sbin/camcontrol/camcontrol.c

   1 /*
   2  * Copyright (c) 1997-2007 Kenneth D. Merry
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. The name of the author may not be used to endorse or promote products
  14  *    derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/ioctl.h>
  33 #include <sys/stdint.h>
  34 #include <sys/types.h>
  35 #include <sys/endian.h>
  36
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41 #include <fcntl.h>
  42 #include <ctype.h>
  43 #include <err.h>
  44 #include <libutil.h>
  45
  46 #include <cam/cam.h>
  47 #include <cam/cam_debug.h>
  48 #include <cam/cam_ccb.h>
  49 #include <cam/scsi/scsi_all.h>
  50 #include <cam/scsi/scsi_da.h>
  51 #include <cam/scsi/scsi_pass.h>
  52 #include <cam/scsi/scsi_message.h>
  53 #include <cam/ata/ata_all.h>
  54 #include <camlib.h>
  55 #include "camcontrol.h"
  56
  57 typedef enum {
  58         CAM_CMD_NONE            = 0x00000000,
  59         CAM_CMD_DEVLIST         = 0x00000001,
  60         CAM_CMD_TUR             = 0x00000002,
  61         CAM_CMD_INQUIRY         = 0x00000003,
  62         CAM_CMD_STARTSTOP       = 0x00000004,
  63         CAM_CMD_RESCAN          = 0x00000005,
  64         CAM_CMD_READ_DEFECTS    = 0x00000006,
  65         CAM_CMD_MODE_PAGE       = 0x00000007,
  66         CAM_CMD_SCSI_CMD        = 0x00000008,
  67         CAM_CMD_DEVTREE         = 0x00000009,
  68         CAM_CMD_USAGE           = 0x0000000a,
  69         CAM_CMD_DEBUG           = 0x0000000b,
  70         CAM_CMD_RESET           = 0x0000000c,
  71         CAM_CMD_FORMAT          = 0x0000000d,
  72         CAM_CMD_TAG             = 0x0000000e,
  73         CAM_CMD_RATE            = 0x0000000f,
  74         CAM_CMD_DETACH          = 0x00000010,
  75         CAM_CMD_REPORTLUNS      = 0x00000011,
  76         CAM_CMD_READCAP         = 0x00000012,
  77         CAM_CMD_IDENTIFY        = 0x00000013,
  78         CAM_CMD_IDLE            = 0x00000014,
  79         CAM_CMD_STANDBY         = 0x00000015,
  80         CAM_CMD_SLEEP           = 0x00000016
  81 } cam_cmdmask;
  82
  83 typedef enum {
  84         CAM_ARG_NONE            = 0x00000000,
  85         CAM_ARG_VERBOSE         = 0x00000001,
  86         CAM_ARG_DEVICE          = 0x00000002,
  87         CAM_ARG_BUS             = 0x00000004,
  88         CAM_ARG_TARGET          = 0x00000008,
  89         CAM_ARG_LUN             = 0x00000010,
  90         CAM_ARG_EJECT           = 0x00000020,
  91         CAM_ARG_UNIT            = 0x00000040,
  92         CAM_ARG_FORMAT_BLOCK    = 0x00000080,
  93         CAM_ARG_FORMAT_BFI      = 0x00000100,
  94         CAM_ARG_FORMAT_PHYS     = 0x00000200,
  95         CAM_ARG_PLIST           = 0x00000400,
  96         CAM_ARG_GLIST           = 0x00000800,
  97         CAM_ARG_GET_SERIAL      = 0x00001000,
  98         CAM_ARG_GET_STDINQ      = 0x00002000,
  99         CAM_ARG_GET_XFERRATE    = 0x00004000,
 100         CAM_ARG_INQ_MASK        = 0x00007000,
 101         CAM_ARG_MODE_EDIT       = 0x00008000,
 102         CAM_ARG_PAGE_CNTL       = 0x00010000,
 103         CAM_ARG_TIMEOUT         = 0x00020000,
 104         CAM_ARG_CMD_IN          = 0x00040000,
 105         CAM_ARG_CMD_OUT         = 0x00080000,
 106         CAM_ARG_DBD             = 0x00100000,
 107         CAM_ARG_ERR_RECOVER     = 0x00200000,
 108         CAM_ARG_RETRIES         = 0x00400000,
 109         CAM_ARG_START_UNIT      = 0x00800000,
 110         CAM_ARG_DEBUG_INFO      = 0x01000000,
 111         CAM_ARG_DEBUG_TRACE     = 0x02000000,
 112         CAM_ARG_DEBUG_SUBTRACE  = 0x04000000,
 113         CAM_ARG_DEBUG_CDB       = 0x08000000,
 114         CAM_ARG_DEBUG_XPT       = 0x10000000,
 115         CAM_ARG_DEBUG_PERIPH    = 0x20000000,
 116 } cam_argmask;
 117
 118 struct camcontrol_opts {
 119         const char      *optname;
 120         cam_cmdmask     cmdnum;
 121         cam_argmask     argnum;
 122         const char      *subopt;
 123 };
 124
 125 #ifndef MINIMALISTIC
 126 static const char scsicmd_opts[] = "a:c:dfi:o:r";
 127 static const char readdefect_opts[] = "f:GP";
 128 static const char negotiate_opts[] = "acD:M:O:qR:T:UW:";
 129 #endif
 130
 131 struct camcontrol_opts option_table[] = {
 132 #ifndef MINIMALISTIC
 133         {"tur", CAM_CMD_TUR, CAM_ARG_NONE, NULL},
 134         {"inquiry", CAM_CMD_INQUIRY, CAM_ARG_NONE, "DSR"},
 135         {"identify", CAM_CMD_IDENTIFY, CAM_ARG_NONE, NULL},
 136         {"start", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT, NULL},
 137         {"stop", CAM_CMD_STARTSTOP, CAM_ARG_NONE, NULL},
 138         {"load", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT | CAM_ARG_EJECT, NULL},
 139         {"eject", CAM_CMD_STARTSTOP, CAM_ARG_EJECT, NULL},
 140         {"reportluns", CAM_CMD_REPORTLUNS, CAM_ARG_NONE, "clr:"},
 141         {"readcapacity", CAM_CMD_READCAP, CAM_ARG_NONE, "bhHNqs"},
 142 #endif /* MINIMALISTIC */
 143         {"rescan", CAM_CMD_RESCAN, CAM_ARG_NONE, NULL},
 144         {"reset", CAM_CMD_RESET, CAM_ARG_NONE, NULL},
 145 #ifndef MINIMALISTIC
 146         {"cmd", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts},
 147         {"command", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts},
 148         {"defects", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts},
 149         {"defectlist", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts},
 150 #endif /* MINIMALISTIC */
 151         {"devlist", CAM_CMD_DEVTREE, CAM_ARG_NONE, NULL},
 152 #ifndef MINIMALISTIC
 153         {"periphlist", CAM_CMD_DEVLIST, CAM_ARG_NONE, NULL},
 154         {"modepage", CAM_CMD_MODE_PAGE, CAM_ARG_NONE, "bdelm:P:"},
 155         {"tags", CAM_CMD_TAG, CAM_ARG_NONE, "N:q"},
 156         {"negotiate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts},
 157         {"rate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts},
 158         {"debug", CAM_CMD_DEBUG, CAM_ARG_NONE, "IPTSXc"},
 159         {"format", CAM_CMD_FORMAT, CAM_ARG_NONE, "qrwy"},
 160         {"idle", CAM_CMD_IDLE, CAM_ARG_NONE, "t:"},
 161         {"standby", CAM_CMD_STANDBY, CAM_ARG_NONE, "t:"},
 162         {"sleep", CAM_CMD_SLEEP, CAM_ARG_NONE, ""},
 163 #endif /* MINIMALISTIC */
 164         {"help", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
 165         {"-?", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
 166         {"-h", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
 167         {NULL, 0, 0, NULL}
 168 };
 169
 170 typedef enum {
 171         CC_OR_NOT_FOUND,
 172         CC_OR_AMBIGUOUS,
 173         CC_OR_FOUND
 174 } camcontrol_optret;
 175
 176 cam_cmdmask cmdlist;
 177 cam_argmask arglist;
 178
 179
 180 camcontrol_optret getoption(char *arg, cam_cmdmask *cmdnum, cam_argmask *argnum,
 181                             const char **subopt);
 182 #ifndef MINIMALISTIC
 183 static int getdevlist(struct cam_device *device);
 184 #endif /* MINIMALISTIC */
 185 static int getdevtree(void);
 186 #ifndef MINIMALISTIC
 187 static int testunitready(struct cam_device *device, int retry_count,
 188                          int timeout, int quiet);
 189 static int scsistart(struct cam_device *device, int startstop, int loadeject,
 190                      int retry_count, int timeout);
 191 static int scsidoinquiry(struct cam_device *device, int argc, char **argv,
 192                          char *combinedopt, int retry_count, int timeout);
 193 static int scsiinquiry(struct cam_device *device, int retry_count, int timeout);
 194 static int scsiserial(struct cam_device *device, int retry_count, int timeout);
 195 static int camxferrate(struct cam_device *device);
 196 #endif /* MINIMALISTIC */
 197 static int parse_btl(char *tstr, int *bus, int *target, int *lun,
 198                      cam_argmask *arglst);
 199 static int dorescan_or_reset(int argc, char **argv, int rescan);
 200 static int rescan_or_reset_bus(int bus, int rescan);
 201 static int scanlun_or_reset_dev(int bus, int target, int lun, int scan);
 202 #ifndef MINIMALISTIC
 203 static int readdefects(struct cam_device *device, int argc, char **argv,
 204                        char *combinedopt, int retry_count, int timeout);
 205 static void modepage(struct cam_device *device, int argc, char **argv,
 206                      char *combinedopt, int retry_count, int timeout);
 207 static int scsicmd(struct cam_device *device, int argc, char **argv,
 208                    char *combinedopt, int retry_count, int timeout);
 209 static int tagcontrol(struct cam_device *device, int argc, char **argv,
 210                       char *combinedopt);
 211 static void cts_print(struct cam_device *device,
 212                       struct ccb_trans_settings *cts);
 213 static void cpi_print(struct ccb_pathinq *cpi);
 214 static int get_cpi(struct cam_device *device, struct ccb_pathinq *cpi);
 215 static int get_cgd(struct cam_device *device, struct ccb_getdev *cgd);
 216 static int get_print_cts(struct cam_device *device, int user_settings,
 217                          int quiet, struct ccb_trans_settings *cts);
 218 static int ratecontrol(struct cam_device *device, int retry_count,
 219                        int timeout, int argc, char **argv, char *combinedopt);
 220 static int scsiformat(struct cam_device *device, int argc, char **argv,
 221                       char *combinedopt, int retry_count, int timeout);
 222 static int scsireportluns(struct cam_device *device, int argc, char **argv,
 223                           char *combinedopt, int retry_count, int timeout);
 224 static int scsireadcapacity(struct cam_device *device, int argc, char **argv,
 225                             char *combinedopt, int retry_count, int timeout);
 226 static int atapm(struct cam_device *device, int argc, char **argv,
 227                             char *combinedopt, int retry_count, int timeout);
 228 #endif /* MINIMALISTIC */
 229 #ifndef min
 230 #define min(a,b) (((a)<(b))?(a):(b))
 231 #endif
 232 #ifndef max
 233 #define max(a,b) (((a)>(b))?(a):(b))
 234 #endif
 235
 236 camcontrol_optret
 237 getoption(char *arg, cam_cmdmask *cmdnum, cam_argmask *argnum,
 238           const char **subopt)
 239 {
 240         struct camcontrol_opts *opts;
 241         int num_matches = 0;
 242
 243         for (opts = option_table; (opts != NULL) && (opts->optname != NULL);
 244              opts++) {
 245                 if (strncmp(opts->optname, arg, strlen(arg)) == 0) {
 246                         *cmdnum = opts->cmdnum;
 247                         *argnum = opts->argnum;
 248                         *subopt = opts->subopt;
 249                         if (++num_matches > 1)
 250                                 return(CC_OR_AMBIGUOUS);
 251                 }
 252         }
 253
 254         if (num_matches > 0)
 255                 return(CC_OR_FOUND);
 256         else
 257                 return(CC_OR_NOT_FOUND);
 258 }
 259
 260 #ifndef MINIMALISTIC
 261 static int
 262 getdevlist(struct cam_device *device)
 263 {
 264         union ccb *ccb;
 265         char status[32];
 266         int error = 0;
 267
 268         ccb = cam_getccb(device);
 269
 270         ccb->ccb_h.func_code = XPT_GDEVLIST;
 271         ccb->ccb_h.flags = CAM_DIR_NONE;
 272         ccb->ccb_h.retry_count = 1;
 273         ccb->cgdl.index = 0;
 274         ccb->cgdl.status = CAM_GDEVLIST_MORE_DEVS;
 275         while (ccb->cgdl.status == CAM_GDEVLIST_MORE_DEVS) {
 276                 if (cam_send_ccb(device, ccb) < 0) {
 277                         perror("error getting device list");
 278                         cam_freeccb(ccb);
 279                         return(1);
 280                 }
 281
 282                 status[0] = '\0';
 283
 284                 switch (ccb->cgdl.status) {
 285                         case CAM_GDEVLIST_MORE_DEVS:
 286                                 strcpy(status, "MORE");
 287                                 break;
 288                         case CAM_GDEVLIST_LAST_DEVICE:
 289                                 strcpy(status, "LAST");
 290                                 break;
 291                         case CAM_GDEVLIST_LIST_CHANGED:
 292                                 strcpy(status, "CHANGED");
 293                                 break;
 294                         case CAM_GDEVLIST_ERROR:
 295                                 strcpy(status, "ERROR");
 296                                 error = 1;
 297                                 break;
 298                 }
 299
 300                 fprintf(stdout, "%s%d:  generation: %d index: %d status: %s\n",
 301                         ccb->cgdl.periph_name,
 302                         ccb->cgdl.unit_number,
 303                         ccb->cgdl.generation,
 304                         ccb->cgdl.index,
 305                         status);
 306
 307                 /*
 308                  * If the list has changed, we need to start over from the
 309                  * beginning.
 310                  */
 311                 if (ccb->cgdl.status == CAM_GDEVLIST_LIST_CHANGED)
 312                         ccb->cgdl.index = 0;
 313         }
 314
 315         cam_freeccb(ccb);
 316
 317         return(error);
 318 }
 319 #endif /* MINIMALISTIC */
 320
 321 static int
 322 getdevtree(void)
 323 {
 324         union ccb ccb;
 325         int bufsize, fd;
 326         unsigned int i;
 327         int need_close = 0;
 328         int error = 0;
 329         int skip_device = 0;
 330
 331         if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
 332                 warn("couldn't open %s", XPT_DEVICE);
 333                 return(1);
 334         }
 335
 336         bzero(&ccb, sizeof(union ccb));
 337
 338         ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
 339         ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
 340         ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
 341
 342         ccb.ccb_h.func_code = XPT_DEV_MATCH;
 343         bufsize = sizeof(struct dev_match_result) * 100;
 344         ccb.cdm.match_buf_len = bufsize;
 345         ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
 346         if (ccb.cdm.matches == NULL) {
 347                 warnx("can't malloc memory for matches");
 348                 close(fd);
 349                 return(1);
 350         }
 351         ccb.cdm.num_matches = 0;
 352
 353         /*
 354          * We fetch all nodes, since we display most of them in the default
 355          * case, and all in the verbose case.
 356          */
 357         ccb.cdm.num_patterns = 0;
 358         ccb.cdm.pattern_buf_len = 0;
 359
 360         /*
 361          * We do the ioctl multiple times if necessary, in case there are
 362          * more than 100 nodes in the EDT.
 363          */
 364         do {
 365                 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
 366                         warn("error sending CAMIOCOMMAND ioctl");
 367                         error = 1;
 368                         break;
 369                 }
 370
 371                 if ((ccb.ccb_h.status != CAM_REQ_CMP)
 372                  || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
 373                     && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
 374                         warnx("got CAM error %#x, CDM error %d\n",
 375                               ccb.ccb_h.status, ccb.cdm.status);
 376                         error = 1;
 377                         break;
 378                 }
 379
 380                 for (i = 0; i < ccb.cdm.num_matches; i++) {
 381                         switch (ccb.cdm.matches[i].type) {
 382                         case DEV_MATCH_BUS: {
 383                                 struct bus_match_result *bus_result;
 384
 385                                 /*
 386                                  * Only print the bus information if the
 387                                  * user turns on the verbose flag.
 388                                  */
 389                                 if ((arglist & CAM_ARG_VERBOSE) == 0)
 390                                         break;
 391
 392                                 bus_result =
 393                                         &ccb.cdm.matches[i].result.bus_result;
 394
 395                                 if (need_close) {
 396                                         fprintf(stdout, ")\n");
 397                                         need_close = 0;
 398                                 }
 399
 400                                 fprintf(stdout, "scbus%d on %s%d bus %d:\n",
 401                                         bus_result->path_id,
 402                                         bus_result->dev_name,
 403                                         bus_result->unit_number,
 404                                         bus_result->bus_id);
 405                                 break;
 406                         }
 407                         case DEV_MATCH_DEVICE: {
 408                                 struct device_match_result *dev_result;
 409                                 char vendor[16], product[48], revision[16];
 410                                 char tmpstr[256];
 411
 412                                 dev_result =
 413                                      &ccb.cdm.matches[i].result.device_result;
 414
 415                                 if ((dev_result->flags
 416                                      & DEV_RESULT_UNCONFIGURED)
 417                                  && ((arglist & CAM_ARG_VERBOSE) == 0)) {
 418                                         skip_device = 1;
 419                                         break;
 420                                 } else
 421                                         skip_device = 0;
 422
 423                                 if (dev_result->protocol == PROTO_SCSI) {
 424                                     cam_strvis(vendor, dev_result->inq_data.vendor,
 425                                            sizeof(dev_result->inq_data.vendor),
 426                                            sizeof(vendor));
 427                                     cam_strvis(product,
 428                                            dev_result->inq_data.product,
 429                                            sizeof(dev_result->inq_data.product),
 430                                            sizeof(product));
 431                                     cam_strvis(revision,
 432                                            dev_result->inq_data.revision,
 433                                           sizeof(dev_result->inq_data.revision),
 434                                            sizeof(revision));
 435                                     sprintf(tmpstr, "<%s %s %s>", vendor, product,
 436                                         revision);
 437                                 } else if (dev_result->protocol == PROTO_ATA ||
 438                                     dev_result->protocol == PROTO_SATAPM) {
 439                                     cam_strvis(product,
 440                                            dev_result->ident_data.model,
 441                                            sizeof(dev_result->ident_data.model),
 442                                            sizeof(product));
 443                                     cam_strvis(revision,
 444                                            dev_result->ident_data.revision,
 445                                           sizeof(dev_result->ident_data.revision),
 446                                            sizeof(revision));
 447                                     sprintf(tmpstr, "<%s %s>", product,
 448                                         revision);
 449                                 } else {
 450                                     sprintf(tmpstr, "<>");
 451                                 }
 452                                 if (need_close) {
 453                                         fprintf(stdout, ")\n");
 454                                         need_close = 0;
 455                                 }
 456
 457                                 fprintf(stdout, "%-33s  at scbus%d "
 458                                         "target %d lun %d (",
 459                                         tmpstr,
 460                                         dev_result->path_id,
 461                                         dev_result->target_id,
 462                                         dev_result->target_lun);
 463
 464                                 need_close = 1;
 465
 466                                 break;
 467                         }
 468                         case DEV_MATCH_PERIPH: {
 469                                 struct periph_match_result *periph_result;
 470
 471                                 periph_result =
 472                                       &ccb.cdm.matches[i].result.periph_result;
 473
 474                                 if (skip_device != 0)
 475                                         break;
 476
 477                                 if (need_close > 1)
 478                                         fprintf(stdout, ",");
 479
 480                                 fprintf(stdout, "%s%d",
 481                                         periph_result->periph_name,
 482                                         periph_result->unit_number);
 483
 484                                 need_close++;
 485                                 break;
 486                         }
 487                         default:
 488                                 fprintf(stdout, "unknown match type\n");
 489                                 break;
 490                         }
 491                 }
 492
 493         } while ((ccb.ccb_h.status == CAM_REQ_CMP)
 494                 && (ccb.cdm.status == CAM_DEV_MATCH_MORE));
 495
 496         if (need_close)
 497                 fprintf(stdout, ")\n");
 498
 499         close(fd);
 500
 501         return(error);
 502 }
 503
 504 #ifndef MINIMALISTIC
 505 static int
 506 testunitready(struct cam_device *device, int retry_count, int timeout,
 507               int quiet)
 508 {
 509         int error = 0;
 510         union ccb *ccb;
 511
 512         ccb = cam_getccb(device);
 513
 514         scsi_test_unit_ready(&ccb->csio,
 515                              /* retries */ retry_count,
 516                              /* cbfcnp */ NULL,
 517                              /* tag_action */ MSG_SIMPLE_Q_TAG,
 518                              /* sense_len */ SSD_FULL_SIZE,
 519                              /* timeout */ timeout ? timeout : 5000);
 520
 521         /* Disable freezing the device queue */
 522         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
 523
 524         if (arglist & CAM_ARG_ERR_RECOVER)
 525                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
 526
 527         if (cam_send_ccb(device, ccb) < 0) {
 528                 if (quiet == 0)
 529                         perror("error sending test unit ready");
 530
 531                 if (arglist & CAM_ARG_VERBOSE) {
 532                         cam_error_print(device, ccb, CAM_ESF_ALL,
 533                                         CAM_EPF_ALL, stderr);
 534                 }
 535
 536                 cam_freeccb(ccb);
 537                 return(1);
 538         }
 539
 540         if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
 541                 if (quiet == 0)
 542                         fprintf(stdout, "Unit is ready\n");
 543         } else {
 544                 if (quiet == 0)
 545                         fprintf(stdout, "Unit is not ready\n");
 546                 error = 1;
 547
 548                 if (arglist & CAM_ARG_VERBOSE) {
 549                         cam_error_print(device, ccb, CAM_ESF_ALL,
 550                                         CAM_EPF_ALL, stderr);
 551                 }
 552         }
 553
 554         cam_freeccb(ccb);
 555
 556         return(error);
 557 }
 558
 559 static int
 560 scsistart(struct cam_device *device, int startstop, int loadeject,
 561           int retry_count, int timeout)
 562 {
 563         union ccb *ccb;
 564         int error = 0;
 565
 566         ccb = cam_getccb(device);
 567
 568         /*
 569          * If we're stopping, send an ordered tag so the drive in question
 570          * will finish any previously queued writes before stopping.  If
 571          * the device isn't capable of tagged queueing, or if tagged
 572          * queueing is turned off, the tag action is a no-op.
 573          */
 574         scsi_start_stop(&ccb->csio,
 575                         /* retries */ retry_count,
 576                         /* cbfcnp */ NULL,
 577                         /* tag_action */ startstop ? MSG_SIMPLE_Q_TAG :
 578                                                      MSG_ORDERED_Q_TAG,
 579                         /* start/stop */ startstop,
 580                         /* load_eject */ loadeject,
 581                         /* immediate */ 0,
 582                         /* sense_len */ SSD_FULL_SIZE,
 583                         /* timeout */ timeout ? timeout : 120000);
 584
 585         /* Disable freezing the device queue */
 586         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
 587
 588         if (arglist & CAM_ARG_ERR_RECOVER)
 589                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
 590
 591         if (cam_send_ccb(device, ccb) < 0) {
 592                 perror("error sending start unit");
 593
 594                 if (arglist & CAM_ARG_VERBOSE) {
 595                         cam_error_print(device, ccb, CAM_ESF_ALL,
 596                                         CAM_EPF_ALL, stderr);
 597                 }
 598
 599                 cam_freeccb(ccb);
 600                 return(1);
 601         }
 602
 603         if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
 604                 if (startstop) {
 605                         fprintf(stdout, "Unit started successfully");
 606                         if (loadeject)
 607                                 fprintf(stdout,", Media loaded\n");
 608                         else
 609                                 fprintf(stdout,"\n");
 610                 } else {
 611                         fprintf(stdout, "Unit stopped successfully");
 612                         if (loadeject)
 613                                 fprintf(stdout, ", Media ejected\n");
 614                         else
 615                                 fprintf(stdout, "\n");
 616                 }
 617         else {
 618                 error = 1;
 619                 if (startstop)
 620                         fprintf(stdout,
 621                                 "Error received from start unit command\n");
 622                 else
 623                         fprintf(stdout,
 624                                 "Error received from stop unit command\n");
 625
 626                 if (arglist & CAM_ARG_VERBOSE) {
 627                         cam_error_print(device, ccb, CAM_ESF_ALL,
 628                                         CAM_EPF_ALL, stderr);
 629                 }
 630         }
 631
 632         cam_freeccb(ccb);
 633
 634         return(error);
 635 }
 636
 637 static int
 638 scsidoinquiry(struct cam_device *device, int argc, char **argv,
 639               char *combinedopt, int retry_count, int timeout)
 640 {
 641         int c;
 642         int error = 0;
 643
 644         while ((c = getopt(argc, argv, combinedopt)) != -1) {
 645                 switch(c) {
 646                 case 'D':
 647                         arglist |= CAM_ARG_GET_STDINQ;
 648                         break;
 649                 case 'R':
 650                         arglist |= CAM_ARG_GET_XFERRATE;
 651                         break;
 652                 case 'S':
 653                         arglist |= CAM_ARG_GET_SERIAL;
 654                         break;
 655                 default:
 656                         break;
 657                 }
 658         }
 659
 660         /*
 661          * If the user didn't specify any inquiry options, he wants all of
 662          * them.
 663          */
 664         if ((arglist & CAM_ARG_INQ_MASK) == 0)
 665                 arglist |= CAM_ARG_INQ_MASK;
 666
 667         if (arglist & CAM_ARG_GET_STDINQ)
 668                 error = scsiinquiry(device, retry_count, timeout);
 669
 670         if (error != 0)
 671                 return(error);
 672
 673         if (arglist & CAM_ARG_GET_SERIAL)
 674                 scsiserial(device, retry_count, timeout);
 675
 676         if (error != 0)
 677                 return(error);
 678
 679         if (arglist & CAM_ARG_GET_XFERRATE)
 680                 error = camxferrate(device);
 681
 682         return(error);
 683 }
 684
 685 static int
 686 scsiinquiry(struct cam_device *device, int retry_count, int timeout)
 687 {
 688         union ccb *ccb;
 689         struct scsi_inquiry_data *inq_buf;
 690         int error = 0;
 691
 692         ccb = cam_getccb(device);
 693
 694         if (ccb == NULL) {
 695                 warnx("couldn't allocate CCB");
 696                 return(1);
 697         }
 698
 699         /* cam_getccb cleans up the header, caller has to zero the payload */
 700         bzero(&(&ccb->ccb_h)[1],
 701               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
 702
 703         inq_buf = (struct scsi_inquiry_data *)malloc(
 704                 sizeof(struct scsi_inquiry_data));
 705
 706         if (inq_buf == NULL) {
 707                 cam_freeccb(ccb);
 708                 warnx("can't malloc memory for inquiry\n");
 709                 return(1);
 710         }
 711         bzero(inq_buf, sizeof(*inq_buf));
 712
 713         /*
 714          * Note that although the size of the inquiry buffer is the full
 715          * 256 bytes specified in the SCSI spec, we only tell the device
 716          * that we have allocated SHORT_INQUIRY_LENGTH bytes.  There are
 717          * two reasons for this:
 718          *
 719          *  - The SCSI spec says that when a length field is only 1 byte,
 720          *    a value of 0 will be interpreted as 256.  Therefore
 721          *    scsi_inquiry() will convert an inq_len (which is passed in as
 722          *    a u_int32_t, but the field in the CDB is only 1 byte) of 256
 723          *    to 0.  Evidently, very few devices meet the spec in that
 724          *    regard.  Some devices, like many Seagate disks, take the 0 as
 725          *    0, and don't return any data.  One Pioneer DVD-R drive
 726          *    returns more data than the command asked for.
 727          *
 728          *    So, since there are numerous devices that just don't work
 729          *    right with the full inquiry size, we don't send the full size.
 730          *
 731          *  - The second reason not to use the full inquiry data length is
 732          *    that we don't need it here.  The only reason we issue a
 733          *    standard inquiry is to get the vendor name, device name,
 734          *    and revision so scsi_print_inquiry() can print them.
 735          *
 736          * If, at some point in the future, more inquiry data is needed for
 737          * some reason, this code should use a procedure similar to the
 738          * probe code.  i.e., issue a short inquiry, and determine from
 739          * the additional length passed back from the device how much
 740          * inquiry data the device supports.  Once the amount the device
 741          * supports is determined, issue an inquiry for that amount and no
 742          * more.
 743          *
 744          * KDM, 2/18/2000
 745          */
 746         scsi_inquiry(&ccb->csio,
 747                      /* retries */ retry_count,
 748                      /* cbfcnp */ NULL,
 749                      /* tag_action */ MSG_SIMPLE_Q_TAG,
 750                      /* inq_buf */ (u_int8_t *)inq_buf,
 751                      /* inq_len */ SHORT_INQUIRY_LENGTH,
 752                      /* evpd */ 0,
 753                      /* page_code */ 0,
 754                      /* sense_len */ SSD_FULL_SIZE,
 755                      /* timeout */ timeout ? timeout : 5000);
 756
 757         /* Disable freezing the device queue */
 758         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
 759
 760         if (arglist & CAM_ARG_ERR_RECOVER)
 761                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
 762
 763         if (cam_send_ccb(device, ccb) < 0) {
 764                 perror("error sending SCSI inquiry");
 765
 766                 if (arglist & CAM_ARG_VERBOSE) {
 767                         cam_error_print(device, ccb, CAM_ESF_ALL,
 768                                         CAM_EPF_ALL, stderr);
 769                 }
 770
 771                 cam_freeccb(ccb);
 772                 return(1);
 773         }
 774
 775         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 776                 error = 1;
 777
 778                 if (arglist & CAM_ARG_VERBOSE) {
 779                         cam_error_print(device, ccb, CAM_ESF_ALL,
 780                                         CAM_EPF_ALL, stderr);
 781                 }
 782         }
 783
 784         cam_freeccb(ccb);
 785
 786         if (error != 0) {
 787                 free(inq_buf);
 788                 return(error);
 789         }
 790
 791         fprintf(stdout, "%s%d: ", device->device_name,
 792                 device->dev_unit_num);
 793         scsi_print_inquiry(inq_buf);
 794
 795         free(inq_buf);
 796
 797         return(0);
 798 }
 799
 800 static int
 801 scsiserial(struct cam_device *device, int retry_count, int timeout)
 802 {
 803         union ccb *ccb;
 804         struct scsi_vpd_unit_serial_number *serial_buf;
 805         char serial_num[SVPD_SERIAL_NUM_SIZE + 1];
 806         int error = 0;
 807
 808         ccb = cam_getccb(device);
 809
 810         if (ccb == NULL) {
 811                 warnx("couldn't allocate CCB");
 812                 return(1);
 813         }
 814
 815         /* cam_getccb cleans up the header, caller has to zero the payload */
 816         bzero(&(&ccb->ccb_h)[1],
 817               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
 818
 819         serial_buf = (struct scsi_vpd_unit_serial_number *)
 820                 malloc(sizeof(*serial_buf));
 821
 822         if (serial_buf == NULL) {
 823                 cam_freeccb(ccb);
 824                 warnx("can't malloc memory for serial number");
 825                 return(1);
 826         }
 827
 828         scsi_inquiry(&ccb->csio,
 829                      /*retries*/ retry_count,
 830                      /*cbfcnp*/ NULL,
 831                      /* tag_action */ MSG_SIMPLE_Q_TAG,
 832                      /* inq_buf */ (u_int8_t *)serial_buf,
 833                      /* inq_len */ sizeof(*serial_buf),
 834                      /* evpd */ 1,
 835                      /* page_code */ SVPD_UNIT_SERIAL_NUMBER,
 836                      /* sense_len */ SSD_FULL_SIZE,
 837                      /* timeout */ timeout ? timeout : 5000);
 838
 839         /* Disable freezing the device queue */
 840         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
 841
 842         if (arglist & CAM_ARG_ERR_RECOVER)
 843                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
 844
 845         if (cam_send_ccb(device, ccb) < 0) {
 846                 warn("error getting serial number");
 847
 848                 if (arglist & CAM_ARG_VERBOSE) {
 849                         cam_error_print(device, ccb, CAM_ESF_ALL,
 850                                         CAM_EPF_ALL, stderr);
 851                 }
 852
 853                 cam_freeccb(ccb);
 854                 free(serial_buf);
 855                 return(1);
 856         }
 857
 858         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 859                 error = 1;
 860
 861                 if (arglist & CAM_ARG_VERBOSE) {
 862                         cam_error_print(device, ccb, CAM_ESF_ALL,
 863                                         CAM_EPF_ALL, stderr);
 864                 }
 865         }
 866
 867         cam_freeccb(ccb);
 868
 869         if (error != 0) {
 870                 free(serial_buf);
 871                 return(error);
 872         }
 873
 874         bcopy(serial_buf->serial_num, serial_num, serial_buf->length);
 875         serial_num[serial_buf->length] = '\0';
 876
 877         if ((arglist & CAM_ARG_GET_STDINQ)
 878          || (arglist & CAM_ARG_GET_XFERRATE))
 879                 fprintf(stdout, "%s%d: Serial Number ",
 880                         device->device_name, device->dev_unit_num);
 881
 882         fprintf(stdout, "%.60s\n", serial_num);
 883
 884         free(serial_buf);
 885
 886         return(0);
 887 }
 888
 889 static int
 890 camxferrate(struct cam_device *device)
 891 {
 892         struct ccb_pathinq cpi;
 893         u_int32_t freq = 0;
 894         u_int32_t speed = 0;
 895         union ccb *ccb;
 896         u_int mb;
 897         int retval = 0;
 898
 899         if ((retval = get_cpi(device, &cpi)) != 0)
 900                 return (1);
 901
 902         ccb = cam_getccb(device);
 903
 904         if (ccb == NULL) {
 905                 warnx("couldn't allocate CCB");
 906                 return(1);
 907         }
 908
 909         bzero(&(&ccb->ccb_h)[1],
 910               sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr));
 911
 912         ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 913         ccb->cts.type = CTS_TYPE_CURRENT_SETTINGS;
 914
 915         if (((retval = cam_send_ccb(device, ccb)) < 0)
 916          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
 917                 const char error_string[] = "error getting transfer settings";
 918
 919                 if (retval < 0)
 920                         warn(error_string);
 921                 else
 922                         warnx(error_string);
 923
 924                 if (arglist & CAM_ARG_VERBOSE)
 925                         cam_error_print(device, ccb, CAM_ESF_ALL,
 926                                         CAM_EPF_ALL, stderr);
 927
 928                 retval = 1;
 929
 930                 goto xferrate_bailout;
 931
 932         }
 933
 934         speed = cpi.base_transfer_speed;
 935         freq = 0;
 936         if (ccb->cts.transport == XPORT_SPI) {
 937                 struct ccb_trans_settings_spi *spi =
 938                     &ccb->cts.xport_specific.spi;
 939
 940                 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) {
 941                         freq = scsi_calc_syncsrate(spi->sync_period);
 942                         speed = freq;
 943                 }
 944                 if ((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0) {
 945                         speed *= (0x01 << spi->bus_width);
 946                 }
 947         } else if (ccb->cts.transport == XPORT_FC) {
 948                 struct ccb_trans_settings_fc *fc =
 949                     &ccb->cts.xport_specific.fc;
 950
 951                 if (fc->valid & CTS_FC_VALID_SPEED)
 952                         speed = fc->bitrate;
 953         } else if (ccb->cts.transport == XPORT_SAS) {
 954                 struct ccb_trans_settings_sas *sas =
 955                     &ccb->cts.xport_specific.sas;
 956
 957                 if (sas->valid & CTS_SAS_VALID_SPEED)
 958                         speed = sas->bitrate;
 959         } else if (ccb->cts.transport == XPORT_ATA) {
 960                 struct ccb_trans_settings_ata *ata =
 961                     &ccb->cts.xport_specific.ata;
 962
 963                 if (ata->valid & CTS_ATA_VALID_MODE)
 964                         speed = ata_mode2speed(ata->mode);
 965         } else if (ccb->cts.transport == XPORT_SATA) {
 966                 struct  ccb_trans_settings_sata *sata =
 967                     &ccb->cts.xport_specific.sata;
 968
 969                 if (sata->valid & CTS_SATA_VALID_REVISION)
 970                         speed = ata_revision2speed(sata->revision);
 971         }
 972
 973         mb = speed / 1000;
 974         if (mb > 0) {
 975                 fprintf(stdout, "%s%d: %d.%03dMB/s transfers",
 976                         device->device_name, device->dev_unit_num,
 977                         mb, speed % 1000);
 978         } else {
 979                 fprintf(stdout, "%s%d: %dKB/s transfers",
 980                         device->device_name, device->dev_unit_num,
 981                         speed);
 982         }
 983
 984         if (ccb->cts.transport == XPORT_SPI) {
 985                 struct ccb_trans_settings_spi *spi =
 986                     &ccb->cts.xport_specific.spi;
 987
 988                 if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0)
 989                  && (spi->sync_offset != 0))
 990                         fprintf(stdout, " (%d.%03dMHz, offset %d", freq / 1000,
 991                                 freq % 1000, spi->sync_offset);
 992
 993                 if (((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0)
 994                  && (spi->bus_width > 0)) {
 995                         if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0)
 996                          && (spi->sync_offset != 0)) {
 997                                 fprintf(stdout, ", ");
 998                         } else {
 999                                 fprintf(stdout, " (");
1000                         }
1001                         fprintf(stdout, "%dbit)", 8 * (0x01 << spi->bus_width));
1002                 } else if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0)
1003                  && (spi->sync_offset != 0)) {
1004                         fprintf(stdout, ")");
1005                 }
1006         } else if (ccb->cts.transport == XPORT_ATA) {
1007                 struct ccb_trans_settings_ata *ata =
1008                     &ccb->cts.xport_specific.ata;
1009
1010                 printf(" (");
1011                 if (ata->valid & CTS_ATA_VALID_MODE)
1012                         printf("%s, ", ata_mode2string(ata->mode));
1013                 if ((ata->valid & CTS_ATA_VALID_ATAPI) && ata->atapi != 0)
1014                         printf("ATAPI %dbytes, ", ata->atapi);
1015                 if (ata->valid & CTS_ATA_VALID_BYTECOUNT)
1016                         printf("PIO %dbytes", ata->bytecount);
1017                 printf(")");
1018         } else if (ccb->cts.transport == XPORT_SATA) {
1019                 struct ccb_trans_settings_sata *sata =
1020                     &ccb->cts.xport_specific.sata;
1021
1022                 printf(" (");
1023                 if (sata->valid & CTS_SATA_VALID_REVISION)
1024                         printf("SATA %d.x, ", sata->revision);
1025                 else
1026                         printf("SATA, ");
1027                 if (sata->valid & CTS_SATA_VALID_MODE)
1028                         printf("%s, ", ata_mode2string(sata->mode));
1029                 if ((sata->valid & CTS_SATA_VALID_ATAPI) && sata->atapi != 0)
1030                         printf("ATAPI %dbytes, ", sata->atapi);
1031                 if (sata->valid & CTS_SATA_VALID_BYTECOUNT)
1032                         printf("PIO %dbytes", sata->bytecount);
1033                 printf(")");
1034         }
1035
1036         if (ccb->cts.protocol == PROTO_SCSI) {
1037                 struct ccb_trans_settings_scsi *scsi =
1038                     &ccb->cts.proto_specific.scsi;
1039                 if (scsi->valid & CTS_SCSI_VALID_TQ) {
1040                         if (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) {
1041                                 fprintf(stdout, ", Command Queueing Enabled");
1042                         }
1043                 }
1044         }
1045
1046         fprintf(stdout, "\n");
1047
1048 xferrate_bailout:
1049
1050         cam_freeccb(ccb);
1051
1052         return(retval);
1053 }
1054
1055 static void
1056 atacapprint(struct ata_params *parm)
1057 {
1058         u_int32_t lbasize = (u_int32_t)parm->lba_size_1 |
1059                                 ((u_int32_t)parm->lba_size_2 << 16);
1060
1061         u_int64_t lbasize48 = ((u_int64_t)parm->lba_size48_1) |
1062                                 ((u_int64_t)parm->lba_size48_2 << 16) |
1063                                 ((u_int64_t)parm->lba_size48_3 << 32) |
1064                                 ((u_int64_t)parm->lba_size48_4 << 48);
1065
1066         printf("\n");
1067         printf("protocol              ");
1068         printf("ATA/ATAPI-%d", ata_version(parm->version_major));
1069         if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
1070                 if (parm->satacapabilities & ATA_SATA_GEN3)
1071                         printf(" SATA 3.x\n");
1072                 else if (parm->satacapabilities & ATA_SATA_GEN2)
1073                         printf(" SATA 2.x\n");
1074                 else if (parm->satacapabilities & ATA_SATA_GEN1)
1075                         printf(" SATA 1.x\n");
1076                 else
1077                         printf(" SATA\n");
1078         }
1079         else
1080                 printf("\n");
1081         printf("device model          %.40s\n", parm->model);
1082         printf("firmware revision     %.8s\n", parm->revision);
1083         printf("serial number         %.20s\n", parm->serial);
1084         if (parm->enabled.extension & ATA_SUPPORT_64BITWWN) {
1085                 printf("WWN                   %02x%02x%02x%02x\n",
1086                     parm->wwn[0], parm->wwn[1], parm->wwn[2], parm->wwn[3]);
1087         }
1088         if (parm->enabled.extension & ATA_SUPPORT_MEDIASN) {
1089                 printf("media serial number   %.30s\n",
1090                     parm->media_serial);
1091         }
1092
1093         printf("cylinders             %d\n", parm->cylinders);
1094         printf("heads                 %d\n", parm->heads);
1095         printf("sectors/track         %d\n", parm->sectors);
1096         printf("sector size           logical %u, physical %lu, offset %lu\n",
1097             ata_logical_sector_size(parm),
1098             (unsigned long)ata_physical_sector_size(parm),
1099             (unsigned long)ata_logical_sector_offset(parm));
1100
1101         if (parm->config == ATA_PROTO_CFA ||
1102             (parm->support.command2 & ATA_SUPPORT_CFA))
1103                 printf("CFA supported\n");
1104
1105         printf("LBA%ssupported         ",
1106                 parm->capabilities1 & ATA_SUPPORT_LBA ? " " : " not ");
1107         if (lbasize)
1108                 printf("%d sectors\n", lbasize);
1109         else
1110                 printf("\n");
1111
1112         printf("LBA48%ssupported       ",
1113                 parm->support.command2 & ATA_SUPPORT_ADDRESS48 ? " " : " not ");
1114         if (lbasize48)
1115                 printf("%ju sectors\n", (uintmax_t)lbasize48);
1116         else
1117                 printf("\n");
1118
1119         printf("PIO supported         PIO");
1120         switch (ata_max_pmode(parm)) {
1121         case ATA_PIO4:
1122                 printf("4");
1123                 break;
1124         case ATA_PIO3:
1125                 printf("3");
1126                 break;
1127         case ATA_PIO2:
1128                 printf("2");
1129                 break;
1130         case ATA_PIO1:
1131                 printf("1");
1132                 break;
1133         default:
1134                 printf("0");
1135         }
1136         if ((parm->capabilities1 & ATA_SUPPORT_IORDY) == 0)
1137                 printf(" w/o IORDY");
1138         printf("\n");
1139
1140         printf("DMA%ssupported         ",
1141                 parm->capabilities1 & ATA_SUPPORT_DMA ? " " : " not ");
1142         if (parm->capabilities1 & ATA_SUPPORT_DMA) {
1143                 if (parm->mwdmamodes & 0xff) {
1144                         printf("WDMA");
1145                         if (parm->mwdmamodes & 0x04)
1146                                 printf("2");
1147                         else if (parm->mwdmamodes & 0x02)
1148                                 printf("1");
1149                         else if (parm->mwdmamodes & 0x01)
1150                                 printf("0");
1151                         printf(" ");
1152                 }
1153                 if ((parm->atavalid & ATA_FLAG_88) &&
1154                     (parm->udmamodes & 0xff)) {
1155                         printf("UDMA");
1156                         if (parm->udmamodes & 0x40)
1157                                 printf("6");
1158                         else if (parm->udmamodes & 0x20)
1159                                 printf("5");
1160                         else if (parm->udmamodes & 0x10)
1161                                 printf("4");
1162                         else if (parm->udmamodes & 0x08)
1163                                 printf("3");
1164                         else if (parm->udmamodes & 0x04)
1165                                 printf("2");
1166                         else if (parm->udmamodes & 0x02)
1167                                 printf("1");
1168                         else if (parm->udmamodes & 0x01)
1169                                 printf("0");
1170                         printf(" ");
1171                 }
1172         }
1173         printf("\n");
1174
1175         if (parm->media_rotation_rate == 1) {
1176                 printf("media RPM             non-rotating\n");
1177         } else if (parm->media_rotation_rate >= 0x0401 &&
1178             parm->media_rotation_rate <= 0xFFFE) {
1179                 printf("media RPM             %d\n",
1180                         parm->media_rotation_rate);
1181         }
1182
1183         printf("\nFeature                      "
1184                 "Support  Enabled   Value           Vendor\n");
1185         printf("read ahead                     %s       %s\n",
1186                 parm->support.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no",
1187                 parm->enabled.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no");
1188         printf("write cache                    %s       %s\n",
1189                 parm->support.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no",
1190                 parm->enabled.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no");
1191         printf("flush cache                    %s       %s\n",
1192                 parm->support.command2 & ATA_SUPPORT_FLUSHCACHE ? "yes" : "no",
1193                 parm->enabled.command2 & ATA_SUPPORT_FLUSHCACHE ? "yes" : "no");
1194         printf("overlap                        %s\n",
1195                 parm->capabilities1 & ATA_SUPPORT_OVERLAP ? "yes" : "no");
1196         printf("Tagged Command Queuing (TCQ)   %s       %s",
1197                 parm->support.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no",
1198                 parm->enabled.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no");
1199                 if (parm->support.command2 & ATA_SUPPORT_QUEUED) {
1200                         printf("        %d tags\n",
1201                             ATA_QUEUE_LEN(parm->queue) + 1);
1202                 } else
1203                         printf("\n");
1204         printf("Native Command Queuing (NCQ)   ");
1205         if (parm->satacapabilities != 0xffff &&
1206             (parm->satacapabilities & ATA_SUPPORT_NCQ)) {
1207                 printf("yes             %d tags\n",
1208                     ATA_QUEUE_LEN(parm->queue) + 1);
1209         } else
1210                 printf("no\n");
1211         printf("SMART                          %s       %s\n",
1212                 parm->support.command1 & ATA_SUPPORT_SMART ? "yes" : "no",
1213                 parm->enabled.command1 & ATA_SUPPORT_SMART ? "yes" : "no");
1214         printf("microcode download             %s       %s\n",
1215                 parm->support.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no",
1216                 parm->enabled.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no");
1217         printf("security                       %s       %s\n",
1218                 parm->support.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no",
1219                 parm->enabled.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no");
1220         printf("power management               %s       %s\n",
1221                 parm->support.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no",
1222                 parm->enabled.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no");
1223         printf("advanced power management      %s       %s",
1224                 parm->support.command2 & ATA_SUPPORT_APM ? "yes" : "no",
1225                 parm->enabled.command2 & ATA_SUPPORT_APM ? "yes" : "no");
1226                 if (parm->support.command2 & ATA_SUPPORT_APM) {
1227                         printf("        %d/0x%02X\n",
1228                             parm->apm_value, parm->apm_value);
1229                 } else
1230                         printf("\n");
1231         printf("automatic acoustic management  %s       %s",
1232                 parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no",
1233                 parm->enabled.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no");
1234                 if (parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC) {
1235                         printf("        %d/0x%02X       %d/0x%02X\n",
1236                             ATA_ACOUSTIC_CURRENT(parm->acoustic),
1237                             ATA_ACOUSTIC_CURRENT(parm->acoustic),
1238                             ATA_ACOUSTIC_VENDOR(parm->acoustic),
1239                             ATA_ACOUSTIC_VENDOR(parm->acoustic));
1240                 } else
1241                         printf("\n");
1242         printf("media status notification      %s       %s\n",
1243                 parm->support.command2 & ATA_SUPPORT_NOTIFY ? "yes" : "no",
1244                 parm->enabled.command2 & ATA_SUPPORT_NOTIFY ? "yes" : "no");
1245         printf("power-up in Standby            %s       %s\n",
1246                 parm->support.command2 & ATA_SUPPORT_STANDBY ? "yes" : "no",
1247                 parm->enabled.command2 & ATA_SUPPORT_STANDBY ? "yes" : "no");
1248         printf("write-read-verify              %s       %s",
1249                 parm->support2 & ATA_SUPPORT_WRITEREADVERIFY ? "yes" : "no",
1250                 parm->enabled2 & ATA_SUPPORT_WRITEREADVERIFY ? "yes" : "no");
1251                 if (parm->support2 & ATA_SUPPORT_WRITEREADVERIFY) {
1252                         printf("        %d/0x%x\n",
1253                             parm->wrv_mode, parm->wrv_mode);
1254                 } else
1255                         printf("\n");
1256         printf("unload                         %s       %s\n",
1257                 parm->support.extension & ATA_SUPPORT_UNLOAD ? "yes" : "no",
1258                 parm->enabled.extension & ATA_SUPPORT_UNLOAD ? "yes" : "no");
1259         printf("free-fall                      %s       %s\n",
1260                 parm->support2 & ATA_SUPPORT_FREEFALL ? "yes" : "no",
1261                 parm->enabled2 & ATA_SUPPORT_FREEFALL ? "yes" : "no");
1262         printf("data set management (TRIM)     %s\n",
1263                 parm->support_dsm & ATA_SUPPORT_DSM_TRIM ? "yes" : "no");
1264 }
1265
1266 static int
1267 ataidentify(struct cam_device *device, int retry_count, int timeout)
1268 {
1269         union ccb *ccb;
1270         struct ata_params *ident_buf;
1271         struct ccb_getdev cgd;
1272         u_int i, error = 0;
1273         int16_t *ptr;
1274
1275         if (get_cgd(device, &cgd) != 0) {
1276                 warnx("couldn't get CGD");
1277                 return(1);
1278         }
1279         ccb = cam_getccb(device);
1280
1281         if (ccb == NULL) {
1282                 warnx("couldn't allocate CCB");
1283                 return(1);
1284         }
1285
1286         /* cam_getccb cleans up the header, caller has to zero the payload */
1287         bzero(&(&ccb->ccb_h)[1],
1288               sizeof(struct ccb_ataio) - sizeof(struct ccb_hdr));
1289
1290         ptr = (uint16_t *)malloc(sizeof(struct ata_params));
1291
1292         if (ptr == NULL) {
1293                 cam_freeccb(ccb);
1294                 warnx("can't malloc memory for identify\n");
1295                 return(1);
1296         }
1297         bzero(ptr, sizeof(struct ata_params));
1298
1299         cam_fill_ataio(&ccb->ataio,
1300                       retry_count,
1301                       NULL,
1302                       /*flags*/CAM_DIR_IN,
1303                       MSG_SIMPLE_Q_TAG,
1304                       /*data_ptr*/(u_int8_t *)ptr,
1305                       /*dxfer_len*/sizeof(struct ata_params),
1306                       timeout ? timeout : 30 * 1000);
1307         if (cgd.protocol == PROTO_ATA)
1308                 ata_28bit_cmd(&ccb->ataio, ATA_ATA_IDENTIFY, 0, 0, 0);
1309         else
1310                 ata_28bit_cmd(&ccb->ataio, ATA_ATAPI_IDENTIFY, 0, 0, 0);
1311
1312         /* Disable freezing the device queue */
1313         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1314
1315         if (arglist & CAM_ARG_ERR_RECOVER)
1316                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
1317
1318         if (cam_send_ccb(device, ccb) < 0) {
1319                 perror("error sending ATA identify");
1320
1321                 if (arglist & CAM_ARG_VERBOSE) {
1322                         cam_error_print(device, ccb, CAM_ESF_ALL,
1323                                         CAM_EPF_ALL, stderr);
1324                 }
1325
1326                 free(ptr);
1327                 cam_freeccb(ccb);
1328                 return(1);
1329         }
1330
1331         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1332                 error = 1;
1333
1334                 if (arglist & CAM_ARG_VERBOSE) {
1335                         cam_error_print(device, ccb, CAM_ESF_ALL,
1336                                         CAM_EPF_ALL, stderr);
1337                 }
1338         }
1339
1340         cam_freeccb(ccb);
1341
1342         if (error != 0) {
1343                 free(ptr);
1344                 return(error);
1345         }
1346
1347         for (i = 0; i < sizeof(struct ata_params) / 2; i++)
1348                 ptr[i] = le16toh(ptr[i]);
1349         if (arglist & CAM_ARG_VERBOSE) {
1350                 fprintf(stdout, "%s%d: Raw identify data:\n",
1351                     device->device_name, device->dev_unit_num);
1352                 for (i = 0; i < sizeof(struct ata_params) / 2; i++) {
1353                         if ((i % 8) == 0)
1354                             fprintf(stdout, " %3d: ", i);
1355                         fprintf(stdout, "%04x ", (uint16_t)ptr[i]);
1356                         if ((i % 8) == 7)
1357                             fprintf(stdout, "\n");
1358                 }
1359         }
1360         ident_buf = (struct ata_params *)ptr;
1361         if (strncmp(ident_buf->model, "FX", 2) &&
1362             strncmp(ident_buf->model, "NEC", 3) &&
1363             strncmp(ident_buf->model, "Pioneer", 7) &&
1364             strncmp(ident_buf->model, "SHARP", 5)) {
1365                 ata_bswap(ident_buf->model, sizeof(ident_buf->model));
1366                 ata_bswap(ident_buf->revision, sizeof(ident_buf->revision));
1367                 ata_bswap(ident_buf->serial, sizeof(ident_buf->serial));
1368                 ata_bswap(ident_buf->media_serial, sizeof(ident_buf->media_serial));
1369         }
1370         ata_btrim(ident_buf->model, sizeof(ident_buf->model));
1371         ata_bpack(ident_buf->model, ident_buf->model, sizeof(ident_buf->model));
1372         ata_btrim(ident_buf->revision, sizeof(ident_buf->revision));
1373         ata_bpack(ident_buf->revision, ident_buf->revision, sizeof(ident_buf->revision));
1374         ata_btrim(ident_buf->serial, sizeof(ident_buf->serial));
1375         ata_bpack(ident_buf->serial, ident_buf->serial, sizeof(ident_buf->serial));
1376         ata_btrim(ident_buf->media_serial, sizeof(ident_buf->media_serial));
1377         ata_bpack(ident_buf->media_serial, ident_buf->media_serial,
1378             sizeof(ident_buf->media_serial));
1379
1380         fprintf(stdout, "%s%d: ", device->device_name,
1381                 device->dev_unit_num);
1382         ata_print_ident(ident_buf);
1383         camxferrate(device);
1384         atacapprint(ident_buf);
1385
1386         free(ident_buf);
1387
1388         return(0);
1389 }
1390 #endif /* MINIMALISTIC */
1391
1392 /*
1393  * Parse out a bus, or a bus, target and lun in the following
1394  * format:
1395  * bus
1396  * bus:target
1397  * bus:target:lun
1398  *
1399  * Returns the number of parsed components, or 0.
1400  */
1401 static int
1402 parse_btl(char *tstr, int *bus, int *target, int *lun, cam_argmask *arglst)
1403 {
1404         char *tmpstr;
1405         int convs = 0;
1406
1407         while (isspace(*tstr) && (*tstr != '\0'))
1408                 tstr++;
1409
1410         tmpstr = (char *)strtok(tstr, ":");
1411         if ((tmpstr != NULL) && (*tmpstr != '\0')) {
1412                 *bus = strtol(tmpstr, NULL, 0);
1413                 *arglst |= CAM_ARG_BUS;
1414                 convs++;
1415                 tmpstr = (char *)strtok(NULL, ":");
1416                 if ((tmpstr != NULL) && (*tmpstr != '\0')) {
1417                         *target = strtol(tmpstr, NULL, 0);
1418                         *arglst |= CAM_ARG_TARGET;
1419                         convs++;
1420                         tmpstr = (char *)strtok(NULL, ":");
1421                         if ((tmpstr != NULL) && (*tmpstr != '\0')) {
1422                                 *lun = strtol(tmpstr, NULL, 0);
1423                                 *arglst |= CAM_ARG_LUN;
1424                                 convs++;
1425                         }
1426                 }
1427         }
1428
1429         return convs;
1430 }
1431
1432 static int
1433 dorescan_or_reset(int argc, char **argv, int rescan)
1434 {
1435         static const char must[] =
1436                 "you must specify \"all\", a bus, or a bus:target:lun to %s";
1437         int rv, error = 0;
1438         int bus = -1, target = -1, lun = -1;
1439         char *tstr;
1440
1441         if (argc < 3) {
1442                 warnx(must, rescan? "rescan" : "reset");
1443                 return(1);
1444         }
1445
1446         tstr = argv[optind];
1447         while (isspace(*tstr) && (*tstr != '\0'))
1448                 tstr++;
1449         if (strncasecmp(tstr, "all", strlen("all")) == 0)
1450                 arglist |= CAM_ARG_BUS;
1451         else {
1452                 rv = parse_btl(argv[optind], &bus, &target, &lun, &arglist);
1453                 if (rv != 1 && rv != 3) {
1454                         warnx(must, rescan? "rescan" : "reset");
1455                         return(1);
1456                 }
1457         }
1458
1459         if ((arglist & CAM_ARG_BUS)
1460             && (arglist & CAM_ARG_TARGET)
1461             && (arglist & CAM_ARG_LUN))
1462                 error = scanlun_or_reset_dev(bus, target, lun, rescan);
1463         else
1464                 error = rescan_or_reset_bus(bus, rescan);
1465
1466         return(error);
1467 }
1468
1469 static int
1470 rescan_or_reset_bus(int bus, int rescan)
1471 {
1472         union ccb ccb, matchccb;
1473         int fd, retval;
1474         int bufsize;
1475
1476         retval = 0;
1477
1478         if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
1479                 warnx("error opening transport layer device %s", XPT_DEVICE);
1480                 warn("%s", XPT_DEVICE);
1481                 return(1);
1482         }
1483
1484         if (bus != -1) {
1485                 ccb.ccb_h.func_code = rescan ? XPT_SCAN_BUS : XPT_RESET_BUS;
1486                 ccb.ccb_h.path_id = bus;
1487                 ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
1488                 ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
1489                 ccb.crcn.flags = CAM_FLAG_NONE;
1490
1491                 /* run this at a low priority */
1492                 ccb.ccb_h.pinfo.priority = 5;
1493
1494                 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
1495                         warn("CAMIOCOMMAND ioctl failed");
1496                         close(fd);
1497                         return(1);
1498                 }
1499
1500                 if ((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
1501                         fprintf(stdout, "%s of bus %d was successful\n",
1502                             rescan ? "Re-scan" : "Reset", bus);
1503                 } else {
1504                         fprintf(stdout, "%s of bus %d returned error %#x\n",
1505                                 rescan ? "Re-scan" : "Reset", bus,
1506                                 ccb.ccb_h.status & CAM_STATUS_MASK);
1507                         retval = 1;
1508                 }
1509
1510                 close(fd);
1511                 return(retval);
1512
1513         }
1514
1515
1516         /*
1517          * The right way to handle this is to modify the xpt so that it can
1518          * handle a wildcarded bus in a rescan or reset CCB.  At the moment
1519          * that isn't implemented, so instead we enumerate the busses and
1520          * send the rescan or reset to those busses in the case where the
1521          * given bus is -1 (wildcard).  We don't send a rescan or reset
1522          * to the xpt bus; sending a rescan to the xpt bus is effectively a
1523          * no-op, sending a rescan to the xpt bus would result in a status of
1524          * CAM_REQ_INVALID.
1525          */
1526         bzero(&(&matchccb.ccb_h)[1],
1527               sizeof(struct ccb_dev_match) - sizeof(struct ccb_hdr));
1528         matchccb.ccb_h.func_code = XPT_DEV_MATCH;
1529         bufsize = sizeof(struct dev_match_result) * 20;
1530         matchccb.cdm.match_buf_len = bufsize;
1531         matchccb.cdm.matches=(struct dev_match_result *)malloc(bufsize);
1532         if (matchccb.cdm.matches == NULL) {
1533                 warnx("can't malloc memory for matches");
1534                 retval = 1;
1535                 goto bailout;
1536         }
1537         matchccb.cdm.num_matches = 0;
1538
1539         matchccb.cdm.num_patterns = 1;
1540         matchccb.cdm.pattern_buf_len = sizeof(struct dev_match_pattern);
1541
1542         matchccb.cdm.patterns = (struct dev_match_pattern *)malloc(
1543                 matchccb.cdm.pattern_buf_len);
1544         if (matchccb.cdm.patterns == NULL) {
1545                 warnx("can't malloc memory for patterns");
1546                 retval = 1;
1547                 goto bailout;
1548         }
1549         matchccb.cdm.patterns[0].type = DEV_MATCH_BUS;
1550         matchccb.cdm.patterns[0].pattern.bus_pattern.flags = BUS_MATCH_ANY;
1551
1552         do {
1553                 unsigned int i;
1554
1555                 if (ioctl(fd, CAMIOCOMMAND, &matchccb) == -1) {
1556                         warn("CAMIOCOMMAND ioctl failed");
1557                         retval = 1;
1558                         goto bailout;
1559                 }
1560
1561                 if ((matchccb.ccb_h.status != CAM_REQ_CMP)
1562                  || ((matchccb.cdm.status != CAM_DEV_MATCH_LAST)
1563                    && (matchccb.cdm.status != CAM_DEV_MATCH_MORE))) {
1564                         warnx("got CAM error %#x, CDM error %d\n",
1565                               matchccb.ccb_h.status, matchccb.cdm.status);
1566                         retval = 1;
1567                         goto bailout;
1568                 }
1569
1570                 for (i = 0; i < matchccb.cdm.num_matches; i++) {
1571                         struct bus_match_result *bus_result;
1572
1573                         /* This shouldn't happen. */
1574                         if (matchccb.cdm.matches[i].type != DEV_MATCH_BUS)
1575                                 continue;
1576
1577                         bus_result = &matchccb.cdm.matches[i].result.bus_result;
1578
1579                         /*
1580                          * We don't want to rescan or reset the xpt bus.
1581                          * See above.
1582                          */
1583                         if ((int)bus_result->path_id == -1)
1584                                 continue;
1585
1586                         ccb.ccb_h.func_code = rescan ? XPT_SCAN_BUS :
1587                                                        XPT_RESET_BUS;
1588                         ccb.ccb_h.path_id = bus_result->path_id;
1589                         ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
1590                         ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
1591                         ccb.crcn.flags = CAM_FLAG_NONE;
1592
1593                         /* run this at a low priority */
1594                         ccb.ccb_h.pinfo.priority = 5;
1595
1596                         if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
1597                                 warn("CAMIOCOMMAND ioctl failed");
1598                                 retval = 1;
1599                                 goto bailout;
1600                         }
1601
1602                         if ((ccb.ccb_h.status & CAM_STATUS_MASK) ==CAM_REQ_CMP){
1603                                 fprintf(stdout, "%s of bus %d was successful\n",
1604                                         rescan? "Re-scan" : "Reset",
1605                                         bus_result->path_id);
1606                         } else {
1607                                 /*
1608                                  * Don't bail out just yet, maybe the other
1609                                  * rescan or reset commands will complete
1610                                  * successfully.
1611                                  */
1612                                 fprintf(stderr, "%s of bus %d returned error "
1613                                         "%#x\n", rescan? "Re-scan" : "Reset",
1614                                         bus_result->path_id,
1615                                         ccb.ccb_h.status & CAM_STATUS_MASK);
1616                                 retval = 1;
1617                         }
1618                 }
1619         } while ((matchccb.ccb_h.status == CAM_REQ_CMP)
1620                  && (matchccb.cdm.status == CAM_DEV_MATCH_MORE));
1621
1622 bailout:
1623
1624         if (fd != -1)
1625                 close(fd);
1626
1627         if (matchccb.cdm.patterns != NULL)
1628                 free(matchccb.cdm.patterns);
1629         if (matchccb.cdm.matches != NULL)
1630                 free(matchccb.cdm.matches);
1631
1632         return(retval);
1633 }
1634
1635 static int
1636 scanlun_or_reset_dev(int bus, int target, int lun, int scan)
1637 {
1638         union ccb ccb;
1639         struct cam_device *device;
1640         int fd;
1641
1642         device = NULL;
1643
1644         if (bus < 0) {
1645                 warnx("invalid bus number %d", bus);
1646                 return(1);
1647         }
1648
1649         if (target < 0) {
1650                 warnx("invalid target number %d", target);
1651                 return(1);
1652         }
1653
1654         if (lun < 0) {
1655                 warnx("invalid lun number %d", lun);
1656                 return(1);
1657         }
1658
1659         fd = -1;
1660
1661         bzero(&ccb, sizeof(union ccb));
1662
1663         if (scan) {
1664                 if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
1665                         warnx("error opening transport layer device %s\n",
1666                             XPT_DEVICE);
1667                         warn("%s", XPT_DEVICE);
1668                         return(1);
1669                 }
1670         } else {
1671                 device = cam_open_btl(bus, target, lun, O_RDWR, NULL);
1672                 if (device == NULL) {
1673                         warnx("%s", cam_errbuf);
1674                         return(1);
1675                 }
1676         }
1677
1678         ccb.ccb_h.func_code = (scan)? XPT_SCAN_LUN : XPT_RESET_DEV;
1679         ccb.ccb_h.path_id = bus;
1680         ccb.ccb_h.target_id = target;
1681         ccb.ccb_h.target_lun = lun;
1682         ccb.ccb_h.timeout = 5000;
1683         ccb.crcn.flags = CAM_FLAG_NONE;
1684
1685         /* run this at a low priority */
1686         ccb.ccb_h.pinfo.priority = 5;
1687
1688         if (scan) {
1689                 if (ioctl(fd, CAMIOCOMMAND, &ccb) < 0) {
1690                         warn("CAMIOCOMMAND ioctl failed");
1691                         close(fd);
1692                         return(1);
1693                 }
1694         } else {
1695                 if (cam_send_ccb(device, &ccb) < 0) {
1696                         warn("error sending XPT_RESET_DEV CCB");
1697                         cam_close_device(device);
1698                         return(1);
1699                 }
1700         }
1701
1702         if (scan)
1703                 close(fd);
1704         else
1705                 cam_close_device(device);
1706
1707         /*
1708          * An error code of CAM_BDR_SENT is normal for a BDR request.
1709          */
1710         if (((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
1711          || ((!scan)
1712           && ((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_BDR_SENT))) {
1713                 fprintf(stdout, "%s of %d:%d:%d was successful\n",
1714                     scan? "Re-scan" : "Reset", bus, target, lun);
1715                 return(0);
1716         } else {
1717                 fprintf(stdout, "%s of %d:%d:%d returned error %#x\n",
1718                     scan? "Re-scan" : "Reset", bus, target, lun,
1719                     ccb.ccb_h.status & CAM_STATUS_MASK);
1720                 return(1);
1721         }
1722 }
1723
1724 #ifndef MINIMALISTIC
1725 static int
1726 readdefects(struct cam_device *device, int argc, char **argv,
1727             char *combinedopt, int retry_count, int timeout)
1728 {
1729         union ccb *ccb = NULL;
1730         struct scsi_read_defect_data_10 *rdd_cdb;
1731         u_int8_t *defect_list = NULL;
1732         u_int32_t dlist_length = 65000;
1733         u_int32_t returned_length = 0;
1734         u_int32_t num_returned = 0;
1735         u_int8_t returned_format;
1736         unsigned int i;
1737         int c, error = 0;
1738         int lists_specified = 0;
1739
1740         while ((c = getopt(argc, argv, combinedopt)) != -1) {
1741                 switch(c){
1742                 case 'f':
1743                 {
1744                         char *tstr;
1745                         tstr = optarg;
1746                         while (isspace(*tstr) && (*tstr != '\0'))
1747                                 tstr++;
1748                         if (strcmp(tstr, "block") == 0)
1749                                 arglist |= CAM_ARG_FORMAT_BLOCK;
1750                         else if (strcmp(tstr, "bfi") == 0)
1751                                 arglist |= CAM_ARG_FORMAT_BFI;
1752                         else if (strcmp(tstr, "phys") == 0)
1753                                 arglist |= CAM_ARG_FORMAT_PHYS;
1754                         else {
1755                                 error = 1;
1756                                 warnx("invalid defect format %s", tstr);
1757                                 goto defect_bailout;
1758                         }
1759                         break;
1760                 }
1761                 case 'G':
1762                         arglist |= CAM_ARG_GLIST;
1763                         break;
1764                 case 'P':
1765                         arglist |= CAM_ARG_PLIST;
1766                         break;
1767                 default:
1768                         break;
1769                 }
1770         }
1771
1772         ccb = cam_getccb(device);
1773
1774         /*
1775          * Hopefully 65000 bytes is enough to hold the defect list.  If it
1776          * isn't, the disk is probably dead already.  We'd have to go with
1777          * 12 byte command (i.e. alloc_length is 32 bits instead of 16)
1778          * to hold them all.
1779          */
1780         defect_list = malloc(dlist_length);
1781         if (defect_list == NULL) {
1782                 warnx("can't malloc memory for defect list");
1783                 error = 1;
1784                 goto defect_bailout;
1785         }
1786
1787         rdd_cdb =(struct scsi_read_defect_data_10 *)&ccb->csio.cdb_io.cdb_bytes;
1788
1789         /*
1790          * cam_getccb() zeros the CCB header only.  So we need to zero the
1791          * payload portion of the ccb.
1792          */
1793         bzero(&(&ccb->ccb_h)[1],
1794               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
1795
1796         cam_fill_csio(&ccb->csio,
1797                       /*retries*/ retry_count,
1798                       /*cbfcnp*/ NULL,
1799                       /*flags*/ CAM_DIR_IN | ((arglist & CAM_ARG_ERR_RECOVER) ?
1800                                               CAM_PASS_ERR_RECOVER : 0),
1801                       /*tag_action*/ MSG_SIMPLE_Q_TAG,
1802                       /*data_ptr*/ defect_list,
1803                       /*dxfer_len*/ dlist_length,
1804                       /*sense_len*/ SSD_FULL_SIZE,
1805                       /*cdb_len*/ sizeof(struct scsi_read_defect_data_10),
1806                       /*timeout*/ timeout ? timeout : 5000);
1807
1808         rdd_cdb->opcode = READ_DEFECT_DATA_10;
1809         if (arglist & CAM_ARG_FORMAT_BLOCK)
1810                 rdd_cdb->format = SRDD10_BLOCK_FORMAT;
1811         else if (arglist & CAM_ARG_FORMAT_BFI)
1812                 rdd_cdb->format = SRDD10_BYTES_FROM_INDEX_FORMAT;
1813         else if (arglist & CAM_ARG_FORMAT_PHYS)
1814                 rdd_cdb->format = SRDD10_PHYSICAL_SECTOR_FORMAT;
1815         else {
1816                 error = 1;
1817                 warnx("no defect list format specified");
1818                 goto defect_bailout;
1819         }
1820         if (arglist & CAM_ARG_PLIST) {
1821                 rdd_cdb->format |= SRDD10_PLIST;
1822                 lists_specified++;
1823         }
1824
1825         if (arglist & CAM_ARG_GLIST) {
1826                 rdd_cdb->format |= SRDD10_GLIST;
1827                 lists_specified++;
1828         }
1829
1830         scsi_ulto2b(dlist_length, rdd_cdb->alloc_length);
1831
1832         /* Disable freezing the device queue */
1833         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1834
1835         if (cam_send_ccb(device, ccb) < 0) {
1836                 perror("error reading defect list");
1837
1838                 if (arglist & CAM_ARG_VERBOSE) {
1839                         cam_error_print(device, ccb, CAM_ESF_ALL,
1840                                         CAM_EPF_ALL, stderr);
1841                 }
1842
1843                 error = 1;
1844                 goto defect_bailout;
1845         }
1846
1847         returned_length = scsi_2btoul(((struct
1848                 scsi_read_defect_data_hdr_10 *)defect_list)->length);
1849
1850         returned_format = ((struct scsi_read_defect_data_hdr_10 *)
1851                         defect_list)->format;
1852
1853         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_SCSI_STATUS_ERROR)
1854          && (ccb->csio.scsi_status == SCSI_STATUS_CHECK_COND)
1855          && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
1856                 struct scsi_sense_data *sense;
1857                 int error_code, sense_key, asc, ascq;
1858
1859                 sense = &ccb->csio.sense_data;
1860                 scsi_extract_sense(sense, &error_code, &sense_key, &asc, &ascq);
1861
1862                 /*
1863                  * According to the SCSI spec, if the disk doesn't support
1864                  * the requested format, it will generally return a sense
1865                  * key of RECOVERED ERROR, and an additional sense code
1866                  * of "DEFECT LIST NOT FOUND".  So, we check for that, and
1867                  * also check to make sure that the returned length is
1868                  * greater than 0, and then print out whatever format the
1869                  * disk gave us.
1870                  */
1871                 if ((sense_key == SSD_KEY_RECOVERED_ERROR)
1872                  && (asc == 0x1c) && (ascq == 0x00)
1873                  && (returned_length > 0)) {
1874                         warnx("requested defect format not available");
1875                         switch(returned_format & SRDDH10_DLIST_FORMAT_MASK) {
1876                         case SRDD10_BLOCK_FORMAT:
1877                                 warnx("Device returned block format");
1878                                 break;
1879                         case SRDD10_BYTES_FROM_INDEX_FORMAT:
1880                                 warnx("Device returned bytes from index"
1881                                       " format");
1882                                 break;
1883                         case SRDD10_PHYSICAL_SECTOR_FORMAT:
1884                                 warnx("Device returned physical sector format");
1885                                 break;
1886                         default:
1887                                 error = 1;
1888                                 warnx("Device returned unknown defect"
1889                                      " data format %#x", returned_format);
1890                                 goto defect_bailout;
1891                                 break; /* NOTREACHED */
1892                         }
1893                 } else {
1894                         error = 1;
1895                         warnx("Error returned from read defect data command");
1896                         if (arglist & CAM_ARG_VERBOSE)
1897                                 cam_error_print(device, ccb, CAM_ESF_ALL,
1898                                                 CAM_EPF_ALL, stderr);
1899                         goto defect_bailout;
1900                 }
1901         } else if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1902                 error = 1;
1903                 warnx("Error returned from read defect data command");
1904                 if (arglist & CAM_ARG_VERBOSE)
1905                         cam_error_print(device, ccb, CAM_ESF_ALL,
1906                                         CAM_EPF_ALL, stderr);
1907                 goto defect_bailout;
1908         }
1909
1910         /*
1911          * XXX KDM  I should probably clean up the printout format for the
1912          * disk defects.
1913          */
1914         switch (returned_format & SRDDH10_DLIST_FORMAT_MASK){
1915                 case SRDDH10_PHYSICAL_SECTOR_FORMAT:
1916                 {
1917                         struct scsi_defect_desc_phys_sector *dlist;
1918
1919                         dlist = (struct scsi_defect_desc_phys_sector *)
1920                                 (defect_list +
1921                                 sizeof(struct scsi_read_defect_data_hdr_10));
1922
1923                         num_returned = returned_length /
1924                                 sizeof(struct scsi_defect_desc_phys_sector);
1925
1926                         fprintf(stderr, "Got %d defect", num_returned);
1927
1928                         if ((lists_specified == 0) || (num_returned == 0)) {
1929                                 fprintf(stderr, "s.\n");
1930                                 break;
1931                         } else if (num_returned == 1)
1932                                 fprintf(stderr, ":\n");
1933                         else
1934                                 fprintf(stderr, "s:\n");
1935
1936                         for (i = 0; i < num_returned; i++) {
1937                                 fprintf(stdout, "%d:%d:%d\n",
1938                                         scsi_3btoul(dlist[i].cylinder),
1939                                         dlist[i].head,
1940                                         scsi_4btoul(dlist[i].sector));
1941                         }
1942                         break;
1943                 }
1944                 case SRDDH10_BYTES_FROM_INDEX_FORMAT:
1945                 {
1946                         struct scsi_defect_desc_bytes_from_index *dlist;
1947
1948                         dlist = (struct scsi_defect_desc_bytes_from_index *)
1949                                 (defect_list +
1950                                 sizeof(struct scsi_read_defect_data_hdr_10));
1951
1952                         num_returned = returned_length /
1953                               sizeof(struct scsi_defect_desc_bytes_from_index);
1954
1955                         fprintf(stderr, "Got %d defect", num_returned);
1956
1957                         if ((lists_specified == 0) || (num_returned == 0)) {
1958                                 fprintf(stderr, "s.\n");
1959                                 break;
1960                         } else if (num_returned == 1)
1961                                 fprintf(stderr, ":\n");
1962                         else
1963                                 fprintf(stderr, "s:\n");
1964
1965                         for (i = 0; i < num_returned; i++) {
1966                                 fprintf(stdout, "%d:%d:%d\n",
1967                                         scsi_3btoul(dlist[i].cylinder),
1968                                         dlist[i].head,
1969                                         scsi_4btoul(dlist[i].bytes_from_index));
1970                         }
1971                         break;
1972                 }
1973                 case SRDDH10_BLOCK_FORMAT:
1974                 {
1975                         struct scsi_defect_desc_block *dlist;
1976
1977                         dlist = (struct scsi_defect_desc_block *)(defect_list +
1978                                 sizeof(struct scsi_read_defect_data_hdr_10));
1979
1980                         num_returned = returned_length /
1981                               sizeof(struct scsi_defect_desc_block);
1982
1983                         fprintf(stderr, "Got %d defect", num_returned);
1984
1985                         if ((lists_specified == 0) || (num_returned == 0)) {
1986                                 fprintf(stderr, "s.\n");
1987                                 break;
1988                         } else if (num_returned == 1)
1989                                 fprintf(stderr, ":\n");
1990                         else
1991                                 fprintf(stderr, "s:\n");
1992
1993                         for (i = 0; i < num_returned; i++)
1994                                 fprintf(stdout, "%u\n",
1995                                         scsi_4btoul(dlist[i].address));
1996                         break;
1997                 }
1998                 default:
1999                         fprintf(stderr, "Unknown defect format %d\n",
2000                                 returned_format & SRDDH10_DLIST_FORMAT_MASK);
2001                         error = 1;
2002                         break;
2003         }
2004 defect_bailout:
2005
2006         if (defect_list != NULL)
2007                 free(defect_list);
2008
2009         if (ccb != NULL)
2010                 cam_freeccb(ccb);
2011
2012         return(error);
2013 }
2014 #endif /* MINIMALISTIC */
2015
2016 #if 0
2017 void
2018 reassignblocks(struct cam_device *device, u_int32_t *blocks, int num_blocks)
2019 {
2020         union ccb *ccb;
2021
2022         ccb = cam_getccb(device);
2023
2024         cam_freeccb(ccb);
2025 }
2026 #endif
2027
2028 #ifndef MINIMALISTIC
2029 void
2030 mode_sense(struct cam_device *device, int mode_page, int page_control,
2031            int dbd, int retry_count, int timeout, u_int8_t *data, int datalen)
2032 {
2033         union ccb *ccb;
2034         int retval;
2035
2036         ccb = cam_getccb(device);
2037
2038         if (ccb == NULL)
2039                 errx(1, "mode_sense: couldn't allocate CCB");
2040
2041         bzero(&(&ccb->ccb_h)[1],
2042               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
2043
2044         scsi_mode_sense(&ccb->csio,
2045                         /* retries */ retry_count,
2046                         /* cbfcnp */ NULL,
2047                         /* tag_action */ MSG_SIMPLE_Q_TAG,
2048                         /* dbd */ dbd,
2049                         /* page_code */ page_control << 6,
2050                         /* page */ mode_page,
2051                         /* param_buf */ data,
2052                         /* param_len */ datalen,
2053                         /* sense_len */ SSD_FULL_SIZE,
2054                         /* timeout */ timeout ? timeout : 5000);
2055
2056         if (arglist & CAM_ARG_ERR_RECOVER)
2057                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
2058
2059         /* Disable freezing the device queue */
2060         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
2061
2062         if (((retval = cam_send_ccb(device, ccb)) < 0)
2063          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
2064                 if (arglist & CAM_ARG_VERBOSE) {
2065                         cam_error_print(device, ccb, CAM_ESF_ALL,
2066                                         CAM_EPF_ALL, stderr);
2067                 }
2068                 cam_freeccb(ccb);
2069                 cam_close_device(device);
2070                 if (retval < 0)
2071                         err(1, "error sending mode sense command");
2072                 else
2073                         errx(1, "error sending mode sense command");
2074         }
2075
2076         cam_freeccb(ccb);
2077 }
2078
2079 void
2080 mode_select(struct cam_device *device, int save_pages, int retry_count,
2081            int timeout, u_int8_t *data, int datalen)
2082 {
2083         union ccb *ccb;
2084         int retval;
2085
2086         ccb = cam_getccb(device);
2087
2088         if (ccb == NULL)
2089                 errx(1, "mode_select: couldn't allocate CCB");
2090
2091         bzero(&(&ccb->ccb_h)[1],
2092               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
2093
2094         scsi_mode_select(&ccb->csio,
2095                          /* retries */ retry_count,
2096                          /* cbfcnp */ NULL,
2097                          /* tag_action */ MSG_SIMPLE_Q_TAG,
2098                          /* scsi_page_fmt */ 1,
2099                          /* save_pages */ save_pages,
2100                          /* param_buf */ data,
2101                          /* param_len */ datalen,
2102                          /* sense_len */ SSD_FULL_SIZE,
2103                          /* timeout */ timeout ? timeout : 5000);
2104
2105         if (arglist & CAM_ARG_ERR_RECOVER)
2106                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
2107
2108         /* Disable freezing the device queue */
2109         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
2110
2111         if (((retval = cam_send_ccb(device, ccb)) < 0)
2112          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
2113                 if (arglist & CAM_ARG_VERBOSE) {
2114                         cam_error_print(device, ccb, CAM_ESF_ALL,
2115                                         CAM_EPF_ALL, stderr);
2116                 }
2117                 cam_freeccb(ccb);
2118                 cam_close_device(device);
2119
2120                 if (retval < 0)
2121                         err(1, "error sending mode select command");
2122                 else
2123                         errx(1, "error sending mode select command");
2124
2125         }
2126
2127         cam_freeccb(ccb);
2128 }
2129
2130 void
2131 modepage(struct cam_device *device, int argc, char **argv, char *combinedopt,
2132          int retry_count, int timeout)
2133 {
2134         int c, mode_page = -1, page_control = 0;
2135         int binary = 0, list = 0;
2136
2137         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2138                 switch(c) {
2139                 case 'b':
2140                         binary = 1;
2141                         break;
2142                 case 'd':
2143                         arglist |= CAM_ARG_DBD;
2144                         break;
2145                 case 'e':
2146                         arglist |= CAM_ARG_MODE_EDIT;
2147                         break;
2148                 case 'l':
2149                         list = 1;
2150                         break;
2151                 case 'm':
2152                         mode_page = strtol(optarg, NULL, 0);
2153                         if (mode_page < 0)
2154                                 errx(1, "invalid mode page %d", mode_page);
2155                         break;
2156                 case 'P':
2157                         page_control = strtol(optarg, NULL, 0);
2158                         if ((page_control < 0) || (page_control > 3))
2159                                 errx(1, "invalid page control field %d",
2160                                      page_control);
2161                         arglist |= CAM_ARG_PAGE_CNTL;
2162                         break;
2163                 default:
2164                         break;
2165                 }
2166         }
2167
2168         if (mode_page == -1 && list == 0)
2169                 errx(1, "you must specify a mode page!");
2170
2171         if (list) {
2172                 mode_list(device, page_control, arglist & CAM_ARG_DBD,
2173                     retry_count, timeout);
2174         } else {
2175                 mode_edit(device, mode_page, page_control,
2176                     arglist & CAM_ARG_DBD, arglist & CAM_ARG_MODE_EDIT, binary,
2177                     retry_count, timeout);
2178         }
2179 }
2180
2181 static int
2182 scsicmd(struct cam_device *device, int argc, char **argv, char *combinedopt,
2183         int retry_count, int timeout)
2184 {
2185         union ccb *ccb;
2186         u_int32_t flags = CAM_DIR_NONE;
2187         u_int8_t *data_ptr = NULL;
2188         u_int8_t cdb[20];
2189         u_int8_t atacmd[12];
2190         struct get_hook hook;
2191         int c, data_bytes = 0;
2192         int cdb_len = 0;
2193         int atacmd_len = 0;
2194         int dmacmd = 0;
2195         int fpdmacmd = 0;
2196         int need_res = 0;
2197         char *datastr = NULL, *tstr, *resstr = NULL;
2198         int error = 0;
2199         int fd_data = 0, fd_res = 0;
2200         int retval;
2201
2202         ccb = cam_getccb(device);
2203
2204         if (ccb == NULL) {
2205                 warnx("scsicmd: error allocating ccb");
2206                 return(1);
2207         }
2208
2209         bzero(&(&ccb->ccb_h)[1],
2210               sizeof(union ccb) - sizeof(struct ccb_hdr));
2211
2212         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2213                 switch(c) {
2214                 case 'a':
2215                         tstr = optarg;
2216                         while (isspace(*tstr) && (*tstr != '\0'))
2217                                 tstr++;
2218                         hook.argc = argc - optind;
2219                         hook.argv = argv + optind;
2220                         hook.got = 0;
2221                         atacmd_len = buff_encode_visit(atacmd, sizeof(atacmd), tstr,
2222                                                     iget, &hook);
2223                         /*
2224                          * Increment optind by the number of arguments the
2225                          * encoding routine processed.  After each call to
2226                          * getopt(3), optind points to the argument that
2227                          * getopt should process _next_.  In this case,
2228                          * that means it points to the first command string
2229                          * argument, if there is one.  Once we increment
2230                          * this, it should point to either the next command
2231                          * line argument, or it should be past the end of
2232                          * the list.
2233                          */
2234                         optind += hook.got;
2235                         break;
2236                 case 'c':
2237                         tstr = optarg;
2238                         while (isspace(*tstr) && (*tstr != '\0'))
2239                                 tstr++;
2240                         hook.argc = argc - optind;
2241                         hook.argv = argv + optind;
2242                         hook.got = 0;
2243                         cdb_len = buff_encode_visit(cdb, sizeof(cdb), tstr,
2244                                                     iget, &hook);
2245                         /*
2246                          * Increment optind by the number of arguments the
2247                          * encoding routine processed.  After each call to
2248                          * getopt(3), optind points to the argument that
2249                          * getopt should process _next_.  In this case,
2250                          * that means it points to the first command string
2251                          * argument, if there is one.  Once we increment
2252                          * this, it should point to either the next command
2253                          * line argument, or it should be past the end of
2254                          * the list.
2255                          */
2256                         optind += hook.got;
2257                         break;
2258                 case 'd':
2259                         dmacmd = 1;
2260                         break;
2261                 case 'f':
2262                         fpdmacmd = 1;
2263                         break;
2264                 case 'i':
2265                         if (arglist & CAM_ARG_CMD_OUT) {
2266                                 warnx("command must either be "
2267                                       "read or write, not both");
2268                                 error = 1;
2269                                 goto scsicmd_bailout;
2270                         }
2271                         arglist |= CAM_ARG_CMD_IN;
2272                         flags = CAM_DIR_IN;
2273                         data_bytes = strtol(optarg, NULL, 0);
2274                         if (data_bytes <= 0) {
2275                                 warnx("invalid number of input bytes %d",
2276                                       data_bytes);
2277                                 error = 1;
2278                                 goto scsicmd_bailout;
2279                         }
2280                         hook.argc = argc - optind;
2281                         hook.argv = argv + optind;
2282                         hook.got = 0;
2283                         optind++;
2284                         datastr = cget(&hook, NULL);
2285                         /*
2286                          * If the user supplied "-" instead of a format, he
2287                          * wants the data to be written to stdout.
2288                          */
2289                         if ((datastr != NULL)
2290                          && (datastr[0] == '-'))
2291                                 fd_data = 1;
2292
2293                         data_ptr = (u_int8_t *)malloc(data_bytes);
2294                         if (data_ptr == NULL) {
2295                                 warnx("can't malloc memory for data_ptr");
2296                                 error = 1;
2297                                 goto scsicmd_bailout;
2298                         }
2299                         break;
2300                 case 'o':
2301                         if (arglist & CAM_ARG_CMD_IN) {
2302                                 warnx("command must either be "
2303                                       "read or write, not both");
2304                                 error = 1;
2305                                 goto scsicmd_bailout;
2306                         }
2307                         arglist |= CAM_ARG_CMD_OUT;
2308                         flags = CAM_DIR_OUT;
2309                         data_bytes = strtol(optarg, NULL, 0);
2310                         if (data_bytes <= 0) {
2311                                 warnx("invalid number of output bytes %d",
2312                                       data_bytes);
2313                                 error = 1;
2314                                 goto scsicmd_bailout;
2315                         }
2316                         hook.argc = argc - optind;
2317                         hook.argv = argv + optind;
2318                         hook.got = 0;
2319                         datastr = cget(&hook, NULL);
2320                         data_ptr = (u_int8_t *)malloc(data_bytes);
2321                         if (data_ptr == NULL) {
2322                                 warnx("can't malloc memory for data_ptr");
2323                                 error = 1;
2324                                 goto scsicmd_bailout;
2325                         }
2326                         bzero(data_ptr, data_bytes);
2327                         /*
2328                          * If the user supplied "-" instead of a format, he
2329                          * wants the data to be read from stdin.
2330                          */
2331                         if ((datastr != NULL)
2332                          && (datastr[0] == '-'))
2333                                 fd_data = 1;
2334                         else
2335                                 buff_encode_visit(data_ptr, data_bytes, datastr,
2336                                                   iget, &hook);
2337                         optind += hook.got;
2338                         break;
2339                 case 'r':
2340                         need_res = 1;
2341                         hook.argc = argc - optind;
2342                         hook.argv = argv + optind;
2343                         hook.got = 0;
2344                         resstr = cget(&hook, NULL);
2345                         if ((resstr != NULL) && (resstr[0] == '-'))
2346                                 fd_res = 1;
2347                         optind += hook.got;
2348                         break;
2349                 default:
2350                         break;
2351                 }
2352         }
2353
2354         /*
2355          * If fd_data is set, and we're writing to the device, we need to
2356          * read the data the user wants written from stdin.
2357          */
2358         if ((fd_data == 1) && (arglist & CAM_ARG_CMD_OUT)) {
2359                 ssize_t amt_read;
2360                 int amt_to_read = data_bytes;
2361                 u_int8_t *buf_ptr = data_ptr;
2362
2363                 for (amt_read = 0; amt_to_read > 0;
2364                      amt_read = read(STDIN_FILENO, buf_ptr, amt_to_read)) {
2365                         if (amt_read == -1) {
2366                                 warn("error reading data from stdin");
2367                                 error = 1;
2368                                 goto scsicmd_bailout;
2369                         }
2370                         amt_to_read -= amt_read;
2371                         buf_ptr += amt_read;
2372                 }
2373         }
2374
2375         if (arglist & CAM_ARG_ERR_RECOVER)
2376                 flags |= CAM_PASS_ERR_RECOVER;
2377
2378         /* Disable freezing the device queue */
2379         flags |= CAM_DEV_QFRZDIS;
2380
2381         if (cdb_len) {
2382                 /*
2383                  * This is taken from the SCSI-3 draft spec.
2384                  * (T10/1157D revision 0.3)
2385                  * The top 3 bits of an opcode are the group code.
2386                  * The next 5 bits are the command code.
2387                  * Group 0:  six byte commands
2388                  * Group 1:  ten byte commands
2389                  * Group 2:  ten byte commands
2390                  * Group 3:  reserved
2391                  * Group 4:  sixteen byte commands
2392                  * Group 5:  twelve byte commands
2393                  * Group 6:  vendor specific
2394                  * Group 7:  vendor specific
2395                  */
2396                 switch((cdb[0] >> 5) & 0x7) {
2397                         case 0:
2398                                 cdb_len = 6;
2399                                 break;
2400                         case 1:
2401                         case 2:
2402                                 cdb_len = 10;
2403                                 break;
2404                         case 3:
2405                         case 6:
2406                         case 7:
2407                                 /* computed by buff_encode_visit */
2408                                 break;
2409                         case 4:
2410                                 cdb_len = 16;
2411                                 break;
2412                         case 5:
2413                                 cdb_len = 12;
2414                                 break;
2415                 }
2416
2417                 /*
2418                  * We should probably use csio_build_visit or something like that
2419                  * here, but it's easier to encode arguments as you go.  The
2420                  * alternative would be skipping the CDB argument and then encoding
2421                  * it here, since we've got the data buffer argument by now.
2422                  */
2423                 bcopy(cdb, &ccb->csio.cdb_io.cdb_bytes, cdb_len);
2424
2425                 cam_fill_csio(&ccb->csio,
2426                       /*retries*/ retry_count,
2427                       /*cbfcnp*/ NULL,
2428                       /*flags*/ flags,
2429                       /*tag_action*/ MSG_SIMPLE_Q_TAG,
2430                       /*data_ptr*/ data_ptr,
2431                       /*dxfer_len*/ data_bytes,
2432                       /*sense_len*/ SSD_FULL_SIZE,
2433                       /*cdb_len*/ cdb_len,
2434                       /*timeout*/ timeout ? timeout : 5000);
2435         } else {
2436                 atacmd_len = 12;
2437                 bcopy(atacmd, &ccb->ataio.cmd.command, atacmd_len);
2438                 if (need_res)
2439                         ccb->ataio.cmd.flags |= CAM_ATAIO_NEEDRESULT;
2440                 if (dmacmd)
2441                         ccb->ataio.cmd.flags |= CAM_ATAIO_DMA;
2442                 if (fpdmacmd)
2443                         ccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA;
2444
2445                 cam_fill_ataio(&ccb->ataio,
2446                       /*retries*/ retry_count,
2447                       /*cbfcnp*/ NULL,
2448                       /*flags*/ flags,
2449                       /*tag_action*/ 0,
2450                       /*data_ptr*/ data_ptr,
2451                       /*dxfer_len*/ data_bytes,
2452                       /*timeout*/ timeout ? timeout : 5000);
2453         }
2454
2455         if (((retval = cam_send_ccb(device, ccb)) < 0)
2456          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
2457                 if (retval < 0)
2458                         warn("error sending command");
2459                 else
2460                         warnx("error sending command");
2461
2462                 if (arglist & CAM_ARG_VERBOSE) {
2463                         cam_error_print(device, ccb, CAM_ESF_ALL,
2464                                         CAM_EPF_ALL, stderr);
2465                 }
2466
2467                 error = 1;
2468                 goto scsicmd_bailout;
2469         }
2470
2471         if (atacmd_len && need_res) {
2472                 if (fd_res == 0) {
2473                         buff_decode_visit(&ccb->ataio.res.status, 11, resstr,
2474                                           arg_put, NULL);
2475                         fprintf(stdout, "\n");
2476                 } else {
2477                         fprintf(stdout,
2478                             "%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
2479                             ccb->ataio.res.status,
2480                             ccb->ataio.res.error,
2481                             ccb->ataio.res.lba_low,
2482                             ccb->ataio.res.lba_mid,
2483                             ccb->ataio.res.lba_high,
2484                             ccb->ataio.res.device,
2485                             ccb->ataio.res.lba_low_exp,
2486                             ccb->ataio.res.lba_mid_exp,
2487                             ccb->ataio.res.lba_high_exp,
2488                             ccb->ataio.res.sector_count,
2489                             ccb->ataio.res.sector_count_exp);
2490                         fflush(stdout);
2491                 }
2492         }
2493
2494         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
2495          && (arglist & CAM_ARG_CMD_IN)
2496          && (data_bytes > 0)) {
2497                 if (fd_data == 0) {
2498                         buff_decode_visit(data_ptr, data_bytes, datastr,
2499                                           arg_put, NULL);
2500                         fprintf(stdout, "\n");
2501                 } else {
2502                         ssize_t amt_written;
2503                         int amt_to_write = data_bytes;
2504                         u_int8_t *buf_ptr = data_ptr;
2505
2506                         for (amt_written = 0; (amt_to_write > 0) &&
2507                              (amt_written =write(1, buf_ptr,amt_to_write))> 0;){
2508                                 amt_to_write -= amt_written;
2509                                 buf_ptr += amt_written;
2510                         }
2511                         if (amt_written == -1) {
2512                                 warn("error writing data to stdout");
2513                                 error = 1;
2514                                 goto scsicmd_bailout;
2515                         } else if ((amt_written == 0)
2516                                 && (amt_to_write > 0)) {
2517                                 warnx("only wrote %u bytes out of %u",
2518                                       data_bytes - amt_to_write, data_bytes);
2519                         }
2520                 }
2521         }
2522
2523 scsicmd_bailout:
2524
2525         if ((data_bytes > 0) && (data_ptr != NULL))
2526                 free(data_ptr);
2527
2528         cam_freeccb(ccb);
2529
2530         return(error);
2531 }
2532
2533 static int
2534 camdebug(int argc, char **argv, char *combinedopt)
2535 {
2536         int c, fd;
2537         int bus = -1, target = -1, lun = -1;
2538         char *tstr, *tmpstr = NULL;
2539         union ccb ccb;
2540         int error = 0;
2541
2542         bzero(&ccb, sizeof(union ccb));
2543
2544         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2545                 switch(c) {
2546                 case 'I':
2547                         arglist |= CAM_ARG_DEBUG_INFO;
2548                         ccb.cdbg.flags |= CAM_DEBUG_INFO;
2549                         break;
2550                 case 'P':
2551                         arglist |= CAM_ARG_DEBUG_PERIPH;
2552                         ccb.cdbg.flags |= CAM_DEBUG_PERIPH;
2553                         break;
2554                 case 'S':
2555                         arglist |= CAM_ARG_DEBUG_SUBTRACE;
2556                         ccb.cdbg.flags |= CAM_DEBUG_SUBTRACE;
2557                         break;
2558                 case 'T':
2559                         arglist |= CAM_ARG_DEBUG_TRACE;
2560                         ccb.cdbg.flags |= CAM_DEBUG_TRACE;
2561                         break;
2562                 case 'X':
2563                         arglist |= CAM_ARG_DEBUG_XPT;
2564                         ccb.cdbg.flags |= CAM_DEBUG_XPT;
2565                         break;
2566                 case 'c':
2567                         arglist |= CAM_ARG_DEBUG_CDB;
2568                         ccb.cdbg.flags |= CAM_DEBUG_CDB;
2569                         break;
2570                 default:
2571                         break;
2572                 }
2573         }
2574
2575         if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
2576                 warnx("error opening transport layer device %s", XPT_DEVICE);
2577                 warn("%s", XPT_DEVICE);
2578                 return(1);
2579         }
2580         argc -= optind;
2581         argv += optind;
2582
2583         if (argc <= 0) {
2584                 warnx("you must specify \"off\", \"all\" or a bus,");
2585                 warnx("bus:target, or bus:target:lun");
2586                 close(fd);
2587                 return(1);
2588         }
2589
2590         tstr = *argv;
2591
2592         while (isspace(*tstr) && (*tstr != '\0'))
2593                 tstr++;
2594
2595         if (strncmp(tstr, "off", 3) == 0) {
2596                 ccb.cdbg.flags = CAM_DEBUG_NONE;
2597                 arglist &= ~(CAM_ARG_DEBUG_INFO|CAM_ARG_DEBUG_PERIPH|
2598                              CAM_ARG_DEBUG_TRACE|CAM_ARG_DEBUG_SUBTRACE|
2599                              CAM_ARG_DEBUG_XPT);
2600         } else if (strncmp(tstr, "all", 3) != 0) {
2601                 tmpstr = (char *)strtok(tstr, ":");
2602                 if ((tmpstr != NULL) && (*tmpstr != '\0')){
2603                         bus = strtol(tmpstr, NULL, 0);
2604                         arglist |= CAM_ARG_BUS;
2605                         tmpstr = (char *)strtok(NULL, ":");
2606                         if ((tmpstr != NULL) && (*tmpstr != '\0')){
2607                                 target = strtol(tmpstr, NULL, 0);
2608                                 arglist |= CAM_ARG_TARGET;
2609                                 tmpstr = (char *)strtok(NULL, ":");
2610                                 if ((tmpstr != NULL) && (*tmpstr != '\0')){
2611                                         lun = strtol(tmpstr, NULL, 0);
2612                                         arglist |= CAM_ARG_LUN;
2613                                 }
2614                         }
2615                 } else {
2616                         error = 1;
2617                         warnx("you must specify \"all\", \"off\", or a bus,");
2618                         warnx("bus:target, or bus:target:lun to debug");
2619                 }
2620         }
2621
2622         if (error == 0) {
2623
2624                 ccb.ccb_h.func_code = XPT_DEBUG;
2625                 ccb.ccb_h.path_id = bus;
2626                 ccb.ccb_h.target_id = target;
2627                 ccb.ccb_h.target_lun = lun;
2628
2629                 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
2630                         warn("CAMIOCOMMAND ioctl failed");
2631                         error = 1;
2632                 }
2633
2634                 if (error == 0) {
2635                         if ((ccb.ccb_h.status & CAM_STATUS_MASK) ==
2636                              CAM_FUNC_NOTAVAIL) {
2637                                 warnx("CAM debugging not available");
2638                                 warnx("you need to put options CAMDEBUG in"
2639                                       " your kernel config file!");
2640                                 error = 1;
2641                         } else if ((ccb.ccb_h.status & CAM_STATUS_MASK) !=
2642                                     CAM_REQ_CMP) {
2643                                 warnx("XPT_DEBUG CCB failed with status %#x",
2644                                       ccb.ccb_h.status);
2645                                 error = 1;
2646                         } else {
2647                                 if (ccb.cdbg.flags == CAM_DEBUG_NONE) {
2648                                         fprintf(stderr,
2649                                                 "Debugging turned off\n");
2650                                 } else {
2651                                         fprintf(stderr,
2652                                                 "Debugging enabled for "
2653                                                 "%d:%d:%d\n",
2654                                                 bus, target, lun);
2655                                 }
2656                         }
2657                 }
2658                 close(fd);
2659         }
2660
2661         return(error);
2662 }
2663
2664 static int
2665 tagcontrol(struct cam_device *device, int argc, char **argv,
2666            char *combinedopt)
2667 {
2668         int c;
2669         union ccb *ccb;
2670         int numtags = -1;
2671         int retval = 0;
2672         int quiet = 0;
2673         char pathstr[1024];
2674
2675         ccb = cam_getccb(device);
2676
2677         if (ccb == NULL) {
2678                 warnx("tagcontrol: error allocating ccb");
2679                 return(1);
2680         }
2681
2682         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2683                 switch(c) {
2684                 case 'N':
2685                         numtags = strtol(optarg, NULL, 0);
2686                         if (numtags < 0) {
2687                                 warnx("tag count %d is < 0", numtags);
2688                                 retval = 1;
2689                                 goto tagcontrol_bailout;
2690                         }
2691                         break;
2692                 case 'q':
2693                         quiet++;
2694                         break;
2695                 default:
2696                         break;
2697                 }
2698         }
2699
2700         cam_path_string(device, pathstr, sizeof(pathstr));
2701
2702         if (numtags >= 0) {
2703                 bzero(&(&ccb->ccb_h)[1],
2704                       sizeof(struct ccb_relsim) - sizeof(struct ccb_hdr));
2705                 ccb->ccb_h.func_code = XPT_REL_SIMQ;
2706                 ccb->crs.release_flags = RELSIM_ADJUST_OPENINGS;
2707                 ccb->crs.openings = numtags;
2708
2709
2710                 if (cam_send_ccb(device, ccb) < 0) {
2711                         perror("error sending XPT_REL_SIMQ CCB");
2712                         retval = 1;
2713                         goto tagcontrol_bailout;
2714                 }
2715
2716                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2717                         warnx("XPT_REL_SIMQ CCB failed");
2718                         cam_error_print(device, ccb, CAM_ESF_ALL,
2719                                         CAM_EPF_ALL, stderr);
2720                         retval = 1;
2721                         goto tagcontrol_bailout;
2722                 }
2723
2724
2725                 if (quiet == 0)
2726                         fprintf(stdout, "%stagged openings now %d\n",
2727                                 pathstr, ccb->crs.openings);
2728         }
2729
2730         bzero(&(&ccb->ccb_h)[1],
2731               sizeof(struct ccb_getdevstats) - sizeof(struct ccb_hdr));
2732
2733         ccb->ccb_h.func_code = XPT_GDEV_STATS;
2734
2735         if (cam_send_ccb(device, ccb) < 0) {
2736                 perror("error sending XPT_GDEV_STATS CCB");
2737                 retval = 1;
2738                 goto tagcontrol_bailout;
2739         }
2740
2741         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2742                 warnx("XPT_GDEV_STATS CCB failed");
2743                 cam_error_print(device, ccb, CAM_ESF_ALL,
2744                                 CAM_EPF_ALL, stderr);
2745                 retval = 1;
2746                 goto tagcontrol_bailout;
2747         }
2748
2749         if (arglist & CAM_ARG_VERBOSE) {
2750                 fprintf(stdout, "%s", pathstr);
2751                 fprintf(stdout, "dev_openings  %d\n", ccb->cgds.dev_openings);
2752                 fprintf(stdout, "%s", pathstr);
2753                 fprintf(stdout, "dev_active    %d\n", ccb->cgds.dev_active);
2754                 fprintf(stdout, "%s", pathstr);
2755                 fprintf(stdout, "devq_openings %d\n", ccb->cgds.devq_openings);
2756                 fprintf(stdout, "%s", pathstr);
2757                 fprintf(stdout, "devq_queued   %d\n", ccb->cgds.devq_queued);
2758                 fprintf(stdout, "%s", pathstr);
2759                 fprintf(stdout, "held          %d\n", ccb->cgds.held);
2760                 fprintf(stdout, "%s", pathstr);
2761                 fprintf(stdout, "mintags       %d\n", ccb->cgds.mintags);
2762                 fprintf(stdout, "%s", pathstr);
2763                 fprintf(stdout, "maxtags       %d\n", ccb->cgds.maxtags);
2764         } else {
2765                 if (quiet == 0) {
2766                         fprintf(stdout, "%s", pathstr);
2767                         fprintf(stdout, "device openings: ");
2768                 }
2769                 fprintf(stdout, "%d\n", ccb->cgds.dev_openings +
2770                         ccb->cgds.dev_active);
2771         }
2772
2773 tagcontrol_bailout:
2774
2775         cam_freeccb(ccb);
2776         return(retval);
2777 }
2778
2779 static void
2780 cts_print(struct cam_device *device, struct ccb_trans_settings *cts)
2781 {
2782         char pathstr[1024];
2783
2784         cam_path_string(device, pathstr, sizeof(pathstr));
2785
2786         if (cts->transport == XPORT_SPI) {
2787                 struct ccb_trans_settings_spi *spi =
2788                     &cts->xport_specific.spi;
2789
2790                 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) {
2791
2792                         fprintf(stdout, "%ssync parameter: %d\n", pathstr,
2793                                 spi->sync_period);
2794
2795                         if (spi->sync_offset != 0) {
2796                                 u_int freq;
2797
2798                                 freq = scsi_calc_syncsrate(spi->sync_period);
2799                                 fprintf(stdout, "%sfrequency: %d.%03dMHz\n",
2800                                         pathstr, freq / 1000, freq % 1000);
2801                         }
2802                 }
2803
2804                 if (spi->valid & CTS_SPI_VALID_SYNC_OFFSET) {
2805                         fprintf(stdout, "%soffset: %d\n", pathstr,
2806                             spi->sync_offset);
2807                 }
2808
2809                 if (spi->valid & CTS_SPI_VALID_BUS_WIDTH) {
2810                         fprintf(stdout, "%sbus width: %d bits\n", pathstr,
2811                                 (0x01 << spi->bus_width) * 8);
2812                 }
2813
2814                 if (spi->valid & CTS_SPI_VALID_DISC) {
2815                         fprintf(stdout, "%sdisconnection is %s\n", pathstr,
2816                                 (spi->flags & CTS_SPI_FLAGS_DISC_ENB) ?
2817                                 "enabled" : "disabled");
2818                 }
2819         }
2820         if (cts->transport == XPORT_ATA) {
2821                 struct ccb_trans_settings_ata *ata =
2822                     &cts->xport_specific.ata;
2823
2824                 if ((ata->valid & CTS_ATA_VALID_MODE) != 0) {
2825                         fprintf(stdout, "%sATA mode: %s\n", pathstr,
2826                                 ata_mode2string(ata->mode));
2827                 }
2828                 if ((ata->valid & CTS_ATA_VALID_ATAPI) != 0) {
2829                         fprintf(stdout, "%sATAPI packet length: %d\n", pathstr,
2830                                 ata->atapi);
2831                 }
2832                 if ((ata->valid & CTS_ATA_VALID_BYTECOUNT) != 0) {
2833                         fprintf(stdout, "%sPIO transaction length: %d\n",
2834                                 pathstr, ata->bytecount);
2835                 }
2836         }
2837         if (cts->transport == XPORT_SATA) {
2838                 struct ccb_trans_settings_sata *sata =
2839                     &cts->xport_specific.sata;
2840
2841                 if ((sata->valid & CTS_SATA_VALID_REVISION) != 0) {
2842                         fprintf(stdout, "%sSATA revision: %d.x\n", pathstr,
2843                                 sata->revision);
2844                 }
2845                 if ((sata->valid & CTS_SATA_VALID_MODE) != 0) {
2846                         fprintf(stdout, "%sATA mode: %s\n", pathstr,
2847                                 ata_mode2string(sata->mode));
2848                 }
2849                 if ((sata->valid & CTS_SATA_VALID_ATAPI) != 0) {
2850                         fprintf(stdout, "%sATAPI packet length: %d\n", pathstr,
2851                                 sata->atapi);
2852                 }
2853                 if ((sata->valid & CTS_SATA_VALID_BYTECOUNT) != 0) {
2854                         fprintf(stdout, "%sPIO transaction length: %d\n",
2855                                 pathstr, sata->bytecount);
2856                 }
2857                 if ((sata->valid & CTS_SATA_VALID_PM) != 0) {
2858                         fprintf(stdout, "%sPMP presence: %d\n", pathstr,
2859                                 sata->pm_present);
2860                 }
2861                 if ((sata->valid & CTS_SATA_VALID_TAGS) != 0) {
2862                         fprintf(stdout, "%sNumber of tags: %d\n", pathstr,
2863                                 sata->tags);
2864                 }
2865                 if ((sata->valid & CTS_SATA_VALID_CAPS) != 0) {
2866                         fprintf(stdout, "%sSATA capabilities: %08x\n", pathstr,
2867                                 sata->caps);
2868                 }
2869         }
2870         if (cts->protocol == PROTO_SCSI) {
2871                 struct ccb_trans_settings_scsi *scsi=
2872                     &cts->proto_specific.scsi;
2873
2874                 if (scsi->valid & CTS_SCSI_VALID_TQ) {
2875                         fprintf(stdout, "%stagged queueing is %s\n", pathstr,
2876                                 (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) ?
2877                                 "enabled" : "disabled");
2878                 }
2879         }
2880
2881 }
2882
2883 /*
2884  * Get a path inquiry CCB for the specified device.
2885  */
2886 static int
2887 get_cpi(struct cam_device *device, struct ccb_pathinq *cpi)
2888 {
2889         union ccb *ccb;
2890         int retval = 0;
2891
2892         ccb = cam_getccb(device);
2893         if (ccb == NULL) {
2894                 warnx("get_cpi: couldn't allocate CCB");
2895                 return(1);
2896         }
2897         bzero(&(&ccb->ccb_h)[1],
2898               sizeof(struct ccb_pathinq) - sizeof(struct ccb_hdr));
2899         ccb->ccb_h.func_code = XPT_PATH_INQ;
2900         if (cam_send_ccb(device, ccb) < 0) {
2901                 warn("get_cpi: error sending Path Inquiry CCB");
2902                 if (arglist & CAM_ARG_VERBOSE)
2903                         cam_error_print(device, ccb, CAM_ESF_ALL,
2904                                         CAM_EPF_ALL, stderr);
2905                 retval = 1;
2906                 goto get_cpi_bailout;
2907         }
2908         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2909                 if (arglist & CAM_ARG_VERBOSE)
2910                         cam_error_print(device, ccb, CAM_ESF_ALL,
2911                                         CAM_EPF_ALL, stderr);
2912                 retval = 1;
2913                 goto get_cpi_bailout;
2914         }
2915         bcopy(&ccb->cpi, cpi, sizeof(struct ccb_pathinq));
2916
2917 get_cpi_bailout:
2918         cam_freeccb(ccb);
2919         return(retval);
2920 }
2921
2922 /*
2923  * Get a get device CCB for the specified device.
2924  */
2925 static int
2926 get_cgd(struct cam_device *device, struct ccb_getdev *cgd)
2927 {
2928         union ccb *ccb;
2929         int retval = 0;
2930
2931         ccb = cam_getccb(device);
2932         if (ccb == NULL) {
2933                 warnx("get_cgd: couldn't allocate CCB");
2934                 return(1);
2935         }
2936         bzero(&(&ccb->ccb_h)[1],
2937               sizeof(struct ccb_pathinq) - sizeof(struct ccb_hdr));
2938         ccb->ccb_h.func_code = XPT_GDEV_TYPE;
2939         if (cam_send_ccb(device, ccb) < 0) {
2940                 warn("get_cgd: error sending Path Inquiry CCB");
2941                 if (arglist & CAM_ARG_VERBOSE)
2942                         cam_error_print(device, ccb, CAM_ESF_ALL,
2943                                         CAM_EPF_ALL, stderr);
2944                 retval = 1;
2945                 goto get_cgd_bailout;
2946         }
2947         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2948                 if (arglist & CAM_ARG_VERBOSE)
2949                         cam_error_print(device, ccb, CAM_ESF_ALL,
2950                                         CAM_EPF_ALL, stderr);
2951                 retval = 1;
2952                 goto get_cgd_bailout;
2953         }
2954         bcopy(&ccb->cgd, cgd, sizeof(struct ccb_getdev));
2955
2956 get_cgd_bailout:
2957         cam_freeccb(ccb);
2958         return(retval);
2959 }
2960
2961 static void
2962 cpi_print(struct ccb_pathinq *cpi)
2963 {
2964         char adapter_str[1024];
2965         int i;
2966
2967         snprintf(adapter_str, sizeof(adapter_str),
2968                  "%s%d:", cpi->dev_name, cpi->unit_number);
2969
2970         fprintf(stdout, "%s SIM/HBA version: %d\n", adapter_str,
2971                 cpi->version_num);
2972
2973         for (i = 1; i < 0xff; i = i << 1) {
2974                 const char *str;
2975
2976                 if ((i & cpi->hba_inquiry) == 0)
2977                         continue;
2978
2979                 fprintf(stdout, "%s supports ", adapter_str);
2980
2981                 switch(i) {
2982                 case PI_MDP_ABLE:
2983                         str = "MDP message";
2984                         break;
2985                 case PI_WIDE_32:
2986                         str = "32 bit wide SCSI";
2987                         break;
2988                 case PI_WIDE_16:
2989                         str = "16 bit wide SCSI";
2990                         break;
2991                 case PI_SDTR_ABLE:
2992                         str = "SDTR message";
2993                         break;
2994                 case PI_LINKED_CDB:
2995                         str = "linked CDBs";
2996                         break;
2997                 case PI_TAG_ABLE:
2998                         str = "tag queue messages";
2999                         break;
3000                 case PI_SOFT_RST:
3001                         str = "soft reset alternative";
3002                         break;
3003                 case PI_SATAPM:
3004                         str = "SATA Port Multiplier";
3005                         break;
3006                 default:
3007                         str = "unknown PI bit set";
3008                         break;
3009                 }
3010                 fprintf(stdout, "%s\n", str);
3011         }
3012
3013         for (i = 1; i < 0xff; i = i << 1) {
3014                 const char *str;
3015
3016                 if ((i & cpi->hba_misc) == 0)
3017                         continue;
3018
3019                 fprintf(stdout, "%s ", adapter_str);
3020
3021                 switch(i) {
3022                 case PIM_SCANHILO:
3023                         str = "bus scans from high ID to low ID";
3024                         break;
3025                 case PIM_NOREMOVE:
3026                         str = "removable devices not included in scan";
3027                         break;
3028                 case PIM_NOINITIATOR:
3029                         str = "initiator role not supported";
3030                         break;
3031                 case PIM_NOBUSRESET:
3032                         str = "user has disabled initial BUS RESET or"
3033                               " controller is in target/mixed mode";
3034                         break;
3035                 case PIM_NO_6_BYTE:
3036                         str = "do not send 6-byte commands";
3037                         break;
3038                 case PIM_SEQSCAN:
3039                         str = "scan bus sequentially";
3040                         break;
3041                 default:
3042                         str = "unknown PIM bit set";
3043                         break;
3044                 }
3045                 fprintf(stdout, "%s\n", str);
3046         }
3047
3048         for (i = 1; i < 0xff; i = i << 1) {
3049                 const char *str;
3050
3051                 if ((i & cpi->target_sprt) == 0)
3052                         continue;
3053
3054                 fprintf(stdout, "%s supports ", adapter_str);
3055                 switch(i) {
3056                 case PIT_PROCESSOR:
3057                         str = "target mode processor mode";
3058                         break;
3059                 case PIT_PHASE:
3060                         str = "target mode phase cog. mode";
3061                         break;
3062                 case PIT_DISCONNECT:
3063                         str = "disconnects in target mode";
3064                         break;
3065                 case PIT_TERM_IO:
3066                         str = "terminate I/O message in target mode";
3067                         break;
3068                 case PIT_GRP_6:
3069                         str = "group 6 commands in target mode";
3070                         break;
3071                 case PIT_GRP_7:
3072                         str = "group 7 commands in target mode";
3073                         break;
3074                 default:
3075                         str = "unknown PIT bit set";
3076                         break;
3077                 }
3078
3079                 fprintf(stdout, "%s\n", str);
3080         }
3081         fprintf(stdout, "%s HBA engine count: %d\n", adapter_str,
3082                 cpi->hba_eng_cnt);
3083         fprintf(stdout, "%s maximum target: %d\n", adapter_str,
3084                 cpi->max_target);
3085         fprintf(stdout, "%s maximum LUN: %d\n", adapter_str,
3086                 cpi->max_lun);
3087         fprintf(stdout, "%s highest path ID in subsystem: %d\n",
3088                 adapter_str, cpi->hpath_id);
3089         fprintf(stdout, "%s initiator ID: %d\n", adapter_str,
3090                 cpi->initiator_id);
3091         fprintf(stdout, "%s SIM vendor: %s\n", adapter_str, cpi->sim_vid);
3092         fprintf(stdout, "%s HBA vendor: %s\n", adapter_str, cpi->hba_vid);
3093         fprintf(stdout, "%s HBA vendor ID: 0x%04x\n",
3094             adapter_str, cpi->hba_vendor);
3095         fprintf(stdout, "%s HBA device ID: 0x%04x\n",
3096             adapter_str, cpi->hba_device);
3097         fprintf(stdout, "%s HBA subvendor ID: 0x%04x\n",
3098             adapter_str, cpi->hba_subvendor);
3099         fprintf(stdout, "%s HBA subdevice ID: 0x%04x\n",
3100             adapter_str, cpi->hba_subdevice);
3101         fprintf(stdout, "%s bus ID: %d\n", adapter_str, cpi->bus_id);
3102         fprintf(stdout, "%s base transfer speed: ", adapter_str);
3103         if (cpi->base_transfer_speed > 1000)
3104                 fprintf(stdout, "%d.%03dMB/sec\n",
3105                         cpi->base_transfer_speed / 1000,
3106                         cpi->base_transfer_speed % 1000);
3107         else
3108                 fprintf(stdout, "%dKB/sec\n",
3109                         (cpi->base_transfer_speed % 1000) * 1000);
3110         fprintf(stdout, "%s maximum transfer size: %u bytes\n",
3111             adapter_str, cpi->maxio);
3112 }
3113
3114 static int
3115 get_print_cts(struct cam_device *device, int user_settings, int quiet,
3116               struct ccb_trans_settings *cts)
3117 {
3118         int retval;
3119         union ccb *ccb;
3120
3121         retval = 0;
3122         ccb = cam_getccb(device);
3123
3124         if (ccb == NULL) {
3125                 warnx("get_print_cts: error allocating ccb");
3126                 return(1);
3127         }
3128
3129         bzero(&(&ccb->ccb_h)[1],
3130               sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr));
3131
3132         ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
3133
3134         if (user_settings == 0)
3135                 ccb->cts.type = CTS_TYPE_CURRENT_SETTINGS;
3136         else
3137                 ccb->cts.type = CTS_TYPE_USER_SETTINGS;
3138
3139         if (cam_send_ccb(device, ccb) < 0) {
3140                 perror("error sending XPT_GET_TRAN_SETTINGS CCB");
3141                 if (arglist & CAM_ARG_VERBOSE)
3142                         cam_error_print(device, ccb, CAM_ESF_ALL,
3143                                         CAM_EPF_ALL, stderr);
3144                 retval = 1;
3145                 goto get_print_cts_bailout;
3146         }
3147
3148         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3149                 warnx("XPT_GET_TRANS_SETTINGS CCB failed");
3150                 if (arglist & CAM_ARG_VERBOSE)
3151                         cam_error_print(device, ccb, CAM_ESF_ALL,
3152                                         CAM_EPF_ALL, stderr);
3153                 retval = 1;
3154                 goto get_print_cts_bailout;
3155         }
3156
3157         if (quiet == 0)
3158                 cts_print(device, &ccb->cts);
3159
3160         if (cts != NULL)
3161                 bcopy(&ccb->cts, cts, sizeof(struct ccb_trans_settings));
3162
3163 get_print_cts_bailout:
3164
3165         cam_freeccb(ccb);
3166
3167         return(retval);
3168 }
3169
3170 static int
3171 ratecontrol(struct cam_device *device, int retry_count, int timeout,
3172             int argc, char **argv, char *combinedopt)
3173 {
3174         int c;
3175         union ccb *ccb;
3176         int user_settings = 0;
3177         int retval = 0;
3178         int disc_enable = -1, tag_enable = -1;
3179         int mode = -1;
3180         int offset = -1;
3181         double syncrate = -1;
3182         int bus_width = -1;
3183         int quiet = 0;
3184         int change_settings = 0, send_tur = 0;
3185         struct ccb_pathinq cpi;
3186
3187         ccb = cam_getccb(device);
3188         if (ccb == NULL) {
3189                 warnx("ratecontrol: error allocating ccb");
3190                 return(1);
3191         }
3192         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3193                 switch(c){
3194                 case 'a':
3195                         send_tur = 1;
3196                         break;
3197                 case 'c':
3198                         user_settings = 0;
3199                         break;
3200                 case 'D':
3201                         if (strncasecmp(optarg, "enable", 6) == 0)
3202                                 disc_enable = 1;
3203                         else if (strncasecmp(optarg, "disable", 7) == 0)
3204                                 disc_enable = 0;
3205                         else {
3206                                 warnx("-D argument \"%s\" is unknown", optarg);
3207                                 retval = 1;
3208                                 goto ratecontrol_bailout;
3209                         }
3210                         change_settings = 1;
3211                         break;
3212                 case 'M':
3213                         mode = ata_string2mode(optarg);
3214                         if (mode < 0) {
3215                                 warnx("unknown mode '%s'", optarg);
3216                                 retval = 1;
3217                                 goto ratecontrol_bailout;
3218                         }
3219                         change_settings = 1;
3220                         break;
3221                 case 'O':
3222                         offset = strtol(optarg, NULL, 0);
3223                         if (offset < 0) {
3224                                 warnx("offset value %d is < 0", offset);
3225                                 retval = 1;
3226                                 goto ratecontrol_bailout;
3227                         }
3228                         change_settings = 1;
3229                         break;
3230                 case 'q':
3231                         quiet++;
3232                         break;
3233                 case 'R':
3234                         syncrate = atof(optarg);
3235                         if (syncrate < 0) {
3236                                 warnx("sync rate %f is < 0", syncrate);
3237                                 retval = 1;
3238                                 goto ratecontrol_bailout;
3239                         }
3240                         change_settings = 1;
3241                         break;
3242                 case 'T':
3243                         if (strncasecmp(optarg, "enable", 6) == 0)
3244                                 tag_enable = 1;
3245                         else if (strncasecmp(optarg, "disable", 7) == 0)
3246                                 tag_enable = 0;
3247                         else {
3248                                 warnx("-T argument \"%s\" is unknown", optarg);
3249                                 retval = 1;
3250                                 goto ratecontrol_bailout;
3251                         }
3252                         change_settings = 1;
3253                         break;
3254                 case 'U':
3255                         user_settings = 1;
3256                         break;
3257                 case 'W':
3258                         bus_width = strtol(optarg, NULL, 0);
3259                         if (bus_width < 0) {
3260                                 warnx("bus width %d is < 0", bus_width);
3261                                 retval = 1;
3262                                 goto ratecontrol_bailout;
3263                         }
3264                         change_settings = 1;
3265                         break;
3266                 default:
3267                         break;
3268                 }
3269         }
3270         bzero(&(&ccb->ccb_h)[1],
3271               sizeof(struct ccb_pathinq) - sizeof(struct ccb_hdr));
3272         /*
3273          * Grab path inquiry information, so we can determine whether
3274          * or not the initiator is capable of the things that the user
3275          * requests.
3276          */
3277         ccb->ccb_h.func_code = XPT_PATH_INQ;
3278         if (cam_send_ccb(device, ccb) < 0) {
3279                 perror("error sending XPT_PATH_INQ CCB");
3280                 if (arglist & CAM_ARG_VERBOSE) {
3281                         cam_error_print(device, ccb, CAM_ESF_ALL,
3282                                         CAM_EPF_ALL, stderr);
3283                 }
3284                 retval = 1;
3285                 goto ratecontrol_bailout;
3286         }
3287         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3288                 warnx("XPT_PATH_INQ CCB failed");
3289                 if (arglist & CAM_ARG_VERBOSE) {
3290                         cam_error_print(device, ccb, CAM_ESF_ALL,
3291                                         CAM_EPF_ALL, stderr);
3292                 }
3293                 retval = 1;
3294                 goto ratecontrol_bailout;
3295         }
3296         bcopy(&ccb->cpi, &cpi, sizeof(struct ccb_pathinq));
3297         bzero(&(&ccb->ccb_h)[1],
3298               sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr));
3299         if (quiet == 0) {
3300                 fprintf(stdout, "%s parameters:\n",
3301                     user_settings ? "User" : "Current");
3302         }
3303         retval = get_print_cts(device, user_settings, quiet, &ccb->cts);
3304         if (retval != 0)
3305                 goto ratecontrol_bailout;
3306
3307         if (arglist & CAM_ARG_VERBOSE)
3308                 cpi_print(&cpi);
3309
3310         if (change_settings) {
3311                 int didsettings = 0;
3312                 struct ccb_trans_settings_spi *spi = NULL;
3313                 struct ccb_trans_settings_ata *ata = NULL;
3314                 struct ccb_trans_settings_sata *sata = NULL;
3315                 struct ccb_trans_settings_scsi *scsi = NULL;
3316
3317                 if (ccb->cts.transport == XPORT_SPI)
3318                         spi = &ccb->cts.xport_specific.spi;
3319                 if (ccb->cts.transport == XPORT_ATA)
3320                         ata = &ccb->cts.xport_specific.ata;
3321                 if (ccb->cts.transport == XPORT_SATA)
3322                         sata = &ccb->cts.xport_specific.sata;
3323                 if (ccb->cts.protocol == PROTO_SCSI)
3324                         scsi = &ccb->cts.proto_specific.scsi;
3325                 ccb->cts.xport_specific.valid = 0;
3326                 ccb->cts.proto_specific.valid = 0;
3327                 if (spi && disc_enable != -1) {
3328                         spi->valid |= CTS_SPI_VALID_DISC;
3329                         if (disc_enable == 0)
3330                                 spi->flags &= ~CTS_SPI_FLAGS_DISC_ENB;
3331                         else
3332                                 spi->flags |= CTS_SPI_FLAGS_DISC_ENB;
3333                 }
3334                 if (scsi && tag_enable != -1) {
3335                         if ((cpi.hba_inquiry & PI_TAG_ABLE) == 0) {
3336                                 warnx("HBA does not support tagged queueing, "
3337                                       "so you cannot modify tag settings");
3338                                 retval = 1;
3339                                 goto ratecontrol_bailout;
3340                         }
3341                         scsi->valid |= CTS_SCSI_VALID_TQ;
3342                         if (tag_enable == 0)
3343                                 scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB;
3344                         else
3345                                 scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB;
3346                         didsettings++;
3347                 }
3348                 if (spi && offset != -1) {
3349                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
3350                                 warnx("HBA is not capable of changing offset");
3351                                 retval = 1;
3352                                 goto ratecontrol_bailout;
3353                         }
3354                         spi->valid |= CTS_SPI_VALID_SYNC_OFFSET;
3355                         spi->sync_offset = offset;
3356                         didsettings++;
3357                 }
3358                 if (spi && syncrate != -1) {
3359                         int prelim_sync_period;
3360                         u_int freq;
3361
3362                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
3363                                 warnx("HBA is not capable of changing "
3364                                       "transfer rates");
3365                                 retval = 1;
3366                                 goto ratecontrol_bailout;
3367                         }
3368                         spi->valid |= CTS_SPI_VALID_SYNC_RATE;
3369                         /*
3370                          * The sync rate the user gives us is in MHz.
3371                          * We need to translate it into KHz for this
3372                          * calculation.
3373                          */
3374                         syncrate *= 1000;
3375                         /*
3376                          * Next, we calculate a "preliminary" sync period
3377                          * in tenths of a nanosecond.
3378                          */
3379                         if (syncrate == 0)
3380                                 prelim_sync_period = 0;
3381                         else
3382                                 prelim_sync_period = 10000000 / syncrate;
3383                         spi->sync_period =
3384                                 scsi_calc_syncparam(prelim_sync_period);
3385                         freq = scsi_calc_syncsrate(spi->sync_period);
3386                         didsettings++;
3387                 }
3388                 if (sata && syncrate != -1) {
3389                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
3390                                 warnx("HBA is not capable of changing "
3391                                       "transfer rates");
3392                                 retval = 1;
3393                                 goto ratecontrol_bailout;
3394                         }
3395                         sata->revision = ata_speed2revision(syncrate * 100);
3396                         if (sata->revision < 0) {
3397                                 warnx("Invalid rate %f", syncrate);
3398                                 retval = 1;
3399                                 goto ratecontrol_bailout;
3400                         }
3401                         sata->valid |= CTS_SATA_VALID_REVISION;
3402                         didsettings++;
3403                 }
3404                 if ((ata || sata) && mode != -1) {
3405                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
3406                                 warnx("HBA is not capable of changing "
3407                                       "transfer rates");
3408                                 retval = 1;
3409                                 goto ratecontrol_bailout;
3410                         }
3411                         if (ata) {
3412                                 ata->mode = mode;
3413                                 ata->valid |= CTS_ATA_VALID_MODE;
3414                         } else {
3415                                 sata->mode = mode;
3416                                 sata->valid |= CTS_SATA_VALID_MODE;
3417                         }
3418                         didsettings++;
3419                 }
3420                 /*
3421                  * The bus_width argument goes like this:
3422                  * 0 == 8 bit
3423                  * 1 == 16 bit
3424                  * 2 == 32 bit
3425                  * Therefore, if you shift the number of bits given on the
3426                  * command line right by 4, you should get the correct
3427                  * number.
3428                  */
3429                 if (spi && bus_width != -1) {
3430                         /*
3431                          * We might as well validate things here with a
3432                          * decipherable error message, rather than what
3433                          * will probably be an indecipherable error message
3434                          * by the time it gets back to us.
3435                          */
3436                         if ((bus_width == 16)
3437                          && ((cpi.hba_inquiry & PI_WIDE_16) == 0)) {
3438                                 warnx("HBA does not support 16 bit bus width");
3439                                 retval = 1;
3440                                 goto ratecontrol_bailout;
3441                         } else if ((bus_width == 32)
3442                                 && ((cpi.hba_inquiry & PI_WIDE_32) == 0)) {
3443                                 warnx("HBA does not support 32 bit bus width");
3444                                 retval = 1;
3445                                 goto ratecontrol_bailout;
3446                         } else if ((bus_width != 8)
3447                                 && (bus_width != 16)
3448                                 && (bus_width != 32)) {
3449                                 warnx("Invalid bus width %d", bus_width);
3450                                 retval = 1;
3451                                 goto ratecontrol_bailout;
3452                         }
3453                         spi->valid |= CTS_SPI_VALID_BUS_WIDTH;
3454                         spi->bus_width = bus_width >> 4;
3455                         didsettings++;
3456                 }
3457                 if  (didsettings == 0) {
3458                         goto ratecontrol_bailout;
3459                 }
3460                 if  (!user_settings && (ata || sata)) {
3461                         warnx("You can modify only user settings for ATA/SATA");
3462                         retval = 1;
3463                         goto ratecontrol_bailout;
3464                 }
3465                 ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
3466                 if (cam_send_ccb(device, ccb) < 0) {
3467                         perror("error sending XPT_SET_TRAN_SETTINGS CCB");
3468                         if (arglist & CAM_ARG_VERBOSE) {
3469                                 cam_error_print(device, ccb, CAM_ESF_ALL,
3470                                                 CAM_EPF_ALL, stderr);
3471                         }
3472                         retval = 1;
3473                         goto ratecontrol_bailout;
3474                 }
3475                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3476                         warnx("XPT_SET_TRANS_SETTINGS CCB failed");
3477                         if (arglist & CAM_ARG_VERBOSE) {
3478                                 cam_error_print(device, ccb, CAM_ESF_ALL,
3479                                                 CAM_EPF_ALL, stderr);
3480                         }
3481                         retval = 1;
3482                         goto ratecontrol_bailout;
3483                 }
3484         }
3485         if (send_tur) {
3486                 retval = testunitready(device, retry_count, timeout,
3487                                        (arglist & CAM_ARG_VERBOSE) ? 0 : 1);
3488                 /*
3489                  * If the TUR didn't succeed, just bail.
3490                  */
3491                 if (retval != 0) {
3492                         if (quiet == 0)
3493                                 fprintf(stderr, "Test Unit Ready failed\n");
3494                         goto ratecontrol_bailout;
3495                 }
3496                 /*
3497                  * If the user wants things quiet, there's no sense in
3498                  * getting the transfer settings, if we're not going
3499                  * to print them.
3500                  */
3501                 if (quiet != 0)
3502                         goto ratecontrol_bailout;
3503                 fprintf(stdout, "New parameters:\n");
3504                 retval = get_print_cts(device, user_settings, 0, NULL);
3505         }
3506
3507 ratecontrol_bailout:
3508         cam_freeccb(ccb);
3509         return(retval);
3510 }
3511
3512 static int
3513 scsiformat(struct cam_device *device, int argc, char **argv,
3514            char *combinedopt, int retry_count, int timeout)
3515 {
3516         union ccb *ccb;
3517         int c;
3518         int ycount = 0, quiet = 0;
3519         int error = 0, response = 0, retval = 0;
3520         int use_timeout = 10800 * 1000;
3521         int immediate = 1;
3522         struct format_defect_list_header fh;
3523         u_int8_t *data_ptr = NULL;
3524         u_int32_t dxfer_len = 0;
3525         u_int8_t byte2 = 0;
3526         int num_warnings = 0;
3527         int reportonly = 0;
3528
3529         ccb = cam_getccb(device);
3530
3531         if (ccb == NULL) {
3532                 warnx("scsiformat: error allocating ccb");
3533                 return(1);
3534         }
3535
3536         bzero(&(&ccb->ccb_h)[1],
3537               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
3538
3539         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3540                 switch(c) {
3541                 case 'q':
3542                         quiet++;
3543                         break;
3544                 case 'r':
3545                         reportonly = 1;
3546                         break;
3547                 case 'w':
3548                         immediate = 0;
3549                         break;
3550                 case 'y':
3551                         ycount++;
3552                         break;
3553                 }
3554         }
3555
3556         if (reportonly)
3557                 goto doreport;
3558
3559         if (quiet == 0) {
3560                 fprintf(stdout, "You are about to REMOVE ALL DATA from the "
3561                         "following device:\n");
3562
3563                 error = scsidoinquiry(device, argc, argv, combinedopt,
3564                                       retry_count, timeout);
3565
3566                 if (error != 0) {
3567                         warnx("scsiformat: error sending inquiry");
3568                         goto scsiformat_bailout;
3569                 }
3570         }
3571
3572         if (ycount == 0) {
3573
3574                 do {
3575                         char str[1024];
3576
3577                         fprintf(stdout, "Are you SURE you want to do "
3578                                 "this? (yes/no) ");
3579
3580                         if (fgets(str, sizeof(str), stdin) != NULL) {
3581
3582                                 if (strncasecmp(str, "yes", 3) == 0)
3583                                         response = 1;
3584                                 else if (strncasecmp(str, "no", 2) == 0)
3585                                         response = -1;
3586                                 else {
3587                                         fprintf(stdout, "Please answer"
3588                                                 " \"yes\" or \"no\"\n");
3589                                 }
3590                         }
3591                 } while (response == 0);
3592
3593                 if (response == -1) {
3594                         error = 1;
3595                         goto scsiformat_bailout;
3596                 }
3597         }
3598
3599         if (timeout != 0)
3600                 use_timeout = timeout;
3601
3602         if (quiet == 0) {
3603                 fprintf(stdout, "Current format timeout is %d seconds\n",
3604                         use_timeout / 1000);
3605         }
3606
3607         /*
3608          * If the user hasn't disabled questions and didn't specify a
3609          * timeout on the command line, ask them if they want the current
3610          * timeout.
3611          */
3612         if ((ycount == 0)
3613          && (timeout == 0)) {
3614                 char str[1024];
3615                 int new_timeout = 0;
3616
3617                 fprintf(stdout, "Enter new timeout in seconds or press\n"
3618                         "return to keep the current timeout [%d] ",
3619                         use_timeout / 1000);
3620
3621                 if (fgets(str, sizeof(str), stdin) != NULL) {
3622                         if (str[0] != '\0')
3623                                 new_timeout = atoi(str);
3624                 }
3625
3626                 if (new_timeout != 0) {
3627                         use_timeout = new_timeout * 1000;
3628                         fprintf(stdout, "Using new timeout value %d\n",
3629                                 use_timeout / 1000);
3630                 }
3631         }
3632
3633         /*
3634          * Keep this outside the if block below to silence any unused
3635          * variable warnings.
3636          */
3637         bzero(&fh, sizeof(fh));
3638
3639         /*
3640          * If we're in immediate mode, we've got to include the format
3641          * header
3642          */
3643         if (immediate != 0) {
3644                 fh.byte2 = FU_DLH_IMMED;
3645                 data_ptr = (u_int8_t *)&fh;
3646                 dxfer_len = sizeof(fh);
3647                 byte2 = FU_FMT_DATA;
3648         } else if (quiet == 0) {
3649                 fprintf(stdout, "Formatting...");
3650                 fflush(stdout);
3651         }
3652
3653         scsi_format_unit(&ccb->csio,
3654                          /* retries */ retry_count,
3655                          /* cbfcnp */ NULL,
3656                          /* tag_action */ MSG_SIMPLE_Q_TAG,
3657                          /* byte2 */ byte2,
3658                          /* ileave */ 0,
3659                          /* data_ptr */ data_ptr,
3660                          /* dxfer_len */ dxfer_len,
3661                          /* sense_len */ SSD_FULL_SIZE,
3662                          /* timeout */ use_timeout);
3663
3664         /* Disable freezing the device queue */
3665         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
3666
3667         if (arglist & CAM_ARG_ERR_RECOVER)
3668                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
3669
3670         if (((retval = cam_send_ccb(device, ccb)) < 0)
3671          || ((immediate == 0)
3672            && ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP))) {
3673                 const char errstr[] = "error sending format command";
3674
3675                 if (retval < 0)
3676                         warn(errstr);
3677                 else
3678                         warnx(errstr);
3679
3680                 if (arglist & CAM_ARG_VERBOSE) {
3681                         cam_error_print(device, ccb, CAM_ESF_ALL,
3682                                         CAM_EPF_ALL, stderr);
3683                 }
3684                 error = 1;
3685                 goto scsiformat_bailout;
3686         }
3687
3688         /*
3689          * If we ran in non-immediate mode, we already checked for errors
3690          * above and printed out any necessary information.  If we're in
3691          * immediate mode, we need to loop through and get status
3692          * information periodically.
3693          */
3694         if (immediate == 0) {
3695                 if (quiet == 0) {
3696                         fprintf(stdout, "Format Complete\n");
3697                 }
3698                 goto scsiformat_bailout;
3699         }
3700
3701 doreport:
3702         do {
3703                 cam_status status;
3704
3705                 bzero(&(&ccb->ccb_h)[1],
3706                       sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
3707
3708                 /*
3709                  * There's really no need to do error recovery or
3710                  * retries here, since we're just going to sit in a
3711                  * loop and wait for the device to finish formatting.
3712                  */
3713                 scsi_test_unit_ready(&ccb->csio,
3714                                      /* retries */ 0,
3715                                      /* cbfcnp */ NULL,
3716                                      /* tag_action */ MSG_SIMPLE_Q_TAG,
3717                                      /* sense_len */ SSD_FULL_SIZE,
3718                                      /* timeout */ 5000);
3719
3720                 /* Disable freezing the device queue */
3721                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
3722
3723                 retval = cam_send_ccb(device, ccb);
3724
3725                 /*
3726                  * If we get an error from the ioctl, bail out.  SCSI
3727                  * errors are expected.
3728                  */
3729                 if (retval < 0) {
3730                         warn("error sending CAMIOCOMMAND ioctl");
3731                         if (arglist & CAM_ARG_VERBOSE) {
3732                                 cam_error_print(device, ccb, CAM_ESF_ALL,
3733                                                 CAM_EPF_ALL, stderr);
3734                         }
3735                         error = 1;
3736                         goto scsiformat_bailout;
3737                 }
3738
3739                 status = ccb->ccb_h.status & CAM_STATUS_MASK;
3740
3741                 if ((status != CAM_REQ_CMP)
3742                  && (status == CAM_SCSI_STATUS_ERROR)
3743                  && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
3744                         struct scsi_sense_data *sense;
3745                         int error_code, sense_key, asc, ascq;
3746
3747                         sense = &ccb->csio.sense_data;
3748                         scsi_extract_sense(sense, &error_code, &sense_key,
3749                                            &asc, &ascq);
3750
3751                         /*
3752                          * According to the SCSI-2 and SCSI-3 specs, a
3753                          * drive that is in the middle of a format should
3754                          * return NOT READY with an ASC of "logical unit
3755                          * not ready, format in progress".  The sense key
3756                          * specific bytes will then be a progress indicator.
3757                          */
3758                         if ((sense_key == SSD_KEY_NOT_READY)
3759                          && (asc == 0x04) && (ascq == 0x04)) {
3760                                 if ((sense->extra_len >= 10)
3761                                  && ((sense->sense_key_spec[0] &
3762                                       SSD_SCS_VALID) != 0)
3763                                  && (quiet == 0)) {
3764                                         int val;
3765                                         u_int64_t percentage;
3766
3767                                         val = scsi_2btoul(
3768                                                 &sense->sense_key_spec[1]);
3769                                         percentage = 10000 * val;
3770
3771                                         fprintf(stdout,
3772                                                 "\rFormatting:  %ju.%02u %% "
3773                                                 "(%d/%d) done",
3774                                                 (uintmax_t)(percentage /
3775                                                 (0x10000 * 100)),
3776                                                 (unsigned)((percentage /
3777                                                 0x10000) % 100),
3778                                                 val, 0x10000);
3779                                         fflush(stdout);
3780                                 } else if ((quiet == 0)
3781                                         && (++num_warnings <= 1)) {
3782                                         warnx("Unexpected SCSI Sense Key "
3783                                               "Specific value returned "
3784                                               "during format:");
3785                                         scsi_sense_print(device, &ccb->csio,
3786                                                          stderr);
3787                                         warnx("Unable to print status "
3788                                               "information, but format will "
3789                                               "proceed.");
3790                                         warnx("will exit when format is "
3791                                               "complete");
3792                                 }
3793                                 sleep(1);
3794                         } else {
3795                                 warnx("Unexpected SCSI error during format");
3796                                 cam_error_print(device, ccb, CAM_ESF_ALL,
3797                                                 CAM_EPF_ALL, stderr);
3798                                 error = 1;
3799                                 goto scsiformat_bailout;
3800                         }
3801
3802                 } else if (status != CAM_REQ_CMP) {
3803                         warnx("Unexpected CAM status %#x", status);
3804                         if (arglist & CAM_ARG_VERBOSE)
3805                                 cam_error_print(device, ccb, CAM_ESF_ALL,
3806                                                 CAM_EPF_ALL, stderr);
3807                         error = 1;
3808                         goto scsiformat_bailout;
3809                 }
3810
3811         } while((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP);
3812
3813         if (quiet == 0)
3814                 fprintf(stdout, "\nFormat Complete\n");
3815
3816 scsiformat_bailout:
3817
3818         cam_freeccb(ccb);
3819
3820         return(error);
3821 }
3822
3823 static int
3824 scsireportluns(struct cam_device *device, int argc, char **argv,
3825                char *combinedopt, int retry_count, int timeout)
3826 {
3827         union ccb *ccb;
3828         int c, countonly, lunsonly;
3829         struct scsi_report_luns_data *lundata;
3830         int alloc_len;
3831         uint8_t report_type;
3832         uint32_t list_len, i, j;
3833         int retval;
3834
3835         retval = 0;
3836         lundata = NULL;
3837         report_type = RPL_REPORT_DEFAULT;
3838         ccb = cam_getccb(device);
3839
3840         if (ccb == NULL) {
3841                 warnx("%s: error allocating ccb", __func__);
3842                 return (1);
3843         }
3844
3845         bzero(&(&ccb->ccb_h)[1],
3846               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
3847
3848         countonly = 0;
3849         lunsonly = 0;
3850
3851         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3852                 switch (c) {
3853                 case 'c':
3854                         countonly++;
3855                         break;
3856                 case 'l':
3857                         lunsonly++;
3858                         break;
3859                 case 'r':
3860                         if (strcasecmp(optarg, "default") == 0)
3861                                 report_type = RPL_REPORT_DEFAULT;
3862                         else if (strcasecmp(optarg, "wellknown") == 0)
3863                                 report_type = RPL_REPORT_WELLKNOWN;
3864                         else if (strcasecmp(optarg, "all") == 0)
3865                                 report_type = RPL_REPORT_ALL;
3866                         else {
3867                                 warnx("%s: invalid report type \"%s\"",
3868                                       __func__, optarg);
3869                                 retval = 1;
3870                                 goto bailout;
3871                         }
3872                         break;
3873                 default:
3874                         break;
3875                 }
3876         }
3877
3878         if ((countonly != 0)
3879          && (lunsonly != 0)) {
3880                 warnx("%s: you can only specify one of -c or -l", __func__);
3881                 retval = 1;
3882                 goto bailout;
3883         }
3884         /*
3885          * According to SPC-4, the allocation length must be at least 16
3886          * bytes -- enough for the header and one LUN.
3887          */
3888         alloc_len = sizeof(*lundata) + 8;
3889
3890 retry:
3891
3892         lundata = malloc(alloc_len);
3893
3894         if (lundata == NULL) {
3895                 warn("%s: error mallocing %d bytes", __func__, alloc_len);
3896                 retval = 1;
3897                 goto bailout;
3898         }
3899
3900         scsi_report_luns(&ccb->csio,
3901                          /*retries*/ retry_count,
3902                          /*cbfcnp*/ NULL,
3903                          /*tag_action*/ MSG_SIMPLE_Q_TAG,
3904                          /*select_report*/ report_type,
3905                          /*rpl_buf*/ lundata,
3906                          /*alloc_len*/ alloc_len,
3907                          /*sense_len*/ SSD_FULL_SIZE,
3908                          /*timeout*/ timeout ? timeout : 5000);
3909
3910         /* Disable freezing the device queue */
3911         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
3912
3913         if (arglist & CAM_ARG_ERR_RECOVER)
3914                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
3915
3916         if (cam_send_ccb(device, ccb) < 0) {
3917                 warn("error sending REPORT LUNS command");
3918
3919                 if (arglist & CAM_ARG_VERBOSE)
3920                         cam_error_print(device, ccb, CAM_ESF_ALL,
3921                                         CAM_EPF_ALL, stderr);
3922
3923                 retval = 1;
3924                 goto bailout;
3925         }
3926
3927         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3928                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
3929                 retval = 1;
3930                 goto bailout;
3931         }
3932
3933
3934         list_len = scsi_4btoul(lundata->length);
3935
3936         /*
3937          * If we need to list the LUNs, and our allocation
3938          * length was too short, reallocate and retry.
3939          */
3940         if ((countonly == 0)
3941          && (list_len > (alloc_len - sizeof(*lundata)))) {
3942                 alloc_len = list_len + sizeof(*lundata);
3943                 free(lundata);
3944                 goto retry;
3945         }
3946
3947         if (lunsonly == 0)
3948                 fprintf(stdout, "%u LUN%s found\n", list_len / 8,
3949                         ((list_len / 8) > 1) ? "s" : "");
3950
3951         if (countonly != 0)
3952                 goto bailout;
3953
3954         for (i = 0; i < (list_len / 8); i++) {
3955                 int no_more;
3956
3957                 no_more = 0;
3958                 for (j = 0; j < sizeof(lundata->luns[i].lundata); j += 2) {
3959                         if (j != 0)
3960                                 fprintf(stdout, ",");
3961                         switch (lundata->luns[i].lundata[j] &
3962                                 RPL_LUNDATA_ATYP_MASK) {
3963                         case RPL_LUNDATA_ATYP_PERIPH:
3964                                 if ((lundata->luns[i].lundata[j] &
3965                                     RPL_LUNDATA_PERIPH_BUS_MASK) != 0)
3966                                         fprintf(stdout, "%d:",
3967                                                 lundata->luns[i].lundata[j] &
3968                                                 RPL_LUNDATA_PERIPH_BUS_MASK);
3969                                 else if ((j == 0)
3970                                       && ((lundata->luns[i].lundata[j+2] &
3971                                           RPL_LUNDATA_PERIPH_BUS_MASK) == 0))
3972                                         no_more = 1;
3973
3974                                 fprintf(stdout, "%d",
3975                                         lundata->luns[i].lundata[j+1]);
3976                                 break;
3977                         case RPL_LUNDATA_ATYP_FLAT: {
3978                                 uint8_t tmplun[2];
3979                                 tmplun[0] = lundata->luns[i].lundata[j] &
3980                                         RPL_LUNDATA_FLAT_LUN_MASK;
3981                                 tmplun[1] = lundata->luns[i].lundata[j+1];
3982
3983                                 fprintf(stdout, "%d", scsi_2btoul(tmplun));
3984                                 no_more = 1;
3985                                 break;
3986                         }
3987                         case RPL_LUNDATA_ATYP_LUN:
3988                                 fprintf(stdout, "%d:%d:%d",
3989                                         (lundata->luns[i].lundata[j+1] &
3990                                         RPL_LUNDATA_LUN_BUS_MASK) >> 5,
3991                                         lundata->luns[i].lundata[j] &
3992                                         RPL_LUNDATA_LUN_TARG_MASK,
3993                                         lundata->luns[i].lundata[j+1] &
3994                                         RPL_LUNDATA_LUN_LUN_MASK);
3995                                 break;
3996                         case RPL_LUNDATA_ATYP_EXTLUN: {
3997                                 int field_len, field_len_code, eam_code;
3998
3999                                 eam_code = lundata->luns[i].lundata[j] &
4000                                         RPL_LUNDATA_EXT_EAM_MASK;
4001                                 field_len_code = (lundata->luns[i].lundata[j] &
4002                                         RPL_LUNDATA_EXT_LEN_MASK) >> 4;
4003                                 field_len = field_len_code * 2;
4004
4005                                 if ((eam_code == RPL_LUNDATA_EXT_EAM_WK)
4006                                  && (field_len_code == 0x00)) {
4007                                         fprintf(stdout, "%d",
4008                                                 lundata->luns[i].lundata[j+1]);
4009                                 } else if ((eam_code ==
4010                                             RPL_LUNDATA_EXT_EAM_NOT_SPEC)
4011                                         && (field_len_code == 0x03)) {
4012                                         uint8_t tmp_lun[8];
4013
4014                                         /*
4015                                          * This format takes up all 8 bytes.
4016                                          * If we aren't starting at offset 0,
4017                                          * that's a bug.
4018                                          */
4019                                         if (j != 0) {
4020                                                 fprintf(stdout, "Invalid "
4021                                                         "offset %d for "
4022                                                         "Extended LUN not "
4023                                                         "specified format", j);
4024                                                 no_more = 1;
4025                                                 break;
4026                                         }
4027                                         bzero(tmp_lun, sizeof(tmp_lun));
4028                                         bcopy(&lundata->luns[i].lundata[j+1],
4029                                               &tmp_lun[1], sizeof(tmp_lun) - 1);
4030                                         fprintf(stdout, "%#jx",
4031                                                (intmax_t)scsi_8btou64(tmp_lun));
4032                                         no_more = 1;
4033                                 } else {
4034                                         fprintf(stderr, "Unknown Extended LUN"
4035                                                 "Address method %#x, length "
4036                                                 "code %#x", eam_code,
4037                                                 field_len_code);
4038                                         no_more = 1;
4039                                 }
4040                                 break;
4041                         }
4042                         default:
4043                                 fprintf(stderr, "Unknown LUN address method "
4044                                         "%#x\n", lundata->luns[i].lundata[0] &
4045                                         RPL_LUNDATA_ATYP_MASK);
4046                                 break;
4047                         }
4048                         /*
4049                          * For the flat addressing method, there are no
4050                          * other levels after it.
4051                          */
4052                         if (no_more != 0)
4053                                 break;
4054                 }
4055                 fprintf(stdout, "\n");
4056         }
4057
4058 bailout:
4059
4060         cam_freeccb(ccb);
4061
4062         free(lundata);
4063
4064         return (retval);
4065 }
4066
4067 static int
4068 scsireadcapacity(struct cam_device *device, int argc, char **argv,
4069                  char *combinedopt, int retry_count, int timeout)
4070 {
4071         union ccb *ccb;
4072         int blocksizeonly, humanize, numblocks, quiet, sizeonly, baseten;
4073         struct scsi_read_capacity_data rcap;
4074         struct scsi_read_capacity_data_long rcaplong;
4075         uint64_t maxsector;
4076         uint32_t block_len;
4077         int retval;
4078         int c;
4079
4080         blocksizeonly = 0;
4081         humanize = 0;
4082         numblocks = 0;
4083         quiet = 0;
4084         sizeonly = 0;
4085         baseten = 0;
4086         retval = 0;
4087
4088         ccb = cam_getccb(device);
4089
4090         if (ccb == NULL) {
4091                 warnx("%s: error allocating ccb", __func__);
4092                 return (1);
4093         }
4094
4095         bzero(&(&ccb->ccb_h)[1],
4096               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
4097
4098         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4099                 switch (c) {
4100                 case 'b':
4101                         blocksizeonly++;
4102                         break;
4103                 case 'h':
4104                         humanize++;
4105                         baseten = 0;
4106                         break;
4107                 case 'H':
4108                         humanize++;
4109                         baseten++;
4110                         break;
4111                 case 'N':
4112                         numblocks++;
4113                         break;
4114                 case 'q':
4115                         quiet++;
4116                         break;
4117                 case 's':
4118                         sizeonly++;
4119                         break;
4120                 default:
4121                         break;
4122                 }
4123         }
4124
4125         if ((blocksizeonly != 0)
4126          && (numblocks != 0)) {
4127                 warnx("%s: you can only specify one of -b or -N", __func__);
4128                 retval = 1;
4129                 goto bailout;
4130         }
4131
4132         if ((blocksizeonly != 0)
4133          && (sizeonly != 0)) {
4134                 warnx("%s: you can only specify one of -b or -s", __func__);
4135                 retval = 1;
4136                 goto bailout;
4137         }
4138
4139         if ((humanize != 0)
4140          && (quiet != 0)) {
4141                 warnx("%s: you can only specify one of -h/-H or -q", __func__);
4142                 retval = 1;
4143                 goto bailout;
4144         }
4145
4146         if ((humanize != 0)
4147          && (blocksizeonly != 0)) {
4148                 warnx("%s: you can only specify one of -h/-H or -b", __func__);
4149                 retval = 1;
4150                 goto bailout;
4151         }
4152
4153         scsi_read_capacity(&ccb->csio,
4154                            /*retries*/ retry_count,
4155                            /*cbfcnp*/ NULL,
4156                            /*tag_action*/ MSG_SIMPLE_Q_TAG,
4157                            &rcap,
4158                            SSD_FULL_SIZE,
4159                            /*timeout*/ timeout ? timeout : 5000);
4160
4161         /* Disable freezing the device queue */
4162         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
4163
4164         if (arglist & CAM_ARG_ERR_RECOVER)
4165                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
4166
4167         if (cam_send_ccb(device, ccb) < 0) {
4168                 warn("error sending READ CAPACITY command");
4169
4170                 if (arglist & CAM_ARG_VERBOSE)
4171                         cam_error_print(device, ccb, CAM_ESF_ALL,
4172                                         CAM_EPF_ALL, stderr);
4173
4174                 retval = 1;
4175                 goto bailout;
4176         }
4177
4178         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
4179                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
4180                 retval = 1;
4181                 goto bailout;
4182         }
4183
4184         maxsector = scsi_4btoul(rcap.addr);
4185         block_len = scsi_4btoul(rcap.length);
4186
4187         /*
4188          * A last block of 2^32-1 means that the true capacity is over 2TB,
4189          * and we need to issue the long READ CAPACITY to get the real
4190          * capacity.  Otherwise, we're all set.
4191          */
4192         if (maxsector != 0xffffffff)
4193                 goto do_print;
4194
4195         scsi_read_capacity_16(&ccb->csio,
4196                               /*retries*/ retry_count,
4197                               /*cbfcnp*/ NULL,
4198                               /*tag_action*/ MSG_SIMPLE_Q_TAG,
4199                               /*lba*/ 0,
4200                               /*reladdr*/ 0,
4201                               /*pmi*/ 0,
4202                               &rcaplong,
4203                               /*sense_len*/ SSD_FULL_SIZE,
4204                               /*timeout*/ timeout ? timeout : 5000);
4205
4206         /* Disable freezing the device queue */
4207         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
4208
4209         if (arglist & CAM_ARG_ERR_RECOVER)
4210                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
4211
4212         if (cam_send_ccb(device, ccb) < 0) {
4213                 warn("error sending READ CAPACITY (16) command");
4214
4215                 if (arglist & CAM_ARG_VERBOSE)
4216                         cam_error_print(device, ccb, CAM_ESF_ALL,
4217                                         CAM_EPF_ALL, stderr);
4218
4219                 retval = 1;
4220                 goto bailout;
4221         }
4222
4223         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
4224                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
4225                 retval = 1;
4226                 goto bailout;
4227         }
4228
4229         maxsector = scsi_8btou64(rcaplong.addr);
4230         block_len = scsi_4btoul(rcaplong.length);
4231
4232 do_print:
4233         if (blocksizeonly == 0) {
4234                 /*
4235                  * Humanize implies !quiet, and also implies numblocks.
4236                  */
4237                 if (humanize != 0) {
4238                         char tmpstr[6];
4239                         int64_t tmpbytes;
4240                         int ret;
4241
4242                         tmpbytes = (maxsector + 1) * block_len;
4243                         ret = humanize_number(tmpstr, sizeof(tmpstr),
4244                                               tmpbytes, "", HN_AUTOSCALE,
4245                                               HN_B | HN_DECIMAL |
4246                                               ((baseten != 0) ?
4247                                               HN_DIVISOR_1000 : 0));
4248                         if (ret == -1) {
4249                                 warnx("%s: humanize_number failed!", __func__);
4250                                 retval = 1;
4251                                 goto bailout;
4252                         }
4253                         fprintf(stdout, "Device Size: %s%s", tmpstr,
4254                                 (sizeonly == 0) ?  ", " : "\n");
4255                 } else if (numblocks != 0) {
4256                         fprintf(stdout, "%s%ju%s", (quiet == 0) ?
4257                                 "Blocks: " : "", (uintmax_t)maxsector + 1,
4258                                 (sizeonly == 0) ? ", " : "\n");
4259                 } else {
4260                         fprintf(stdout, "%s%ju%s", (quiet == 0) ?
4261                                 "Last Block: " : "", (uintmax_t)maxsector,
4262                                 (sizeonly == 0) ? ", " : "\n");
4263                 }
4264         }
4265         if (sizeonly == 0)
4266                 fprintf(stdout, "%s%u%s\n", (quiet == 0) ?
4267                         "Block Length: " : "", block_len, (quiet == 0) ?
4268                         " bytes" : "");
4269 bailout:
4270         cam_freeccb(ccb);
4271
4272         return (retval);
4273 }
4274
4275 static int
4276 atapm(struct cam_device *device, int argc, char **argv,
4277                  char *combinedopt, int retry_count, int timeout)
4278 {
4279         union ccb *ccb;
4280         int retval = 0;
4281         int t = -1;
4282         int c;
4283         u_char cmd, sc;
4284
4285         ccb = cam_getccb(device);
4286
4287         if (ccb == NULL) {
4288                 warnx("%s: error allocating ccb", __func__);
4289                 return (1);
4290         }
4291
4292         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4293                 switch (c) {
4294                 case 't':
4295                         t = atoi(optarg);
4296                         break;
4297                 default:
4298                         break;
4299                 }
4300         }
4301         if (strcmp(argv[1], "idle") == 0) {
4302                 if (t == -1)
4303                         cmd = ATA_IDLE_IMMEDIATE;
4304                 else
4305                         cmd = ATA_IDLE_CMD;
4306         } else if (strcmp(argv[1], "standby") == 0) {
4307                 if (t == -1)
4308                         cmd = ATA_STANDBY_IMMEDIATE;
4309                 else
4310                         cmd = ATA_STANDBY_CMD;
4311         } else {
4312                 cmd = ATA_SLEEP;
4313                 t = -1;
4314         }
4315         if (t < 0)
4316                 sc = 0;
4317         else if (t <= (240 * 5))
4318                 sc = t / 5;
4319         else if (t <= (11 * 30 * 60))
4320                 sc = t / (30 * 60) + 241;
4321         else
4322                 sc = 253;
4323         cam_fill_ataio(&ccb->ataio,
4324                       retry_count,
4325                       NULL,
4326                       /*flags*/CAM_DIR_NONE,
4327                       MSG_SIMPLE_Q_TAG,
4328                       /*data_ptr*/NULL,
4329                       /*dxfer_len*/0,
4330                       timeout ? timeout : 30 * 1000);
4331         ata_28bit_cmd(&ccb->ataio, cmd, 0, 0, sc);
4332
4333         /* Disable freezing the device queue */
4334         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
4335
4336         if (arglist & CAM_ARG_ERR_RECOVER)
4337                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
4338
4339         if (cam_send_ccb(device, ccb) < 0) {
4340                 warn("error sending command");
4341
4342                 if (arglist & CAM_ARG_VERBOSE)
4343                         cam_error_print(device, ccb, CAM_ESF_ALL,
4344                                         CAM_EPF_ALL, stderr);
4345
4346                 retval = 1;
4347                 goto bailout;
4348         }
4349
4350         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
4351                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
4352                 retval = 1;
4353                 goto bailout;
4354         }
4355 bailout:
4356         cam_freeccb(ccb);
4357         return (retval);
4358 }
4359
4360 #endif /* MINIMALISTIC */
4361
4362 void
4363 usage(int verbose)
4364 {
4365         fprintf(verbose ? stdout : stderr,
4366 "usage:  camcontrol <command>  [device id][generic args][command args]\n"
4367 "        camcontrol devlist    [-v]\n"
4368 #ifndef MINIMALISTIC
4369 "        camcontrol periphlist [dev_id][-n dev_name] [-u unit]\n"
4370 "        camcontrol tur        [dev_id][generic args]\n"
4371 "        camcontrol inquiry    [dev_id][generic args] [-D] [-S] [-R]\n"
4372 "        camcontrol identify   [dev_id][generic args] [-v]\n"
4373 "        camcontrol reportluns [dev_id][generic args] [-c] [-l] [-r report]\n"
4374 "        camcontrol readcap    [dev_id][generic args] [-b] [-h] [-H] [-N]\n"
4375 "                              [-q] [-s]\n"
4376 "        camcontrol start      [dev_id][generic args]\n"
4377 "        camcontrol stop       [dev_id][generic args]\n"
4378 "        camcontrol load       [dev_id][generic args]\n"
4379 "        camcontrol eject      [dev_id][generic args]\n"
4380 #endif /* MINIMALISTIC */
4381 "        camcontrol rescan     <all | bus[:target:lun]>\n"
4382 "        camcontrol reset      <all | bus[:target:lun]>\n"
4383 #ifndef MINIMALISTIC
4384 "        camcontrol defects    [dev_id][generic args] <-f format> [-P][-G]\n"
4385 "        camcontrol modepage   [dev_id][generic args] <-m page | -l>\n"
4386 "                              [-P pagectl][-e | -b][-d]\n"
4387 "        camcontrol cmd        [dev_id][generic args]\n"
4388 "                              <-a cmd [args] | -c cmd [args]>\n"
4389 "                              [-d] [-f] [-i len fmt|-o len fmt [args]] [-r fmt]\n"
4390 "        camcontrol debug      [-I][-P][-T][-S][-X][-c]\n"
4391 "                              <all|bus[:target[:lun]]|off>\n"
4392 "        camcontrol tags       [dev_id][generic args] [-N tags] [-q] [-v]\n"
4393 "        camcontrol negotiate  [dev_id][generic args] [-a][-c]\n"
4394 "                              [-D <enable|disable>][-M mode][-O offset]\n"
4395 "                              [-q][-R syncrate][-v][-T <enable|disable>]\n"
4396 "                              [-U][-W bus_width]\n"
4397 "        camcontrol format     [dev_id][generic args][-q][-r][-w][-y]\n"
4398 "        camcontrol idle       [dev_id][generic args][-t time]\n"
4399 "        camcontrol standby    [dev_id][generic args][-t time]\n"
4400 "        camcontrol sleep      [dev_id][generic args]\n"
4401 #endif /* MINIMALISTIC */
4402 "        camcontrol help\n");
4403         if (!verbose)
4404                 return;
4405 #ifndef MINIMALISTIC
4406         fprintf(stdout,
4407 "Specify one of the following options:\n"
4408 "devlist     list all CAM devices\n"
4409 "periphlist  list all CAM peripheral drivers attached to a device\n"
4410 "tur         send a test unit ready to the named device\n"
4411 "inquiry     send a SCSI inquiry command to the named device\n"
4412 "identify    send a ATA identify command to the named device\n"
4413 "reportluns  send a SCSI report luns command to the device\n"
4414 "readcap     send a SCSI read capacity command to the device\n"
4415 "start       send a Start Unit command to the device\n"
4416 "stop        send a Stop Unit command to the device\n"
4417 "load        send a Start Unit command to the device with the load bit set\n"
4418 "eject       send a Stop Unit command to the device with the eject bit set\n"
4419 "rescan      rescan all busses, the given bus, or bus:target:lun\n"
4420 "reset       reset all busses, the given bus, or bus:target:lun\n"
4421 "defects     read the defect list of the specified device\n"
4422 "modepage    display or edit (-e) the given mode page\n"
4423 "cmd         send the given scsi command, may need -i or -o as well\n"
4424 "debug       turn debugging on/off for a bus, target, or lun, or all devices\n"
4425 "tags        report or set the number of transaction slots for a device\n"
4426 "negotiate   report or set device negotiation parameters\n"
4427 "format      send the SCSI FORMAT UNIT command to the named device\n"
4428 "idle        send the ATA IDLE command to the named device\n"
4429 "standby     send the ATA STANDBY command to the named device\n"
4430 "sleep       send the ATA SLEEP command to the named device\n"
4431 "help        this message\n"
4432 "Device Identifiers:\n"
4433 "bus:target        specify the bus and target, lun defaults to 0\n"
4434 "bus:target:lun    specify the bus, target and lun\n"
4435 "deviceUNIT        specify the device name, like \"da4\" or \"cd2\"\n"
4436 "Generic arguments:\n"
4437 "-v                be verbose, print out sense information\n"
4438 "-t timeout        command timeout in seconds, overrides default timeout\n"
4439 "-n dev_name       specify device name, e.g. \"da\", \"cd\"\n"
4440 "-u unit           specify unit number, e.g. \"0\", \"5\"\n"
4441 "-E                have the kernel attempt to perform SCSI error recovery\n"
4442 "-C count          specify the SCSI command retry count (needs -E to work)\n"
4443 "modepage arguments:\n"
4444 "-l                list all available mode pages\n"
4445 "-m page           specify the mode page to view or edit\n"
4446 "-e                edit the specified mode page\n"
4447 "-b                force view to binary mode\n"
4448 "-d                disable block descriptors for mode sense\n"
4449 "-P pgctl          page control field 0-3\n"
4450 "defects arguments:\n"
4451 "-f format         specify defect list format (block, bfi or phys)\n"
4452 "-G                get the grown defect list\n"
4453 "-P                get the permanant defect list\n"
4454 "inquiry arguments:\n"
4455 "-D                get the standard inquiry data\n"
4456 "-S                get the serial number\n"
4457 "-R                get the transfer rate, etc.\n"
4458 "reportluns arguments:\n"
4459 "-c                only report a count of available LUNs\n"
4460 "-l                only print out luns, and not a count\n"
4461 "-r <reporttype>   specify \"default\", \"wellknown\" or \"all\"\n"
4462 "readcap arguments\n"
4463 "-b                only report the blocksize\n"
4464 "-h                human readable device size, base 2\n"
4465 "-H                human readable device size, base 10\n"
4466 "-N                print the number of blocks instead of last block\n"
4467 "-q                quiet, print numbers only\n"
4468 "-s                only report the last block/device size\n"
4469 "cmd arguments:\n"
4470 "-c cdb [args]     specify the SCSI CDB\n"
4471 "-i len fmt        specify input data and input data format\n"
4472 "-o len fmt [args] specify output data and output data fmt\n"
4473 "debug arguments:\n"
4474 "-I                CAM_DEBUG_INFO -- scsi commands, errors, data\n"
4475 "-T                CAM_DEBUG_TRACE -- routine flow tracking\n"
4476 "-S                CAM_DEBUG_SUBTRACE -- internal routine command flow\n"
4477 "-c                CAM_DEBUG_CDB -- print out SCSI CDBs only\n"
4478 "tags arguments:\n"
4479 "-N tags           specify the number of tags to use for this device\n"
4480 "-q                be quiet, don't report the number of tags\n"
4481 "-v                report a number of tag-related parameters\n"
4482 "negotiate arguments:\n"
4483 "-a                send a test unit ready after negotiation\n"
4484 "-c                report/set current negotiation settings\n"
4485 "-D <arg>          \"enable\" or \"disable\" disconnection\n"
4486 "-M mode           set ATA mode\n"
4487 "-O offset         set command delay offset\n"
4488 "-q                be quiet, don't report anything\n"
4489 "-R syncrate       synchronization rate in MHz\n"
4490 "-T <arg>          \"enable\" or \"disable\" tagged queueing\n"
4491 "-U                report/set user negotiation settings\n"
4492 "-W bus_width      set the bus width in bits (8, 16 or 32)\n"
4493 "-v                also print a Path Inquiry CCB for the controller\n"
4494 "format arguments:\n"
4495 "-q                be quiet, don't print status messages\n"
4496 "-r                run in report only mode\n"
4497 "-w                don't send immediate format command\n"
4498 "-y                don't ask any questions\n"
4499 "idle/standby arguments:\n"
4500 "-t <arg>          number of seconds before respective state.\n");
4501 #endif /* MINIMALISTIC */
4502 }
4503
4504 int
4505 main(int argc, char **argv)
4506 {
4507         int c;
4508         char *device = NULL;
4509         int unit = 0;
4510         struct cam_device *cam_dev = NULL;
4511         int timeout = 0, retry_count = 1;
4512         camcontrol_optret optreturn;
4513         char *tstr;
4514         const char *mainopt = "C:En:t:u:v";
4515         const char *subopt = NULL;
4516         char combinedopt[256];
4517         int error = 0, optstart = 2;
4518         int devopen = 1;
4519 #ifndef MINIMALISTIC
4520         int bus, target, lun;
4521 #endif /* MINIMALISTIC */
4522
4523         cmdlist = CAM_CMD_NONE;
4524         arglist = CAM_ARG_NONE;
4525
4526         if (argc < 2) {
4527                 usage(0);
4528                 exit(1);
4529         }
4530
4531         /*
4532          * Get the base option.
4533          */
4534         optreturn = getoption(argv[1], &cmdlist, &arglist, &subopt);
4535
4536         if (optreturn == CC_OR_AMBIGUOUS) {
4537                 warnx("ambiguous option %s", argv[1]);
4538                 usage(0);
4539                 exit(1);
4540         } else if (optreturn == CC_OR_NOT_FOUND) {
4541                 warnx("option %s not found", argv[1]);
4542                 usage(0);
4543                 exit(1);
4544         }
4545
4546         /*
4547          * Ahh, getopt(3) is a pain.
4548          *
4549          * This is a gross hack.  There really aren't many other good
4550          * options (excuse the pun) for parsing options in a situation like
4551          * this.  getopt is kinda braindead, so you end up having to run
4552          * through the options twice, and give each invocation of getopt
4553          * the option string for the other invocation.
4554          *
4555          * You would think that you could just have two groups of options.
4556          * The first group would get parsed by the first invocation of
4557          * getopt, and the second group would get parsed by the second
4558          * invocation of getopt.  It doesn't quite work out that way.  When
4559          * the first invocation of getopt finishes, it leaves optind pointing
4560          * to the argument _after_ the first argument in the second group.
4561          * So when the second invocation of getopt comes around, it doesn't
4562          * recognize the first argument it gets and then bails out.
4563          *
4564          * A nice alternative would be to have a flag for getopt that says
4565          * "just keep parsing arguments even when you encounter an unknown
4566          * argument", but there isn't one.  So there's no real clean way to
4567          * easily parse two sets of arguments without having one invocation
4568          * of getopt know about the other.
4569          *
4570          * Without this hack, the first invocation of getopt would work as
4571          * long as the generic arguments are first, but the second invocation
4572          * (in the subfunction) would fail in one of two ways.  In the case
4573          * where you don't set optreset, it would fail because optind may be
4574          * pointing to the argument after the one it should be pointing at.
4575          * In the case where you do set optreset, and reset optind, it would
4576          * fail because getopt would run into the first set of options, which
4577          * it doesn't understand.
4578          *
4579          * All of this would "sort of" work if you could somehow figure out
4580          * whether optind had been incremented one option too far.  The
4581          * mechanics of that, however, are more daunting than just giving
4582          * both invocations all of the expect options for either invocation.
4583          *
4584          * Needless to say, I wouldn't mind if someone invented a better
4585          * (non-GPL!) command line parsing interface than getopt.  I
4586          * wouldn't mind if someone added more knobs to getopt to make it
4587          * work better.  Who knows, I may talk myself into doing it someday,
4588          * if the standards weenies let me.  As it is, it just leads to
4589          * hackery like this and causes people to avoid it in some cases.
4590          *
4591          * KDM, September 8th, 1998
4592          */
4593         if (subopt != NULL)
4594                 sprintf(combinedopt, "%s%s", mainopt, subopt);
4595         else
4596                 sprintf(combinedopt, "%s", mainopt);
4597
4598         /*
4599          * For these options we do not parse optional device arguments and
4600          * we do not open a passthrough device.
4601          */
4602         if ((cmdlist == CAM_CMD_RESCAN)
4603          || (cmdlist == CAM_CMD_RESET)
4604          || (cmdlist == CAM_CMD_DEVTREE)
4605          || (cmdlist == CAM_CMD_USAGE)
4606          || (cmdlist == CAM_CMD_DEBUG))
4607                 devopen = 0;
4608
4609 #ifndef MINIMALISTIC
4610         if ((devopen == 1)
4611          && (argc > 2 && argv[2][0] != '-')) {
4612                 char name[30];
4613                 int rv;
4614
4615                 if (isdigit(argv[2][0])) {
4616                         /* device specified as bus:target[:lun] */
4617                         rv = parse_btl(argv[2], &bus, &target, &lun, &arglist);
4618                         if (rv < 2)
4619                                 errx(1, "numeric device specification must "
4620                                      "be either bus:target, or "
4621                                      "bus:target:lun");
4622                         /* default to 0 if lun was not specified */
4623                         if ((arglist & CAM_ARG_LUN) == 0) {
4624                                 lun = 0;
4625                                 arglist |= CAM_ARG_LUN;
4626                         }
4627                         optstart++;
4628                 } else {
4629                         if (cam_get_device(argv[2], name, sizeof name, &unit)
4630                             == -1)
4631                                 errx(1, "%s", cam_errbuf);
4632                         device = strdup(name);
4633                         arglist |= CAM_ARG_DEVICE | CAM_ARG_UNIT;
4634                         optstart++;
4635                 }
4636         }
4637 #endif /* MINIMALISTIC */
4638         /*
4639          * Start getopt processing at argv[2/3], since we've already
4640          * accepted argv[1..2] as the command name, and as a possible
4641          * device name.
4642          */
4643         optind = optstart;
4644
4645         /*
4646          * Now we run through the argument list looking for generic
4647          * options, and ignoring options that possibly belong to
4648          * subfunctions.
4649          */
4650         while ((c = getopt(argc, argv, combinedopt))!= -1){
4651                 switch(c) {
4652                         case 'C':
4653                                 retry_count = strtol(optarg, NULL, 0);
4654                                 if (retry_count < 0)
4655                                         errx(1, "retry count %d is < 0",
4656                                              retry_count);
4657                                 arglist |= CAM_ARG_RETRIES;
4658                                 break;
4659                         case 'E':
4660                                 arglist |= CAM_ARG_ERR_RECOVER;
4661                                 break;
4662                         case 'n':
4663                                 arglist |= CAM_ARG_DEVICE;
4664                                 tstr = optarg;
4665                                 while (isspace(*tstr) && (*tstr != '\0'))
4666                                         tstr++;
4667                                 device = (char *)strdup(tstr);
4668                                 break;
4669                         case 't':
4670                                 timeout = strtol(optarg, NULL, 0);
4671                                 if (timeout < 0)
4672                                         errx(1, "invalid timeout %d", timeout);
4673                                 /* Convert the timeout from seconds to ms */
4674                                 timeout *= 1000;
4675                                 arglist |= CAM_ARG_TIMEOUT;
4676                                 break;
4677                         case 'u':
4678                                 arglist |= CAM_ARG_UNIT;
4679                                 unit = strtol(optarg, NULL, 0);
4680                                 break;
4681                         case 'v':
4682                                 arglist |= CAM_ARG_VERBOSE;
4683                                 break;
4684                         default:
4685                                 break;
4686                 }
4687         }
4688
4689 #ifndef MINIMALISTIC
4690         /*
4691          * For most commands we'll want to open the passthrough device
4692          * associated with the specified device.  In the case of the rescan
4693          * commands, we don't use a passthrough device at all, just the
4694          * transport layer device.
4695          */
4696         if (devopen == 1) {
4697                 if (((arglist & (CAM_ARG_BUS|CAM_ARG_TARGET)) == 0)
4698                  && (((arglist & CAM_ARG_DEVICE) == 0)
4699                   || ((arglist & CAM_ARG_UNIT) == 0))) {
4700                         errx(1, "subcommand \"%s\" requires a valid device "
4701                              "identifier", argv[1]);
4702                 }
4703
4704                 if ((cam_dev = ((arglist & (CAM_ARG_BUS | CAM_ARG_TARGET))?
4705                                 cam_open_btl(bus, target, lun, O_RDWR, NULL) :
4706                                 cam_open_spec_device(device,unit,O_RDWR,NULL)))
4707                      == NULL)
4708                         errx(1,"%s", cam_errbuf);
4709         }
4710 #endif /* MINIMALISTIC */
4711
4712         /*
4713          * Reset optind to 2, and reset getopt, so these routines can parse
4714          * the arguments again.
4715          */
4716         optind = optstart;
4717         optreset = 1;
4718
4719         switch(cmdlist) {
4720 #ifndef MINIMALISTIC
4721                 case CAM_CMD_DEVLIST:
4722                         error = getdevlist(cam_dev);
4723                         break;
4724 #endif /* MINIMALISTIC */
4725                 case CAM_CMD_DEVTREE:
4726                         error = getdevtree();
4727                         break;
4728 #ifndef MINIMALISTIC
4729                 case CAM_CMD_TUR:
4730                         error = testunitready(cam_dev, retry_count, timeout, 0);
4731                         break;
4732                 case CAM_CMD_INQUIRY:
4733                         error = scsidoinquiry(cam_dev, argc, argv, combinedopt,
4734                                               retry_count, timeout);
4735                         break;
4736                 case CAM_CMD_IDENTIFY:
4737                         error = ataidentify(cam_dev, retry_count, timeout);
4738                         break;
4739                 case CAM_CMD_STARTSTOP:
4740                         error = scsistart(cam_dev, arglist & CAM_ARG_START_UNIT,
4741                                           arglist & CAM_ARG_EJECT, retry_count,
4742                                           timeout);
4743                         break;
4744 #endif /* MINIMALISTIC */
4745                 case CAM_CMD_RESCAN:
4746                         error = dorescan_or_reset(argc, argv, 1);
4747                         break;
4748                 case CAM_CMD_RESET:
4749                         error = dorescan_or_reset(argc, argv, 0);
4750                         break;
4751 #ifndef MINIMALISTIC
4752                 case CAM_CMD_READ_DEFECTS:
4753                         error = readdefects(cam_dev, argc, argv, combinedopt,
4754                                             retry_count, timeout);
4755                         break;
4756                 case CAM_CMD_MODE_PAGE:
4757                         modepage(cam_dev, argc, argv, combinedopt,
4758                                  retry_count, timeout);
4759                         break;
4760                 case CAM_CMD_SCSI_CMD:
4761                         error = scsicmd(cam_dev, argc, argv, combinedopt,
4762                                         retry_count, timeout);
4763                         break;
4764                 case CAM_CMD_DEBUG:
4765                         error = camdebug(argc, argv, combinedopt);
4766                         break;
4767                 case CAM_CMD_TAG:
4768                         error = tagcontrol(cam_dev, argc, argv, combinedopt);
4769                         break;
4770                 case CAM_CMD_RATE:
4771                         error = ratecontrol(cam_dev, retry_count, timeout,
4772                                             argc, argv, combinedopt);
4773                         break;
4774                 case CAM_CMD_FORMAT:
4775                         error = scsiformat(cam_dev, argc, argv,
4776                                            combinedopt, retry_count, timeout);
4777                         break;
4778                 case CAM_CMD_REPORTLUNS:
4779                         error = scsireportluns(cam_dev, argc, argv,
4780                                                combinedopt, retry_count,
4781                                                timeout);
4782                         break;
4783                 case CAM_CMD_READCAP:
4784                         error = scsireadcapacity(cam_dev, argc, argv,
4785                                                  combinedopt, retry_count,
4786                                                  timeout);
4787                         break;
4788                 case CAM_CMD_IDLE:
4789                 case CAM_CMD_STANDBY:
4790                 case CAM_CMD_SLEEP:
4791                         error = atapm(cam_dev, argc, argv,
4792                                                  combinedopt, retry_count,
4793                                                  timeout);
4794                         break;
4795 #endif /* MINIMALISTIC */
4796                 case CAM_CMD_USAGE:
4797                         usage(1);
4798                         break;
4799                 default:
4800                         usage(0);
4801                         error = 1;
4802                         break;
4803         }
4804
4805         if (cam_dev != NULL)
4806                 cam_close_device(cam_dev);
4807
4808         exit(error);
4809 }