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 #include <sys/sbuf.h>
  37
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <unistd.h>
  42 #include <inttypes.h>
  43 #include <limits.h>
  44 #include <fcntl.h>
  45 #include <ctype.h>
  46 #include <err.h>
  47 #include <libutil.h>
  48
  49 #include <cam/cam.h>
  50 #include <cam/cam_debug.h>
  51 #include <cam/cam_ccb.h>
  52 #include <cam/scsi/scsi_all.h>
  53 #include <cam/scsi/scsi_da.h>
  54 #include <cam/scsi/scsi_pass.h>
  55 #include <cam/scsi/scsi_message.h>
  56 #include <cam/scsi/smp_all.h>
  57 #include <cam/ata/ata_all.h>
  58 #include <camlib.h>
  59 #include "camcontrol.h"
  60
  61 typedef enum {
  62         CAM_CMD_NONE            = 0x00000000,
  63         CAM_CMD_DEVLIST         = 0x00000001,
  64         CAM_CMD_TUR             = 0x00000002,
  65         CAM_CMD_INQUIRY         = 0x00000003,
  66         CAM_CMD_STARTSTOP       = 0x00000004,
  67         CAM_CMD_RESCAN          = 0x00000005,
  68         CAM_CMD_READ_DEFECTS    = 0x00000006,
  69         CAM_CMD_MODE_PAGE       = 0x00000007,
  70         CAM_CMD_SCSI_CMD        = 0x00000008,
  71         CAM_CMD_DEVTREE         = 0x00000009,
  72         CAM_CMD_USAGE           = 0x0000000a,
  73         CAM_CMD_DEBUG           = 0x0000000b,
  74         CAM_CMD_RESET           = 0x0000000c,
  75         CAM_CMD_FORMAT          = 0x0000000d,
  76         CAM_CMD_TAG             = 0x0000000e,
  77         CAM_CMD_RATE            = 0x0000000f,
  78         CAM_CMD_DETACH          = 0x00000010,
  79         CAM_CMD_REPORTLUNS      = 0x00000011,
  80         CAM_CMD_READCAP         = 0x00000012,
  81         CAM_CMD_IDENTIFY        = 0x00000013,
  82         CAM_CMD_IDLE            = 0x00000014,
  83         CAM_CMD_STANDBY         = 0x00000015,
  84         CAM_CMD_SLEEP           = 0x00000016,
  85         CAM_CMD_SMP_CMD         = 0x00000017,
  86         CAM_CMD_SMP_RG          = 0x00000018,
  87         CAM_CMD_SMP_PC          = 0x00000019,
  88         CAM_CMD_SMP_PHYLIST     = 0x0000001a,
  89         CAM_CMD_SMP_MANINFO     = 0x0000001b
  90 } cam_cmdmask;
  91
  92 typedef enum {
  93         CAM_ARG_NONE            = 0x00000000,
  94         CAM_ARG_VERBOSE         = 0x00000001,
  95         CAM_ARG_DEVICE          = 0x00000002,
  96         CAM_ARG_BUS             = 0x00000004,
  97         CAM_ARG_TARGET          = 0x00000008,
  98         CAM_ARG_LUN             = 0x00000010,
  99         CAM_ARG_EJECT           = 0x00000020,
 100         CAM_ARG_UNIT            = 0x00000040,
 101         CAM_ARG_FORMAT_BLOCK    = 0x00000080,
 102         CAM_ARG_FORMAT_BFI      = 0x00000100,
 103         CAM_ARG_FORMAT_PHYS     = 0x00000200,
 104         CAM_ARG_PLIST           = 0x00000400,
 105         CAM_ARG_GLIST           = 0x00000800,
 106         CAM_ARG_GET_SERIAL      = 0x00001000,
 107         CAM_ARG_GET_STDINQ      = 0x00002000,
 108         CAM_ARG_GET_XFERRATE    = 0x00004000,
 109         CAM_ARG_INQ_MASK        = 0x00007000,
 110         CAM_ARG_MODE_EDIT       = 0x00008000,
 111         CAM_ARG_PAGE_CNTL       = 0x00010000,
 112         CAM_ARG_TIMEOUT         = 0x00020000,
 113         CAM_ARG_CMD_IN          = 0x00040000,
 114         CAM_ARG_CMD_OUT         = 0x00080000,
 115         CAM_ARG_DBD             = 0x00100000,
 116         CAM_ARG_ERR_RECOVER     = 0x00200000,
 117         CAM_ARG_RETRIES         = 0x00400000,
 118         CAM_ARG_START_UNIT      = 0x00800000,
 119         CAM_ARG_DEBUG_INFO      = 0x01000000,
 120         CAM_ARG_DEBUG_TRACE     = 0x02000000,
 121         CAM_ARG_DEBUG_SUBTRACE  = 0x04000000,
 122         CAM_ARG_DEBUG_CDB       = 0x08000000,
 123         CAM_ARG_DEBUG_XPT       = 0x10000000,
 124         CAM_ARG_DEBUG_PERIPH    = 0x20000000,
 125 } cam_argmask;
 126
 127 struct camcontrol_opts {
 128         const char      *optname;
 129         uint32_t        cmdnum;
 130         cam_argmask     argnum;
 131         const char      *subopt;
 132 };
 133
 134 #ifndef MINIMALISTIC
 135 static const char scsicmd_opts[] = "a:c:dfi:o:r";
 136 static const char readdefect_opts[] = "f:GP";
 137 static const char negotiate_opts[] = "acD:M:O:qR:T:UW:";
 138 static const char smprg_opts[] = "l";
 139 static const char smppc_opts[] = "a:A:d:lm:M:o:p:s:S:T:";
 140 static const char smpphylist_opts[] = "lq";
 141 #endif
 142
 143 struct camcontrol_opts option_table[] = {
 144 #ifndef MINIMALISTIC
 145         {"tur", CAM_CMD_TUR, CAM_ARG_NONE, NULL},
 146         {"inquiry", CAM_CMD_INQUIRY, CAM_ARG_NONE, "DSR"},
 147         {"identify", CAM_CMD_IDENTIFY, CAM_ARG_NONE, NULL},
 148         {"start", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT, NULL},
 149         {"stop", CAM_CMD_STARTSTOP, CAM_ARG_NONE, NULL},
 150         {"load", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT | CAM_ARG_EJECT, NULL},
 151         {"eject", CAM_CMD_STARTSTOP, CAM_ARG_EJECT, NULL},
 152         {"reportluns", CAM_CMD_REPORTLUNS, CAM_ARG_NONE, "clr:"},
 153         {"readcapacity", CAM_CMD_READCAP, CAM_ARG_NONE, "bhHNqs"},
 154 #endif /* MINIMALISTIC */
 155         {"rescan", CAM_CMD_RESCAN, CAM_ARG_NONE, NULL},
 156         {"reset", CAM_CMD_RESET, CAM_ARG_NONE, NULL},
 157 #ifndef MINIMALISTIC
 158         {"cmd", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts},
 159         {"command", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts},
 160         {"smpcmd", CAM_CMD_SMP_CMD, CAM_ARG_NONE, "r:R:"},
 161         {"smprg", CAM_CMD_SMP_RG, CAM_ARG_NONE, smprg_opts},
 162         {"smpreportgeneral", CAM_CMD_SMP_RG, CAM_ARG_NONE, smprg_opts},
 163         {"smppc", CAM_CMD_SMP_PC, CAM_ARG_NONE, smppc_opts},
 164         {"smpphycontrol", CAM_CMD_SMP_PC, CAM_ARG_NONE, smppc_opts},
 165         {"smpplist", CAM_CMD_SMP_PHYLIST, CAM_ARG_NONE, smpphylist_opts},
 166         {"smpphylist", CAM_CMD_SMP_PHYLIST, CAM_ARG_NONE, smpphylist_opts},
 167         {"smpmaninfo", CAM_CMD_SMP_MANINFO, CAM_ARG_NONE, "l"},
 168         {"defects", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts},
 169         {"defectlist", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts},
 170 #endif /* MINIMALISTIC */
 171         {"devlist", CAM_CMD_DEVTREE, CAM_ARG_NONE, NULL},
 172 #ifndef MINIMALISTIC
 173         {"periphlist", CAM_CMD_DEVLIST, CAM_ARG_NONE, NULL},
 174         {"modepage", CAM_CMD_MODE_PAGE, CAM_ARG_NONE, "bdelm:P:"},
 175         {"tags", CAM_CMD_TAG, CAM_ARG_NONE, "N:q"},
 176         {"negotiate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts},
 177         {"rate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts},
 178         {"debug", CAM_CMD_DEBUG, CAM_ARG_NONE, "IPTSXc"},
 179         {"format", CAM_CMD_FORMAT, CAM_ARG_NONE, "qrwy"},
 180         {"idle", CAM_CMD_IDLE, CAM_ARG_NONE, "t:"},
 181         {"standby", CAM_CMD_STANDBY, CAM_ARG_NONE, "t:"},
 182         {"sleep", CAM_CMD_SLEEP, CAM_ARG_NONE, ""},
 183 #endif /* MINIMALISTIC */
 184         {"help", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
 185         {"-?", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
 186         {"-h", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
 187         {NULL, 0, 0, NULL}
 188 };
 189
 190 typedef enum {
 191         CC_OR_NOT_FOUND,
 192         CC_OR_AMBIGUOUS,
 193         CC_OR_FOUND
 194 } camcontrol_optret;
 195
 196 struct cam_devitem {
 197         struct device_match_result dev_match;
 198         int num_periphs;
 199         struct periph_match_result *periph_matches;
 200         struct scsi_vpd_device_id *device_id;
 201         int device_id_len;
 202         STAILQ_ENTRY(cam_devitem) links;
 203 };
 204
 205 struct cam_devlist {
 206         STAILQ_HEAD(, cam_devitem) dev_queue;
 207         path_id_t path_id;
 208 };
 209
 210 cam_cmdmask cmdlist;
 211 cam_argmask arglist;
 212
 213 camcontrol_optret getoption(struct camcontrol_opts *table, char *arg,
 214                             uint32_t *cmdnum, cam_argmask *argnum,
 215                             const char **subopt);
 216 #ifndef MINIMALISTIC
 217 static int getdevlist(struct cam_device *device);
 218 #endif /* MINIMALISTIC */
 219 static int getdevtree(void);
 220 #ifndef MINIMALISTIC
 221 static int testunitready(struct cam_device *device, int retry_count,
 222                          int timeout, int quiet);
 223 static int scsistart(struct cam_device *device, int startstop, int loadeject,
 224                      int retry_count, int timeout);
 225 static int scsidoinquiry(struct cam_device *device, int argc, char **argv,
 226                          char *combinedopt, int retry_count, int timeout);
 227 static int scsiinquiry(struct cam_device *device, int retry_count, int timeout);
 228 static int scsiserial(struct cam_device *device, int retry_count, int timeout);
 229 static int camxferrate(struct cam_device *device);
 230 #endif /* MINIMALISTIC */
 231 static int parse_btl(char *tstr, int *bus, int *target, int *lun,
 232                      cam_argmask *arglst);
 233 static int dorescan_or_reset(int argc, char **argv, int rescan);
 234 static int rescan_or_reset_bus(int bus, int rescan);
 235 static int scanlun_or_reset_dev(int bus, int target, int lun, int scan);
 236 #ifndef MINIMALISTIC
 237 static int readdefects(struct cam_device *device, int argc, char **argv,
 238                        char *combinedopt, int retry_count, int timeout);
 239 static void modepage(struct cam_device *device, int argc, char **argv,
 240                      char *combinedopt, int retry_count, int timeout);
 241 static int scsicmd(struct cam_device *device, int argc, char **argv,
 242                    char *combinedopt, int retry_count, int timeout);
 243 static int smpcmd(struct cam_device *device, int argc, char **argv,
 244                   char *combinedopt, int retry_count, int timeout);
 245 static int smpreportgeneral(struct cam_device *device, int argc, char **argv,
 246                             char *combinedopt, int retry_count, int timeout);
 247 static int smpphycontrol(struct cam_device *device, int argc, char **argv,
 248                          char *combinedopt, int retry_count, int timeout);
 249 static int smpmaninfo(struct cam_device *device, int argc, char **argv,
 250                       char *combinedopt, int retry_count, int timeout);
 251 static int getdevid(struct cam_devitem *item);
 252 static int buildbusdevlist(struct cam_devlist *devlist);
 253 static void freebusdevlist(struct cam_devlist *devlist);
 254 static struct cam_devitem *findsasdevice(struct cam_devlist *devlist,
 255                                          uint64_t sasaddr);
 256 static int smpphylist(struct cam_device *device, int argc, char **argv,
 257                       char *combinedopt, int retry_count, int timeout);
 258 static int tagcontrol(struct cam_device *device, int argc, char **argv,
 259                       char *combinedopt);
 260 static void cts_print(struct cam_device *device,
 261                       struct ccb_trans_settings *cts);
 262 static void cpi_print(struct ccb_pathinq *cpi);
 263 static int get_cpi(struct cam_device *device, struct ccb_pathinq *cpi);
 264 static int get_cgd(struct cam_device *device, struct ccb_getdev *cgd);
 265 static int get_print_cts(struct cam_device *device, int user_settings,
 266                          int quiet, struct ccb_trans_settings *cts);
 267 static int ratecontrol(struct cam_device *device, int retry_count,
 268                        int timeout, int argc, char **argv, char *combinedopt);
 269 static int scsiformat(struct cam_device *device, int argc, char **argv,
 270                       char *combinedopt, int retry_count, int timeout);
 271 static int scsireportluns(struct cam_device *device, int argc, char **argv,
 272                           char *combinedopt, int retry_count, int timeout);
 273 static int scsireadcapacity(struct cam_device *device, int argc, char **argv,
 274                             char *combinedopt, int retry_count, int timeout);
 275 static int atapm(struct cam_device *device, int argc, char **argv,
 276                             char *combinedopt, int retry_count, int timeout);
 277 #endif /* MINIMALISTIC */
 278 #ifndef min
 279 #define min(a,b) (((a)<(b))?(a):(b))
 280 #endif
 281 #ifndef max
 282 #define max(a,b) (((a)>(b))?(a):(b))
 283 #endif
 284
 285 camcontrol_optret
 286 getoption(struct camcontrol_opts *table, char *arg, uint32_t *cmdnum,
 287           cam_argmask *argnum, const char **subopt)
 288 {
 289         struct camcontrol_opts *opts;
 290         int num_matches = 0;
 291
 292         for (opts = table; (opts != NULL) && (opts->optname != NULL);
 293              opts++) {
 294                 if (strncmp(opts->optname, arg, strlen(arg)) == 0) {
 295                         *cmdnum = opts->cmdnum;
 296                         *argnum = opts->argnum;
 297                         *subopt = opts->subopt;
 298                         if (++num_matches > 1)
 299                                 return(CC_OR_AMBIGUOUS);
 300                 }
 301         }
 302
 303         if (num_matches > 0)
 304                 return(CC_OR_FOUND);
 305         else
 306                 return(CC_OR_NOT_FOUND);
 307 }
 308
 309 #ifndef MINIMALISTIC
 310 static int
 311 getdevlist(struct cam_device *device)
 312 {
 313         union ccb *ccb;
 314         char status[32];
 315         int error = 0;
 316
 317         ccb = cam_getccb(device);
 318
 319         ccb->ccb_h.func_code = XPT_GDEVLIST;
 320         ccb->ccb_h.flags = CAM_DIR_NONE;
 321         ccb->ccb_h.retry_count = 1;
 322         ccb->cgdl.index = 0;
 323         ccb->cgdl.status = CAM_GDEVLIST_MORE_DEVS;
 324         while (ccb->cgdl.status == CAM_GDEVLIST_MORE_DEVS) {
 325                 if (cam_send_ccb(device, ccb) < 0) {
 326                         perror("error getting device list");
 327                         cam_freeccb(ccb);
 328                         return(1);
 329                 }
 330
 331                 status[0] = '\0';
 332
 333                 switch (ccb->cgdl.status) {
 334                         case CAM_GDEVLIST_MORE_DEVS:
 335                                 strcpy(status, "MORE");
 336                                 break;
 337                         case CAM_GDEVLIST_LAST_DEVICE:
 338                                 strcpy(status, "LAST");
 339                                 break;
 340                         case CAM_GDEVLIST_LIST_CHANGED:
 341                                 strcpy(status, "CHANGED");
 342                                 break;
 343                         case CAM_GDEVLIST_ERROR:
 344                                 strcpy(status, "ERROR");
 345                                 error = 1;
 346                                 break;
 347                 }
 348
 349                 fprintf(stdout, "%s%d:  generation: %d index: %d status: %s\n",
 350                         ccb->cgdl.periph_name,
 351                         ccb->cgdl.unit_number,
 352                         ccb->cgdl.generation,
 353                         ccb->cgdl.index,
 354                         status);
 355
 356                 /*
 357                  * If the list has changed, we need to start over from the
 358                  * beginning.
 359                  */
 360                 if (ccb->cgdl.status == CAM_GDEVLIST_LIST_CHANGED)
 361                         ccb->cgdl.index = 0;
 362         }
 363
 364         cam_freeccb(ccb);
 365
 366         return(error);
 367 }
 368 #endif /* MINIMALISTIC */
 369
 370 static int
 371 getdevtree(void)
 372 {
 373         union ccb ccb;
 374         int bufsize, fd;
 375         unsigned int i;
 376         int need_close = 0;
 377         int error = 0;
 378         int skip_device = 0;
 379
 380         if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
 381                 warn("couldn't open %s", XPT_DEVICE);
 382                 return(1);
 383         }
 384
 385         bzero(&ccb, sizeof(union ccb));
 386
 387         ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
 388         ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
 389         ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
 390
 391         ccb.ccb_h.func_code = XPT_DEV_MATCH;
 392         bufsize = sizeof(struct dev_match_result) * 100;
 393         ccb.cdm.match_buf_len = bufsize;
 394         ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
 395         if (ccb.cdm.matches == NULL) {
 396                 warnx("can't malloc memory for matches");
 397                 close(fd);
 398                 return(1);
 399         }
 400         ccb.cdm.num_matches = 0;
 401
 402         /*
 403          * We fetch all nodes, since we display most of them in the default
 404          * case, and all in the verbose case.
 405          */
 406         ccb.cdm.num_patterns = 0;
 407         ccb.cdm.pattern_buf_len = 0;
 408
 409         /*
 410          * We do the ioctl multiple times if necessary, in case there are
 411          * more than 100 nodes in the EDT.
 412          */
 413         do {
 414                 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
 415                         warn("error sending CAMIOCOMMAND ioctl");
 416                         error = 1;
 417                         break;
 418                 }
 419
 420                 if ((ccb.ccb_h.status != CAM_REQ_CMP)
 421                  || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
 422                     && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
 423                         warnx("got CAM error %#x, CDM error %d\n",
 424                               ccb.ccb_h.status, ccb.cdm.status);
 425                         error = 1;
 426                         break;
 427                 }
 428
 429                 for (i = 0; i < ccb.cdm.num_matches; i++) {
 430                         switch (ccb.cdm.matches[i].type) {
 431                         case DEV_MATCH_BUS: {
 432                                 struct bus_match_result *bus_result;
 433
 434                                 /*
 435                                  * Only print the bus information if the
 436                                  * user turns on the verbose flag.
 437                                  */
 438                                 if ((arglist & CAM_ARG_VERBOSE) == 0)
 439                                         break;
 440
 441                                 bus_result =
 442                                         &ccb.cdm.matches[i].result.bus_result;
 443
 444                                 if (need_close) {
 445                                         fprintf(stdout, ")\n");
 446                                         need_close = 0;
 447                                 }
 448
 449                                 fprintf(stdout, "scbus%d on %s%d bus %d:\n",
 450                                         bus_result->path_id,
 451                                         bus_result->dev_name,
 452                                         bus_result->unit_number,
 453                                         bus_result->bus_id);
 454                                 break;
 455                         }
 456                         case DEV_MATCH_DEVICE: {
 457                                 struct device_match_result *dev_result;
 458                                 char vendor[16], product[48], revision[16];
 459                                 char tmpstr[256];
 460
 461                                 dev_result =
 462                                      &ccb.cdm.matches[i].result.device_result;
 463
 464                                 if ((dev_result->flags
 465                                      & DEV_RESULT_UNCONFIGURED)
 466                                  && ((arglist & CAM_ARG_VERBOSE) == 0)) {
 467                                         skip_device = 1;
 468                                         break;
 469                                 } else
 470                                         skip_device = 0;
 471
 472                                 if (dev_result->protocol == PROTO_SCSI) {
 473                                     cam_strvis(vendor, dev_result->inq_data.vendor,
 474                                            sizeof(dev_result->inq_data.vendor),
 475                                            sizeof(vendor));
 476                                     cam_strvis(product,
 477                                            dev_result->inq_data.product,
 478                                            sizeof(dev_result->inq_data.product),
 479                                            sizeof(product));
 480                                     cam_strvis(revision,
 481                                            dev_result->inq_data.revision,
 482                                           sizeof(dev_result->inq_data.revision),
 483                                            sizeof(revision));
 484                                     sprintf(tmpstr, "<%s %s %s>", vendor, product,
 485                                         revision);
 486                                 } else if (dev_result->protocol == PROTO_ATA ||
 487                                     dev_result->protocol == PROTO_SATAPM) {
 488                                     cam_strvis(product,
 489                                            dev_result->ident_data.model,
 490                                            sizeof(dev_result->ident_data.model),
 491                                            sizeof(product));
 492                                     cam_strvis(revision,
 493                                            dev_result->ident_data.revision,
 494                                           sizeof(dev_result->ident_data.revision),
 495                                            sizeof(revision));
 496                                     sprintf(tmpstr, "<%s %s>", product,
 497                                         revision);
 498                                 } else {
 499                                     sprintf(tmpstr, "<>");
 500                                 }
 501                                 if (need_close) {
 502                                         fprintf(stdout, ")\n");
 503                                         need_close = 0;
 504                                 }
 505
 506                                 fprintf(stdout, "%-33s  at scbus%d "
 507                                         "target %d lun %d (",
 508                                         tmpstr,
 509                                         dev_result->path_id,
 510                                         dev_result->target_id,
 511                                         dev_result->target_lun);
 512
 513                                 need_close = 1;
 514
 515                                 break;
 516                         }
 517                         case DEV_MATCH_PERIPH: {
 518                                 struct periph_match_result *periph_result;
 519
 520                                 periph_result =
 521                                       &ccb.cdm.matches[i].result.periph_result;
 522
 523                                 if (skip_device != 0)
 524                                         break;
 525
 526                                 if (need_close > 1)
 527                                         fprintf(stdout, ",");
 528
 529                                 fprintf(stdout, "%s%d",
 530                                         periph_result->periph_name,
 531                                         periph_result->unit_number);
 532
 533                                 need_close++;
 534                                 break;
 535                         }
 536                         default:
 537                                 fprintf(stdout, "unknown match type\n");
 538                                 break;
 539                         }
 540                 }
 541
 542         } while ((ccb.ccb_h.status == CAM_REQ_CMP)
 543                 && (ccb.cdm.status == CAM_DEV_MATCH_MORE));
 544
 545         if (need_close)
 546                 fprintf(stdout, ")\n");
 547
 548         close(fd);
 549
 550         return(error);
 551 }
 552
 553 #ifndef MINIMALISTIC
 554 static int
 555 testunitready(struct cam_device *device, int retry_count, int timeout,
 556               int quiet)
 557 {
 558         int error = 0;
 559         union ccb *ccb;
 560
 561         ccb = cam_getccb(device);
 562
 563         scsi_test_unit_ready(&ccb->csio,
 564                              /* retries */ retry_count,
 565                              /* cbfcnp */ NULL,
 566                              /* tag_action */ MSG_SIMPLE_Q_TAG,
 567                              /* sense_len */ SSD_FULL_SIZE,
 568                              /* timeout */ timeout ? timeout : 5000);
 569
 570         /* Disable freezing the device queue */
 571         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
 572
 573         if (arglist & CAM_ARG_ERR_RECOVER)
 574                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
 575
 576         if (cam_send_ccb(device, ccb) < 0) {
 577                 if (quiet == 0)
 578                         perror("error sending test unit ready");
 579
 580                 if (arglist & CAM_ARG_VERBOSE) {
 581                         cam_error_print(device, ccb, CAM_ESF_ALL,
 582                                         CAM_EPF_ALL, stderr);
 583                 }
 584
 585                 cam_freeccb(ccb);
 586                 return(1);
 587         }
 588
 589         if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
 590                 if (quiet == 0)
 591                         fprintf(stdout, "Unit is ready\n");
 592         } else {
 593                 if (quiet == 0)
 594                         fprintf(stdout, "Unit is not ready\n");
 595                 error = 1;
 596
 597                 if (arglist & CAM_ARG_VERBOSE) {
 598                         cam_error_print(device, ccb, CAM_ESF_ALL,
 599                                         CAM_EPF_ALL, stderr);
 600                 }
 601         }
 602
 603         cam_freeccb(ccb);
 604
 605         return(error);
 606 }
 607
 608 static int
 609 scsistart(struct cam_device *device, int startstop, int loadeject,
 610           int retry_count, int timeout)
 611 {
 612         union ccb *ccb;
 613         int error = 0;
 614
 615         ccb = cam_getccb(device);
 616
 617         /*
 618          * If we're stopping, send an ordered tag so the drive in question
 619          * will finish any previously queued writes before stopping.  If
 620          * the device isn't capable of tagged queueing, or if tagged
 621          * queueing is turned off, the tag action is a no-op.
 622          */
 623         scsi_start_stop(&ccb->csio,
 624                         /* retries */ retry_count,
 625                         /* cbfcnp */ NULL,
 626                         /* tag_action */ startstop ? MSG_SIMPLE_Q_TAG :
 627                                                      MSG_ORDERED_Q_TAG,
 628                         /* start/stop */ startstop,
 629                         /* load_eject */ loadeject,
 630                         /* immediate */ 0,
 631                         /* sense_len */ SSD_FULL_SIZE,
 632                         /* timeout */ timeout ? timeout : 120000);
 633
 634         /* Disable freezing the device queue */
 635         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
 636
 637         if (arglist & CAM_ARG_ERR_RECOVER)
 638                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
 639
 640         if (cam_send_ccb(device, ccb) < 0) {
 641                 perror("error sending start unit");
 642
 643                 if (arglist & CAM_ARG_VERBOSE) {
 644                         cam_error_print(device, ccb, CAM_ESF_ALL,
 645                                         CAM_EPF_ALL, stderr);
 646                 }
 647
 648                 cam_freeccb(ccb);
 649                 return(1);
 650         }
 651
 652         if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
 653                 if (startstop) {
 654                         fprintf(stdout, "Unit started successfully");
 655                         if (loadeject)
 656                                 fprintf(stdout,", Media loaded\n");
 657                         else
 658                                 fprintf(stdout,"\n");
 659                 } else {
 660                         fprintf(stdout, "Unit stopped successfully");
 661                         if (loadeject)
 662                                 fprintf(stdout, ", Media ejected\n");
 663                         else
 664                                 fprintf(stdout, "\n");
 665                 }
 666         else {
 667                 error = 1;
 668                 if (startstop)
 669                         fprintf(stdout,
 670                                 "Error received from start unit command\n");
 671                 else
 672                         fprintf(stdout,
 673                                 "Error received from stop unit command\n");
 674
 675                 if (arglist & CAM_ARG_VERBOSE) {
 676                         cam_error_print(device, ccb, CAM_ESF_ALL,
 677                                         CAM_EPF_ALL, stderr);
 678                 }
 679         }
 680
 681         cam_freeccb(ccb);
 682
 683         return(error);
 684 }
 685
 686 static int
 687 scsidoinquiry(struct cam_device *device, int argc, char **argv,
 688               char *combinedopt, int retry_count, int timeout)
 689 {
 690         int c;
 691         int error = 0;
 692
 693         while ((c = getopt(argc, argv, combinedopt)) != -1) {
 694                 switch(c) {
 695                 case 'D':
 696                         arglist |= CAM_ARG_GET_STDINQ;
 697                         break;
 698                 case 'R':
 699                         arglist |= CAM_ARG_GET_XFERRATE;
 700                         break;
 701                 case 'S':
 702                         arglist |= CAM_ARG_GET_SERIAL;
 703                         break;
 704                 default:
 705                         break;
 706                 }
 707         }
 708
 709         /*
 710          * If the user didn't specify any inquiry options, he wants all of
 711          * them.
 712          */
 713         if ((arglist & CAM_ARG_INQ_MASK) == 0)
 714                 arglist |= CAM_ARG_INQ_MASK;
 715
 716         if (arglist & CAM_ARG_GET_STDINQ)
 717                 error = scsiinquiry(device, retry_count, timeout);
 718
 719         if (error != 0)
 720                 return(error);
 721
 722         if (arglist & CAM_ARG_GET_SERIAL)
 723                 scsiserial(device, retry_count, timeout);
 724
 725         if (error != 0)
 726                 return(error);
 727
 728         if (arglist & CAM_ARG_GET_XFERRATE)
 729                 error = camxferrate(device);
 730
 731         return(error);
 732 }
 733
 734 static int
 735 scsiinquiry(struct cam_device *device, int retry_count, int timeout)
 736 {
 737         union ccb *ccb;
 738         struct scsi_inquiry_data *inq_buf;
 739         int error = 0;
 740
 741         ccb = cam_getccb(device);
 742
 743         if (ccb == NULL) {
 744                 warnx("couldn't allocate CCB");
 745                 return(1);
 746         }
 747
 748         /* cam_getccb cleans up the header, caller has to zero the payload */
 749         bzero(&(&ccb->ccb_h)[1],
 750               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
 751
 752         inq_buf = (struct scsi_inquiry_data *)malloc(
 753                 sizeof(struct scsi_inquiry_data));
 754
 755         if (inq_buf == NULL) {
 756                 cam_freeccb(ccb);
 757                 warnx("can't malloc memory for inquiry\n");
 758                 return(1);
 759         }
 760         bzero(inq_buf, sizeof(*inq_buf));
 761
 762         /*
 763          * Note that although the size of the inquiry buffer is the full
 764          * 256 bytes specified in the SCSI spec, we only tell the device
 765          * that we have allocated SHORT_INQUIRY_LENGTH bytes.  There are
 766          * two reasons for this:
 767          *
 768          *  - The SCSI spec says that when a length field is only 1 byte,
 769          *    a value of 0 will be interpreted as 256.  Therefore
 770          *    scsi_inquiry() will convert an inq_len (which is passed in as
 771          *    a u_int32_t, but the field in the CDB is only 1 byte) of 256
 772          *    to 0.  Evidently, very few devices meet the spec in that
 773          *    regard.  Some devices, like many Seagate disks, take the 0 as
 774          *    0, and don't return any data.  One Pioneer DVD-R drive
 775          *    returns more data than the command asked for.
 776          *
 777          *    So, since there are numerous devices that just don't work
 778          *    right with the full inquiry size, we don't send the full size.
 779          *
 780          *  - The second reason not to use the full inquiry data length is
 781          *    that we don't need it here.  The only reason we issue a
 782          *    standard inquiry is to get the vendor name, device name,
 783          *    and revision so scsi_print_inquiry() can print them.
 784          *
 785          * If, at some point in the future, more inquiry data is needed for
 786          * some reason, this code should use a procedure similar to the
 787          * probe code.  i.e., issue a short inquiry, and determine from
 788          * the additional length passed back from the device how much
 789          * inquiry data the device supports.  Once the amount the device
 790          * supports is determined, issue an inquiry for that amount and no
 791          * more.
 792          *
 793          * KDM, 2/18/2000
 794          */
 795         scsi_inquiry(&ccb->csio,
 796                      /* retries */ retry_count,
 797                      /* cbfcnp */ NULL,
 798                      /* tag_action */ MSG_SIMPLE_Q_TAG,
 799                      /* inq_buf */ (u_int8_t *)inq_buf,
 800                      /* inq_len */ SHORT_INQUIRY_LENGTH,
 801                      /* evpd */ 0,
 802                      /* page_code */ 0,
 803                      /* sense_len */ SSD_FULL_SIZE,
 804                      /* timeout */ timeout ? timeout : 5000);
 805
 806         /* Disable freezing the device queue */
 807         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
 808
 809         if (arglist & CAM_ARG_ERR_RECOVER)
 810                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
 811
 812         if (cam_send_ccb(device, ccb) < 0) {
 813                 perror("error sending SCSI inquiry");
 814
 815                 if (arglist & CAM_ARG_VERBOSE) {
 816                         cam_error_print(device, ccb, CAM_ESF_ALL,
 817                                         CAM_EPF_ALL, stderr);
 818                 }
 819
 820                 cam_freeccb(ccb);
 821                 return(1);
 822         }
 823
 824         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 825                 error = 1;
 826
 827                 if (arglist & CAM_ARG_VERBOSE) {
 828                         cam_error_print(device, ccb, CAM_ESF_ALL,
 829                                         CAM_EPF_ALL, stderr);
 830                 }
 831         }
 832
 833         cam_freeccb(ccb);
 834
 835         if (error != 0) {
 836                 free(inq_buf);
 837                 return(error);
 838         }
 839
 840         fprintf(stdout, "%s%d: ", device->device_name,
 841                 device->dev_unit_num);
 842         scsi_print_inquiry(inq_buf);
 843
 844         free(inq_buf);
 845
 846         return(0);
 847 }
 848
 849 static int
 850 scsiserial(struct cam_device *device, int retry_count, int timeout)
 851 {
 852         union ccb *ccb;
 853         struct scsi_vpd_unit_serial_number *serial_buf;
 854         char serial_num[SVPD_SERIAL_NUM_SIZE + 1];
 855         int error = 0;
 856
 857         ccb = cam_getccb(device);
 858
 859         if (ccb == NULL) {
 860                 warnx("couldn't allocate CCB");
 861                 return(1);
 862         }
 863
 864         /* cam_getccb cleans up the header, caller has to zero the payload */
 865         bzero(&(&ccb->ccb_h)[1],
 866               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
 867
 868         serial_buf = (struct scsi_vpd_unit_serial_number *)
 869                 malloc(sizeof(*serial_buf));
 870
 871         if (serial_buf == NULL) {
 872                 cam_freeccb(ccb);
 873                 warnx("can't malloc memory for serial number");
 874                 return(1);
 875         }
 876
 877         scsi_inquiry(&ccb->csio,
 878                      /*retries*/ retry_count,
 879                      /*cbfcnp*/ NULL,
 880                      /* tag_action */ MSG_SIMPLE_Q_TAG,
 881                      /* inq_buf */ (u_int8_t *)serial_buf,
 882                      /* inq_len */ sizeof(*serial_buf),
 883                      /* evpd */ 1,
 884                      /* page_code */ SVPD_UNIT_SERIAL_NUMBER,
 885                      /* sense_len */ SSD_FULL_SIZE,
 886                      /* timeout */ timeout ? timeout : 5000);
 887
 888         /* Disable freezing the device queue */
 889         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
 890
 891         if (arglist & CAM_ARG_ERR_RECOVER)
 892                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
 893
 894         if (cam_send_ccb(device, ccb) < 0) {
 895                 warn("error getting serial number");
 896
 897                 if (arglist & CAM_ARG_VERBOSE) {
 898                         cam_error_print(device, ccb, CAM_ESF_ALL,
 899                                         CAM_EPF_ALL, stderr);
 900                 }
 901
 902                 cam_freeccb(ccb);
 903                 free(serial_buf);
 904                 return(1);
 905         }
 906
 907         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 908                 error = 1;
 909
 910                 if (arglist & CAM_ARG_VERBOSE) {
 911                         cam_error_print(device, ccb, CAM_ESF_ALL,
 912                                         CAM_EPF_ALL, stderr);
 913                 }
 914         }
 915
 916         cam_freeccb(ccb);
 917
 918         if (error != 0) {
 919                 free(serial_buf);
 920                 return(error);
 921         }
 922
 923         bcopy(serial_buf->serial_num, serial_num, serial_buf->length);
 924         serial_num[serial_buf->length] = '\0';
 925
 926         if ((arglist & CAM_ARG_GET_STDINQ)
 927          || (arglist & CAM_ARG_GET_XFERRATE))
 928                 fprintf(stdout, "%s%d: Serial Number ",
 929                         device->device_name, device->dev_unit_num);
 930
 931         fprintf(stdout, "%.60s\n", serial_num);
 932
 933         free(serial_buf);
 934
 935         return(0);
 936 }
 937
 938 static int
 939 camxferrate(struct cam_device *device)
 940 {
 941         struct ccb_pathinq cpi;
 942         u_int32_t freq = 0;
 943         u_int32_t speed = 0;
 944         union ccb *ccb;
 945         u_int mb;
 946         int retval = 0;
 947
 948         if ((retval = get_cpi(device, &cpi)) != 0)
 949                 return (1);
 950
 951         ccb = cam_getccb(device);
 952
 953         if (ccb == NULL) {
 954                 warnx("couldn't allocate CCB");
 955                 return(1);
 956         }
 957
 958         bzero(&(&ccb->ccb_h)[1],
 959               sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr));
 960
 961         ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 962         ccb->cts.type = CTS_TYPE_CURRENT_SETTINGS;
 963
 964         if (((retval = cam_send_ccb(device, ccb)) < 0)
 965          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
 966                 const char error_string[] = "error getting transfer settings";
 967
 968                 if (retval < 0)
 969                         warn(error_string);
 970                 else
 971                         warnx(error_string);
 972
 973                 if (arglist & CAM_ARG_VERBOSE)
 974                         cam_error_print(device, ccb, CAM_ESF_ALL,
 975                                         CAM_EPF_ALL, stderr);
 976
 977                 retval = 1;
 978
 979                 goto xferrate_bailout;
 980
 981         }
 982
 983         speed = cpi.base_transfer_speed;
 984         freq = 0;
 985         if (ccb->cts.transport == XPORT_SPI) {
 986                 struct ccb_trans_settings_spi *spi =
 987                     &ccb->cts.xport_specific.spi;
 988
 989                 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) {
 990                         freq = scsi_calc_syncsrate(spi->sync_period);
 991                         speed = freq;
 992                 }
 993                 if ((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0) {
 994                         speed *= (0x01 << spi->bus_width);
 995                 }
 996         } else if (ccb->cts.transport == XPORT_FC) {
 997                 struct ccb_trans_settings_fc *fc =
 998                     &ccb->cts.xport_specific.fc;
 999
1000                 if (fc->valid & CTS_FC_VALID_SPEED)
1001                         speed = fc->bitrate;
1002         } else if (ccb->cts.transport == XPORT_SAS) {
1003                 struct ccb_trans_settings_sas *sas =
1004                     &ccb->cts.xport_specific.sas;
1005
1006                 if (sas->valid & CTS_SAS_VALID_SPEED)
1007                         speed = sas->bitrate;
1008         } else if (ccb->cts.transport == XPORT_ATA) {
1009                 struct ccb_trans_settings_ata *ata =
1010                     &ccb->cts.xport_specific.ata;
1011
1012                 if (ata->valid & CTS_ATA_VALID_MODE)
1013                         speed = ata_mode2speed(ata->mode);
1014         } else if (ccb->cts.transport == XPORT_SATA) {
1015                 struct  ccb_trans_settings_sata *sata =
1016                     &ccb->cts.xport_specific.sata;
1017
1018                 if (sata->valid & CTS_SATA_VALID_REVISION)
1019                         speed = ata_revision2speed(sata->revision);
1020         }
1021
1022         mb = speed / 1000;
1023         if (mb > 0) {
1024                 fprintf(stdout, "%s%d: %d.%03dMB/s transfers",
1025                         device->device_name, device->dev_unit_num,
1026                         mb, speed % 1000);
1027         } else {
1028                 fprintf(stdout, "%s%d: %dKB/s transfers",
1029                         device->device_name, device->dev_unit_num,
1030                         speed);
1031         }
1032
1033         if (ccb->cts.transport == XPORT_SPI) {
1034                 struct ccb_trans_settings_spi *spi =
1035                     &ccb->cts.xport_specific.spi;
1036
1037                 if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0)
1038                  && (spi->sync_offset != 0))
1039                         fprintf(stdout, " (%d.%03dMHz, offset %d", freq / 1000,
1040                                 freq % 1000, spi->sync_offset);
1041
1042                 if (((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0)
1043                  && (spi->bus_width > 0)) {
1044                         if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0)
1045                          && (spi->sync_offset != 0)) {
1046                                 fprintf(stdout, ", ");
1047                         } else {
1048                                 fprintf(stdout, " (");
1049                         }
1050                         fprintf(stdout, "%dbit)", 8 * (0x01 << spi->bus_width));
1051                 } else if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0)
1052                  && (spi->sync_offset != 0)) {
1053                         fprintf(stdout, ")");
1054                 }
1055         } else if (ccb->cts.transport == XPORT_ATA) {
1056                 struct ccb_trans_settings_ata *ata =
1057                     &ccb->cts.xport_specific.ata;
1058
1059                 printf(" (");
1060                 if (ata->valid & CTS_ATA_VALID_MODE)
1061                         printf("%s, ", ata_mode2string(ata->mode));
1062                 if ((ata->valid & CTS_ATA_VALID_ATAPI) && ata->atapi != 0)
1063                         printf("ATAPI %dbytes, ", ata->atapi);
1064                 if (ata->valid & CTS_ATA_VALID_BYTECOUNT)
1065                         printf("PIO %dbytes", ata->bytecount);
1066                 printf(")");
1067         } else if (ccb->cts.transport == XPORT_SATA) {
1068                 struct ccb_trans_settings_sata *sata =
1069                     &ccb->cts.xport_specific.sata;
1070
1071                 printf(" (");
1072                 if (sata->valid & CTS_SATA_VALID_REVISION)
1073                         printf("SATA %d.x, ", sata->revision);
1074                 else
1075                         printf("SATA, ");
1076                 if (sata->valid & CTS_SATA_VALID_MODE)
1077                         printf("%s, ", ata_mode2string(sata->mode));
1078                 if ((sata->valid & CTS_SATA_VALID_ATAPI) && sata->atapi != 0)
1079                         printf("ATAPI %dbytes, ", sata->atapi);
1080                 if (sata->valid & CTS_SATA_VALID_BYTECOUNT)
1081                         printf("PIO %dbytes", sata->bytecount);
1082                 printf(")");
1083         }
1084
1085         if (ccb->cts.protocol == PROTO_SCSI) {
1086                 struct ccb_trans_settings_scsi *scsi =
1087                     &ccb->cts.proto_specific.scsi;
1088                 if (scsi->valid & CTS_SCSI_VALID_TQ) {
1089                         if (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) {
1090                                 fprintf(stdout, ", Command Queueing Enabled");
1091                         }
1092                 }
1093         }
1094
1095         fprintf(stdout, "\n");
1096
1097 xferrate_bailout:
1098
1099         cam_freeccb(ccb);
1100
1101         return(retval);
1102 }
1103
1104 static void
1105 atacapprint(struct ata_params *parm)
1106 {
1107         u_int32_t lbasize = (u_int32_t)parm->lba_size_1 |
1108                                 ((u_int32_t)parm->lba_size_2 << 16);
1109
1110         u_int64_t lbasize48 = ((u_int64_t)parm->lba_size48_1) |
1111                                 ((u_int64_t)parm->lba_size48_2 << 16) |
1112                                 ((u_int64_t)parm->lba_size48_3 << 32) |
1113                                 ((u_int64_t)parm->lba_size48_4 << 48);
1114
1115         printf("\n");
1116         printf("protocol              ");
1117         printf("ATA/ATAPI-%d", ata_version(parm->version_major));
1118         if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
1119                 if (parm->satacapabilities & ATA_SATA_GEN3)
1120                         printf(" SATA 3.x\n");
1121                 else if (parm->satacapabilities & ATA_SATA_GEN2)
1122                         printf(" SATA 2.x\n");
1123                 else if (parm->satacapabilities & ATA_SATA_GEN1)
1124                         printf(" SATA 1.x\n");
1125                 else
1126                         printf(" SATA\n");
1127         }
1128         else
1129                 printf("\n");
1130         printf("device model          %.40s\n", parm->model);
1131         printf("firmware revision     %.8s\n", parm->revision);
1132         printf("serial number         %.20s\n", parm->serial);
1133         if (parm->enabled.extension & ATA_SUPPORT_64BITWWN) {
1134                 printf("WWN                   %04x%04x%04x%04x\n",
1135                     parm->wwn[0], parm->wwn[1], parm->wwn[2], parm->wwn[3]);
1136         }
1137         if (parm->enabled.extension & ATA_SUPPORT_MEDIASN) {
1138                 printf("media serial number   %.30s\n",
1139                     parm->media_serial);
1140         }
1141
1142         printf("cylinders             %d\n", parm->cylinders);
1143         printf("heads                 %d\n", parm->heads);
1144         printf("sectors/track         %d\n", parm->sectors);
1145         printf("sector size           logical %u, physical %lu, offset %lu\n",
1146             ata_logical_sector_size(parm),
1147             (unsigned long)ata_physical_sector_size(parm),
1148             (unsigned long)ata_logical_sector_offset(parm));
1149
1150         if (parm->config == ATA_PROTO_CFA ||
1151             (parm->support.command2 & ATA_SUPPORT_CFA))
1152                 printf("CFA supported\n");
1153
1154         printf("LBA%ssupported         ",
1155                 parm->capabilities1 & ATA_SUPPORT_LBA ? " " : " not ");
1156         if (lbasize)
1157                 printf("%d sectors\n", lbasize);
1158         else
1159                 printf("\n");
1160
1161         printf("LBA48%ssupported       ",
1162                 parm->support.command2 & ATA_SUPPORT_ADDRESS48 ? " " : " not ");
1163         if (lbasize48)
1164                 printf("%ju sectors\n", (uintmax_t)lbasize48);
1165         else
1166                 printf("\n");
1167
1168         printf("PIO supported         PIO");
1169         switch (ata_max_pmode(parm)) {
1170         case ATA_PIO4:
1171                 printf("4");
1172                 break;
1173         case ATA_PIO3:
1174                 printf("3");
1175                 break;
1176         case ATA_PIO2:
1177                 printf("2");
1178                 break;
1179         case ATA_PIO1:
1180                 printf("1");
1181                 break;
1182         default:
1183                 printf("0");
1184         }
1185         if ((parm->capabilities1 & ATA_SUPPORT_IORDY) == 0)
1186                 printf(" w/o IORDY");
1187         printf("\n");
1188
1189         printf("DMA%ssupported         ",
1190                 parm->capabilities1 & ATA_SUPPORT_DMA ? " " : " not ");
1191         if (parm->capabilities1 & ATA_SUPPORT_DMA) {
1192                 if (parm->mwdmamodes & 0xff) {
1193                         printf("WDMA");
1194                         if (parm->mwdmamodes & 0x04)
1195                                 printf("2");
1196                         else if (parm->mwdmamodes & 0x02)
1197                                 printf("1");
1198                         else if (parm->mwdmamodes & 0x01)
1199                                 printf("0");
1200                         printf(" ");
1201                 }
1202                 if ((parm->atavalid & ATA_FLAG_88) &&
1203                     (parm->udmamodes & 0xff)) {
1204                         printf("UDMA");
1205                         if (parm->udmamodes & 0x40)
1206                                 printf("6");
1207                         else if (parm->udmamodes & 0x20)
1208                                 printf("5");
1209                         else if (parm->udmamodes & 0x10)
1210                                 printf("4");
1211                         else if (parm->udmamodes & 0x08)
1212                                 printf("3");
1213                         else if (parm->udmamodes & 0x04)
1214                                 printf("2");
1215                         else if (parm->udmamodes & 0x02)
1216                                 printf("1");
1217                         else if (parm->udmamodes & 0x01)
1218                                 printf("0");
1219                         printf(" ");
1220                 }
1221         }
1222         printf("\n");
1223
1224         if (parm->media_rotation_rate == 1) {
1225                 printf("media RPM             non-rotating\n");
1226         } else if (parm->media_rotation_rate >= 0x0401 &&
1227             parm->media_rotation_rate <= 0xFFFE) {
1228                 printf("media RPM             %d\n",
1229                         parm->media_rotation_rate);
1230         }
1231
1232         printf("\nFeature                      "
1233                 "Support  Enabled   Value           Vendor\n");
1234         printf("read ahead                     %s       %s\n",
1235                 parm->support.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no",
1236                 parm->enabled.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no");
1237         printf("write cache                    %s       %s\n",
1238                 parm->support.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no",
1239                 parm->enabled.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no");
1240         printf("flush cache                    %s       %s\n",
1241                 parm->support.command2 & ATA_SUPPORT_FLUSHCACHE ? "yes" : "no",
1242                 parm->enabled.command2 & ATA_SUPPORT_FLUSHCACHE ? "yes" : "no");
1243         printf("overlap                        %s\n",
1244                 parm->capabilities1 & ATA_SUPPORT_OVERLAP ? "yes" : "no");
1245         printf("Tagged Command Queuing (TCQ)   %s       %s",
1246                 parm->support.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no",
1247                 parm->enabled.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no");
1248                 if (parm->support.command2 & ATA_SUPPORT_QUEUED) {
1249                         printf("        %d tags\n",
1250                             ATA_QUEUE_LEN(parm->queue) + 1);
1251                 } else
1252                         printf("\n");
1253         printf("Native Command Queuing (NCQ)   ");
1254         if (parm->satacapabilities != 0xffff &&
1255             (parm->satacapabilities & ATA_SUPPORT_NCQ)) {
1256                 printf("yes             %d tags\n",
1257                     ATA_QUEUE_LEN(parm->queue) + 1);
1258         } else
1259                 printf("no\n");
1260         printf("SMART                          %s       %s\n",
1261                 parm->support.command1 & ATA_SUPPORT_SMART ? "yes" : "no",
1262                 parm->enabled.command1 & ATA_SUPPORT_SMART ? "yes" : "no");
1263         printf("microcode download             %s       %s\n",
1264                 parm->support.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no",
1265                 parm->enabled.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no");
1266         printf("security                       %s       %s\n",
1267                 parm->support.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no",
1268                 parm->enabled.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no");
1269         printf("power management               %s       %s\n",
1270                 parm->support.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no",
1271                 parm->enabled.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no");
1272         printf("advanced power management      %s       %s",
1273                 parm->support.command2 & ATA_SUPPORT_APM ? "yes" : "no",
1274                 parm->enabled.command2 & ATA_SUPPORT_APM ? "yes" : "no");
1275                 if (parm->support.command2 & ATA_SUPPORT_APM) {
1276                         printf("        %d/0x%02X\n",
1277                             parm->apm_value, parm->apm_value);
1278                 } else
1279                         printf("\n");
1280         printf("automatic acoustic management  %s       %s",
1281                 parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no",
1282                 parm->enabled.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no");
1283                 if (parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC) {
1284                         printf("        %d/0x%02X       %d/0x%02X\n",
1285                             ATA_ACOUSTIC_CURRENT(parm->acoustic),
1286                             ATA_ACOUSTIC_CURRENT(parm->acoustic),
1287                             ATA_ACOUSTIC_VENDOR(parm->acoustic),
1288                             ATA_ACOUSTIC_VENDOR(parm->acoustic));
1289                 } else
1290                         printf("\n");
1291         printf("media status notification      %s       %s\n",
1292                 parm->support.command2 & ATA_SUPPORT_NOTIFY ? "yes" : "no",
1293                 parm->enabled.command2 & ATA_SUPPORT_NOTIFY ? "yes" : "no");
1294         printf("power-up in Standby            %s       %s\n",
1295                 parm->support.command2 & ATA_SUPPORT_STANDBY ? "yes" : "no",
1296                 parm->enabled.command2 & ATA_SUPPORT_STANDBY ? "yes" : "no");
1297         printf("write-read-verify              %s       %s",
1298                 parm->support2 & ATA_SUPPORT_WRITEREADVERIFY ? "yes" : "no",
1299                 parm->enabled2 & ATA_SUPPORT_WRITEREADVERIFY ? "yes" : "no");
1300                 if (parm->support2 & ATA_SUPPORT_WRITEREADVERIFY) {
1301                         printf("        %d/0x%x\n",
1302                             parm->wrv_mode, parm->wrv_mode);
1303                 } else
1304                         printf("\n");
1305         printf("unload                         %s       %s\n",
1306                 parm->support.extension & ATA_SUPPORT_UNLOAD ? "yes" : "no",
1307                 parm->enabled.extension & ATA_SUPPORT_UNLOAD ? "yes" : "no");
1308         printf("free-fall                      %s       %s\n",
1309                 parm->support2 & ATA_SUPPORT_FREEFALL ? "yes" : "no",
1310                 parm->enabled2 & ATA_SUPPORT_FREEFALL ? "yes" : "no");
1311         printf("data set management (TRIM)     %s\n",
1312                 parm->support_dsm & ATA_SUPPORT_DSM_TRIM ? "yes" : "no");
1313 }
1314
1315 static int
1316 ataidentify(struct cam_device *device, int retry_count, int timeout)
1317 {
1318         union ccb *ccb;
1319         struct ata_params *ident_buf;
1320         struct ccb_getdev cgd;
1321         u_int i, error = 0;
1322         int16_t *ptr;
1323
1324         if (get_cgd(device, &cgd) != 0) {
1325                 warnx("couldn't get CGD");
1326                 return(1);
1327         }
1328         ccb = cam_getccb(device);
1329
1330         if (ccb == NULL) {
1331                 warnx("couldn't allocate CCB");
1332                 return(1);
1333         }
1334
1335         /* cam_getccb cleans up the header, caller has to zero the payload */
1336         bzero(&(&ccb->ccb_h)[1],
1337               sizeof(struct ccb_ataio) - sizeof(struct ccb_hdr));
1338
1339         ptr = (uint16_t *)malloc(sizeof(struct ata_params));
1340
1341         if (ptr == NULL) {
1342                 cam_freeccb(ccb);
1343                 warnx("can't malloc memory for identify\n");
1344                 return(1);
1345         }
1346         bzero(ptr, sizeof(struct ata_params));
1347
1348         cam_fill_ataio(&ccb->ataio,
1349                       retry_count,
1350                       NULL,
1351                       /*flags*/CAM_DIR_IN,
1352                       MSG_SIMPLE_Q_TAG,
1353                       /*data_ptr*/(u_int8_t *)ptr,
1354                       /*dxfer_len*/sizeof(struct ata_params),
1355                       timeout ? timeout : 30 * 1000);
1356         if (cgd.protocol == PROTO_ATA)
1357                 ata_28bit_cmd(&ccb->ataio, ATA_ATA_IDENTIFY, 0, 0, 0);
1358         else
1359                 ata_28bit_cmd(&ccb->ataio, ATA_ATAPI_IDENTIFY, 0, 0, 0);
1360
1361         /* Disable freezing the device queue */
1362         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1363
1364         if (arglist & CAM_ARG_ERR_RECOVER)
1365                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
1366
1367         if (cam_send_ccb(device, ccb) < 0) {
1368                 perror("error sending ATA identify");
1369
1370                 if (arglist & CAM_ARG_VERBOSE) {
1371                         cam_error_print(device, ccb, CAM_ESF_ALL,
1372                                         CAM_EPF_ALL, stderr);
1373                 }
1374
1375                 free(ptr);
1376                 cam_freeccb(ccb);
1377                 return(1);
1378         }
1379
1380         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1381                 error = 1;
1382
1383                 if (arglist & CAM_ARG_VERBOSE) {
1384                         cam_error_print(device, ccb, CAM_ESF_ALL,
1385                                         CAM_EPF_ALL, stderr);
1386                 }
1387         }
1388
1389         cam_freeccb(ccb);
1390
1391         if (error != 0) {
1392                 free(ptr);
1393                 return(error);
1394         }
1395
1396         for (i = 0; i < sizeof(struct ata_params) / 2; i++)
1397                 ptr[i] = le16toh(ptr[i]);
1398         if (arglist & CAM_ARG_VERBOSE) {
1399                 fprintf(stdout, "%s%d: Raw identify data:\n",
1400                     device->device_name, device->dev_unit_num);
1401                 for (i = 0; i < sizeof(struct ata_params) / 2; i++) {
1402                         if ((i % 8) == 0)
1403                             fprintf(stdout, " %3d: ", i);
1404                         fprintf(stdout, "%04x ", (uint16_t)ptr[i]);
1405                         if ((i % 8) == 7)
1406                             fprintf(stdout, "\n");
1407                 }
1408         }
1409         ident_buf = (struct ata_params *)ptr;
1410         if (strncmp(ident_buf->model, "FX", 2) &&
1411             strncmp(ident_buf->model, "NEC", 3) &&
1412             strncmp(ident_buf->model, "Pioneer", 7) &&
1413             strncmp(ident_buf->model, "SHARP", 5)) {
1414                 ata_bswap(ident_buf->model, sizeof(ident_buf->model));
1415                 ata_bswap(ident_buf->revision, sizeof(ident_buf->revision));
1416                 ata_bswap(ident_buf->serial, sizeof(ident_buf->serial));
1417                 ata_bswap(ident_buf->media_serial, sizeof(ident_buf->media_serial));
1418         }
1419         ata_btrim(ident_buf->model, sizeof(ident_buf->model));
1420         ata_bpack(ident_buf->model, ident_buf->model, sizeof(ident_buf->model));
1421         ata_btrim(ident_buf->revision, sizeof(ident_buf->revision));
1422         ata_bpack(ident_buf->revision, ident_buf->revision, sizeof(ident_buf->revision));
1423         ata_btrim(ident_buf->serial, sizeof(ident_buf->serial));
1424         ata_bpack(ident_buf->serial, ident_buf->serial, sizeof(ident_buf->serial));
1425         ata_btrim(ident_buf->media_serial, sizeof(ident_buf->media_serial));
1426         ata_bpack(ident_buf->media_serial, ident_buf->media_serial,
1427             sizeof(ident_buf->media_serial));
1428
1429         fprintf(stdout, "%s%d: ", device->device_name,
1430                 device->dev_unit_num);
1431         ata_print_ident(ident_buf);
1432         camxferrate(device);
1433         atacapprint(ident_buf);
1434
1435         free(ident_buf);
1436
1437         return(0);
1438 }
1439 #endif /* MINIMALISTIC */
1440
1441 /*
1442  * Parse out a bus, or a bus, target and lun in the following
1443  * format:
1444  * bus
1445  * bus:target
1446  * bus:target:lun
1447  *
1448  * Returns the number of parsed components, or 0.
1449  */
1450 static int
1451 parse_btl(char *tstr, int *bus, int *target, int *lun, cam_argmask *arglst)
1452 {
1453         char *tmpstr;
1454         int convs = 0;
1455
1456         while (isspace(*tstr) && (*tstr != '\0'))
1457                 tstr++;
1458
1459         tmpstr = (char *)strtok(tstr, ":");
1460         if ((tmpstr != NULL) && (*tmpstr != '\0')) {
1461                 *bus = strtol(tmpstr, NULL, 0);
1462                 *arglst |= CAM_ARG_BUS;
1463                 convs++;
1464                 tmpstr = (char *)strtok(NULL, ":");
1465                 if ((tmpstr != NULL) && (*tmpstr != '\0')) {
1466                         *target = strtol(tmpstr, NULL, 0);
1467                         *arglst |= CAM_ARG_TARGET;
1468                         convs++;
1469                         tmpstr = (char *)strtok(NULL, ":");
1470                         if ((tmpstr != NULL) && (*tmpstr != '\0')) {
1471                                 *lun = strtol(tmpstr, NULL, 0);
1472                                 *arglst |= CAM_ARG_LUN;
1473                                 convs++;
1474                         }
1475                 }
1476         }
1477
1478         return convs;
1479 }
1480
1481 static int
1482 dorescan_or_reset(int argc, char **argv, int rescan)
1483 {
1484         static const char must[] =
1485                 "you must specify \"all\", a bus, or a bus:target:lun to %s";
1486         int rv, error = 0;
1487         int bus = -1, target = -1, lun = -1;
1488         char *tstr;
1489
1490         if (argc < 3) {
1491                 warnx(must, rescan? "rescan" : "reset");
1492                 return(1);
1493         }
1494
1495         tstr = argv[optind];
1496         while (isspace(*tstr) && (*tstr != '\0'))
1497                 tstr++;
1498         if (strncasecmp(tstr, "all", strlen("all")) == 0)
1499                 arglist |= CAM_ARG_BUS;
1500         else {
1501                 rv = parse_btl(argv[optind], &bus, &target, &lun, &arglist);
1502                 if (rv != 1 && rv != 3) {
1503                         warnx(must, rescan? "rescan" : "reset");
1504                         return(1);
1505                 }
1506         }
1507
1508         if ((arglist & CAM_ARG_BUS)
1509             && (arglist & CAM_ARG_TARGET)
1510             && (arglist & CAM_ARG_LUN))
1511                 error = scanlun_or_reset_dev(bus, target, lun, rescan);
1512         else
1513                 error = rescan_or_reset_bus(bus, rescan);
1514
1515         return(error);
1516 }
1517
1518 static int
1519 rescan_or_reset_bus(int bus, int rescan)
1520 {
1521         union ccb ccb, matchccb;
1522         int fd, retval;
1523         int bufsize;
1524
1525         retval = 0;
1526
1527         if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
1528                 warnx("error opening transport layer device %s", XPT_DEVICE);
1529                 warn("%s", XPT_DEVICE);
1530                 return(1);
1531         }
1532
1533         if (bus != -1) {
1534                 ccb.ccb_h.func_code = rescan ? XPT_SCAN_BUS : XPT_RESET_BUS;
1535                 ccb.ccb_h.path_id = bus;
1536                 ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
1537                 ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
1538                 ccb.crcn.flags = CAM_FLAG_NONE;
1539
1540                 /* run this at a low priority */
1541                 ccb.ccb_h.pinfo.priority = 5;
1542
1543                 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
1544                         warn("CAMIOCOMMAND ioctl failed");
1545                         close(fd);
1546                         return(1);
1547                 }
1548
1549                 if ((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
1550                         fprintf(stdout, "%s of bus %d was successful\n",
1551                             rescan ? "Re-scan" : "Reset", bus);
1552                 } else {
1553                         fprintf(stdout, "%s of bus %d returned error %#x\n",
1554                                 rescan ? "Re-scan" : "Reset", bus,
1555                                 ccb.ccb_h.status & CAM_STATUS_MASK);
1556                         retval = 1;
1557                 }
1558
1559                 close(fd);
1560                 return(retval);
1561
1562         }
1563
1564
1565         /*
1566          * The right way to handle this is to modify the xpt so that it can
1567          * handle a wildcarded bus in a rescan or reset CCB.  At the moment
1568          * that isn't implemented, so instead we enumerate the busses and
1569          * send the rescan or reset to those busses in the case where the
1570          * given bus is -1 (wildcard).  We don't send a rescan or reset
1571          * to the xpt bus; sending a rescan to the xpt bus is effectively a
1572          * no-op, sending a rescan to the xpt bus would result in a status of
1573          * CAM_REQ_INVALID.
1574          */
1575         bzero(&(&matchccb.ccb_h)[1],
1576               sizeof(struct ccb_dev_match) - sizeof(struct ccb_hdr));
1577         matchccb.ccb_h.func_code = XPT_DEV_MATCH;
1578         matchccb.ccb_h.path_id = CAM_BUS_WILDCARD;
1579         bufsize = sizeof(struct dev_match_result) * 20;
1580         matchccb.cdm.match_buf_len = bufsize;
1581         matchccb.cdm.matches=(struct dev_match_result *)malloc(bufsize);
1582         if (matchccb.cdm.matches == NULL) {
1583                 warnx("can't malloc memory for matches");
1584                 retval = 1;
1585                 goto bailout;
1586         }
1587         matchccb.cdm.num_matches = 0;
1588
1589         matchccb.cdm.num_patterns = 1;
1590         matchccb.cdm.pattern_buf_len = sizeof(struct dev_match_pattern);
1591
1592         matchccb.cdm.patterns = (struct dev_match_pattern *)malloc(
1593                 matchccb.cdm.pattern_buf_len);
1594         if (matchccb.cdm.patterns == NULL) {
1595                 warnx("can't malloc memory for patterns");
1596                 retval = 1;
1597                 goto bailout;
1598         }
1599         matchccb.cdm.patterns[0].type = DEV_MATCH_BUS;
1600         matchccb.cdm.patterns[0].pattern.bus_pattern.flags = BUS_MATCH_ANY;
1601
1602         do {
1603                 unsigned int i;
1604
1605                 if (ioctl(fd, CAMIOCOMMAND, &matchccb) == -1) {
1606                         warn("CAMIOCOMMAND ioctl failed");
1607                         retval = 1;
1608                         goto bailout;
1609                 }
1610
1611                 if ((matchccb.ccb_h.status != CAM_REQ_CMP)
1612                  || ((matchccb.cdm.status != CAM_DEV_MATCH_LAST)
1613                    && (matchccb.cdm.status != CAM_DEV_MATCH_MORE))) {
1614                         warnx("got CAM error %#x, CDM error %d\n",
1615                               matchccb.ccb_h.status, matchccb.cdm.status);
1616                         retval = 1;
1617                         goto bailout;
1618                 }
1619
1620                 for (i = 0; i < matchccb.cdm.num_matches; i++) {
1621                         struct bus_match_result *bus_result;
1622
1623                         /* This shouldn't happen. */
1624                         if (matchccb.cdm.matches[i].type != DEV_MATCH_BUS)
1625                                 continue;
1626
1627                         bus_result = &matchccb.cdm.matches[i].result.bus_result;
1628
1629                         /*
1630                          * We don't want to rescan or reset the xpt bus.
1631                          * See above.
1632                          */
1633                         if ((int)bus_result->path_id == -1)
1634                                 continue;
1635
1636                         ccb.ccb_h.func_code = rescan ? XPT_SCAN_BUS :
1637                                                        XPT_RESET_BUS;
1638                         ccb.ccb_h.path_id = bus_result->path_id;
1639                         ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
1640                         ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
1641                         ccb.crcn.flags = CAM_FLAG_NONE;
1642
1643                         /* run this at a low priority */
1644                         ccb.ccb_h.pinfo.priority = 5;
1645
1646                         if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
1647                                 warn("CAMIOCOMMAND ioctl failed");
1648                                 retval = 1;
1649                                 goto bailout;
1650                         }
1651
1652                         if ((ccb.ccb_h.status & CAM_STATUS_MASK) ==CAM_REQ_CMP){
1653                                 fprintf(stdout, "%s of bus %d was successful\n",
1654                                         rescan? "Re-scan" : "Reset",
1655                                         bus_result->path_id);
1656                         } else {
1657                                 /*
1658                                  * Don't bail out just yet, maybe the other
1659                                  * rescan or reset commands will complete
1660                                  * successfully.
1661                                  */
1662                                 fprintf(stderr, "%s of bus %d returned error "
1663                                         "%#x\n", rescan? "Re-scan" : "Reset",
1664                                         bus_result->path_id,
1665                                         ccb.ccb_h.status & CAM_STATUS_MASK);
1666                                 retval = 1;
1667                         }
1668                 }
1669         } while ((matchccb.ccb_h.status == CAM_REQ_CMP)
1670                  && (matchccb.cdm.status == CAM_DEV_MATCH_MORE));
1671
1672 bailout:
1673
1674         if (fd != -1)
1675                 close(fd);
1676
1677         if (matchccb.cdm.patterns != NULL)
1678                 free(matchccb.cdm.patterns);
1679         if (matchccb.cdm.matches != NULL)
1680                 free(matchccb.cdm.matches);
1681
1682         return(retval);
1683 }
1684
1685 static int
1686 scanlun_or_reset_dev(int bus, int target, int lun, int scan)
1687 {
1688         union ccb ccb;
1689         struct cam_device *device;
1690         int fd;
1691
1692         device = NULL;
1693
1694         if (bus < 0) {
1695                 warnx("invalid bus number %d", bus);
1696                 return(1);
1697         }
1698
1699         if (target < 0) {
1700                 warnx("invalid target number %d", target);
1701                 return(1);
1702         }
1703
1704         if (lun < 0) {
1705                 warnx("invalid lun number %d", lun);
1706                 return(1);
1707         }
1708
1709         fd = -1;
1710
1711         bzero(&ccb, sizeof(union ccb));
1712
1713         if (scan) {
1714                 if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
1715                         warnx("error opening transport layer device %s\n",
1716                             XPT_DEVICE);
1717                         warn("%s", XPT_DEVICE);
1718                         return(1);
1719                 }
1720         } else {
1721                 device = cam_open_btl(bus, target, lun, O_RDWR, NULL);
1722                 if (device == NULL) {
1723                         warnx("%s", cam_errbuf);
1724                         return(1);
1725                 }
1726         }
1727
1728         ccb.ccb_h.func_code = (scan)? XPT_SCAN_LUN : XPT_RESET_DEV;
1729         ccb.ccb_h.path_id = bus;
1730         ccb.ccb_h.target_id = target;
1731         ccb.ccb_h.target_lun = lun;
1732         ccb.ccb_h.timeout = 5000;
1733         ccb.crcn.flags = CAM_FLAG_NONE;
1734
1735         /* run this at a low priority */
1736         ccb.ccb_h.pinfo.priority = 5;
1737
1738         if (scan) {
1739                 if (ioctl(fd, CAMIOCOMMAND, &ccb) < 0) {
1740                         warn("CAMIOCOMMAND ioctl failed");
1741                         close(fd);
1742                         return(1);
1743                 }
1744         } else {
1745                 if (cam_send_ccb(device, &ccb) < 0) {
1746                         warn("error sending XPT_RESET_DEV CCB");
1747                         cam_close_device(device);
1748                         return(1);
1749                 }
1750         }
1751
1752         if (scan)
1753                 close(fd);
1754         else
1755                 cam_close_device(device);
1756
1757         /*
1758          * An error code of CAM_BDR_SENT is normal for a BDR request.
1759          */
1760         if (((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
1761          || ((!scan)
1762           && ((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_BDR_SENT))) {
1763                 fprintf(stdout, "%s of %d:%d:%d was successful\n",
1764                     scan? "Re-scan" : "Reset", bus, target, lun);
1765                 return(0);
1766         } else {
1767                 fprintf(stdout, "%s of %d:%d:%d returned error %#x\n",
1768                     scan? "Re-scan" : "Reset", bus, target, lun,
1769                     ccb.ccb_h.status & CAM_STATUS_MASK);
1770                 return(1);
1771         }
1772 }
1773
1774 #ifndef MINIMALISTIC
1775 static int
1776 readdefects(struct cam_device *device, int argc, char **argv,
1777             char *combinedopt, int retry_count, int timeout)
1778 {
1779         union ccb *ccb = NULL;
1780         struct scsi_read_defect_data_10 *rdd_cdb;
1781         u_int8_t *defect_list = NULL;
1782         u_int32_t dlist_length = 65000;
1783         u_int32_t returned_length = 0;
1784         u_int32_t num_returned = 0;
1785         u_int8_t returned_format;
1786         unsigned int i;
1787         int c, error = 0;
1788         int lists_specified = 0;
1789
1790         while ((c = getopt(argc, argv, combinedopt)) != -1) {
1791                 switch(c){
1792                 case 'f':
1793                 {
1794                         char *tstr;
1795                         tstr = optarg;
1796                         while (isspace(*tstr) && (*tstr != '\0'))
1797                                 tstr++;
1798                         if (strcmp(tstr, "block") == 0)
1799                                 arglist |= CAM_ARG_FORMAT_BLOCK;
1800                         else if (strcmp(tstr, "bfi") == 0)
1801                                 arglist |= CAM_ARG_FORMAT_BFI;
1802                         else if (strcmp(tstr, "phys") == 0)
1803                                 arglist |= CAM_ARG_FORMAT_PHYS;
1804                         else {
1805                                 error = 1;
1806                                 warnx("invalid defect format %s", tstr);
1807                                 goto defect_bailout;
1808                         }
1809                         break;
1810                 }
1811                 case 'G':
1812                         arglist |= CAM_ARG_GLIST;
1813                         break;
1814                 case 'P':
1815                         arglist |= CAM_ARG_PLIST;
1816                         break;
1817                 default:
1818                         break;
1819                 }
1820         }
1821
1822         ccb = cam_getccb(device);
1823
1824         /*
1825          * Hopefully 65000 bytes is enough to hold the defect list.  If it
1826          * isn't, the disk is probably dead already.  We'd have to go with
1827          * 12 byte command (i.e. alloc_length is 32 bits instead of 16)
1828          * to hold them all.
1829          */
1830         defect_list = malloc(dlist_length);
1831         if (defect_list == NULL) {
1832                 warnx("can't malloc memory for defect list");
1833                 error = 1;
1834                 goto defect_bailout;
1835         }
1836
1837         rdd_cdb =(struct scsi_read_defect_data_10 *)&ccb->csio.cdb_io.cdb_bytes;
1838
1839         /*
1840          * cam_getccb() zeros the CCB header only.  So we need to zero the
1841          * payload portion of the ccb.
1842          */
1843         bzero(&(&ccb->ccb_h)[1],
1844               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
1845
1846         cam_fill_csio(&ccb->csio,
1847                       /*retries*/ retry_count,
1848                       /*cbfcnp*/ NULL,
1849                       /*flags*/ CAM_DIR_IN | ((arglist & CAM_ARG_ERR_RECOVER) ?
1850                                               CAM_PASS_ERR_RECOVER : 0),
1851                       /*tag_action*/ MSG_SIMPLE_Q_TAG,
1852                       /*data_ptr*/ defect_list,
1853                       /*dxfer_len*/ dlist_length,
1854                       /*sense_len*/ SSD_FULL_SIZE,
1855                       /*cdb_len*/ sizeof(struct scsi_read_defect_data_10),
1856                       /*timeout*/ timeout ? timeout : 5000);
1857
1858         rdd_cdb->opcode = READ_DEFECT_DATA_10;
1859         if (arglist & CAM_ARG_FORMAT_BLOCK)
1860                 rdd_cdb->format = SRDD10_BLOCK_FORMAT;
1861         else if (arglist & CAM_ARG_FORMAT_BFI)
1862                 rdd_cdb->format = SRDD10_BYTES_FROM_INDEX_FORMAT;
1863         else if (arglist & CAM_ARG_FORMAT_PHYS)
1864                 rdd_cdb->format = SRDD10_PHYSICAL_SECTOR_FORMAT;
1865         else {
1866                 error = 1;
1867                 warnx("no defect list format specified");
1868                 goto defect_bailout;
1869         }
1870         if (arglist & CAM_ARG_PLIST) {
1871                 rdd_cdb->format |= SRDD10_PLIST;
1872                 lists_specified++;
1873         }
1874
1875         if (arglist & CAM_ARG_GLIST) {
1876                 rdd_cdb->format |= SRDD10_GLIST;
1877                 lists_specified++;
1878         }
1879
1880         scsi_ulto2b(dlist_length, rdd_cdb->alloc_length);
1881
1882         /* Disable freezing the device queue */
1883         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1884
1885         if (cam_send_ccb(device, ccb) < 0) {
1886                 perror("error reading defect list");
1887
1888                 if (arglist & CAM_ARG_VERBOSE) {
1889                         cam_error_print(device, ccb, CAM_ESF_ALL,
1890                                         CAM_EPF_ALL, stderr);
1891                 }
1892
1893                 error = 1;
1894                 goto defect_bailout;
1895         }
1896
1897         returned_length = scsi_2btoul(((struct
1898                 scsi_read_defect_data_hdr_10 *)defect_list)->length);
1899
1900         returned_format = ((struct scsi_read_defect_data_hdr_10 *)
1901                         defect_list)->format;
1902
1903         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_SCSI_STATUS_ERROR)
1904          && (ccb->csio.scsi_status == SCSI_STATUS_CHECK_COND)
1905          && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
1906                 struct scsi_sense_data *sense;
1907                 int error_code, sense_key, asc, ascq;
1908
1909                 sense = &ccb->csio.sense_data;
1910                 scsi_extract_sense_len(sense, ccb->csio.sense_len -
1911                     ccb->csio.sense_resid, &error_code, &sense_key, &asc,
1912                     &ascq, /*show_errors*/ 1);
1913
1914                 /*
1915                  * According to the SCSI spec, if the disk doesn't support
1916                  * the requested format, it will generally return a sense
1917                  * key of RECOVERED ERROR, and an additional sense code
1918                  * of "DEFECT LIST NOT FOUND".  So, we check for that, and
1919                  * also check to make sure that the returned length is
1920                  * greater than 0, and then print out whatever format the
1921                  * disk gave us.
1922                  */
1923                 if ((sense_key == SSD_KEY_RECOVERED_ERROR)
1924                  && (asc == 0x1c) && (ascq == 0x00)
1925                  && (returned_length > 0)) {
1926                         warnx("requested defect format not available");
1927                         switch(returned_format & SRDDH10_DLIST_FORMAT_MASK) {
1928                         case SRDD10_BLOCK_FORMAT:
1929                                 warnx("Device returned block format");
1930                                 break;
1931                         case SRDD10_BYTES_FROM_INDEX_FORMAT:
1932                                 warnx("Device returned bytes from index"
1933                                       " format");
1934                                 break;
1935                         case SRDD10_PHYSICAL_SECTOR_FORMAT:
1936                                 warnx("Device returned physical sector format");
1937                                 break;
1938                         default:
1939                                 error = 1;
1940                                 warnx("Device returned unknown defect"
1941                                      " data format %#x", returned_format);
1942                                 goto defect_bailout;
1943                                 break; /* NOTREACHED */
1944                         }
1945                 } else {
1946                         error = 1;
1947                         warnx("Error returned from read defect data command");
1948                         if (arglist & CAM_ARG_VERBOSE)
1949                                 cam_error_print(device, ccb, CAM_ESF_ALL,
1950                                                 CAM_EPF_ALL, stderr);
1951                         goto defect_bailout;
1952                 }
1953         } else if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1954                 error = 1;
1955                 warnx("Error returned from read defect data command");
1956                 if (arglist & CAM_ARG_VERBOSE)
1957                         cam_error_print(device, ccb, CAM_ESF_ALL,
1958                                         CAM_EPF_ALL, stderr);
1959                 goto defect_bailout;
1960         }
1961
1962         /*
1963          * XXX KDM  I should probably clean up the printout format for the
1964          * disk defects.
1965          */
1966         switch (returned_format & SRDDH10_DLIST_FORMAT_MASK){
1967                 case SRDDH10_PHYSICAL_SECTOR_FORMAT:
1968                 {
1969                         struct scsi_defect_desc_phys_sector *dlist;
1970
1971                         dlist = (struct scsi_defect_desc_phys_sector *)
1972                                 (defect_list +
1973                                 sizeof(struct scsi_read_defect_data_hdr_10));
1974
1975                         num_returned = returned_length /
1976                                 sizeof(struct scsi_defect_desc_phys_sector);
1977
1978                         fprintf(stderr, "Got %d defect", num_returned);
1979
1980                         if ((lists_specified == 0) || (num_returned == 0)) {
1981                                 fprintf(stderr, "s.\n");
1982                                 break;
1983                         } else if (num_returned == 1)
1984                                 fprintf(stderr, ":\n");
1985                         else
1986                                 fprintf(stderr, "s:\n");
1987
1988                         for (i = 0; i < num_returned; i++) {
1989                                 fprintf(stdout, "%d:%d:%d\n",
1990                                         scsi_3btoul(dlist[i].cylinder),
1991                                         dlist[i].head,
1992                                         scsi_4btoul(dlist[i].sector));
1993                         }
1994                         break;
1995                 }
1996                 case SRDDH10_BYTES_FROM_INDEX_FORMAT:
1997                 {
1998                         struct scsi_defect_desc_bytes_from_index *dlist;
1999
2000                         dlist = (struct scsi_defect_desc_bytes_from_index *)
2001                                 (defect_list +
2002                                 sizeof(struct scsi_read_defect_data_hdr_10));
2003
2004                         num_returned = returned_length /
2005                               sizeof(struct scsi_defect_desc_bytes_from_index);
2006
2007                         fprintf(stderr, "Got %d defect", num_returned);
2008
2009                         if ((lists_specified == 0) || (num_returned == 0)) {
2010                                 fprintf(stderr, "s.\n");
2011                                 break;
2012                         } else if (num_returned == 1)
2013                                 fprintf(stderr, ":\n");
2014                         else
2015                                 fprintf(stderr, "s:\n");
2016
2017                         for (i = 0; i < num_returned; i++) {
2018                                 fprintf(stdout, "%d:%d:%d\n",
2019                                         scsi_3btoul(dlist[i].cylinder),
2020                                         dlist[i].head,
2021                                         scsi_4btoul(dlist[i].bytes_from_index));
2022                         }
2023                         break;
2024                 }
2025                 case SRDDH10_BLOCK_FORMAT:
2026                 {
2027                         struct scsi_defect_desc_block *dlist;
2028
2029                         dlist = (struct scsi_defect_desc_block *)(defect_list +
2030                                 sizeof(struct scsi_read_defect_data_hdr_10));
2031
2032                         num_returned = returned_length /
2033                               sizeof(struct scsi_defect_desc_block);
2034
2035                         fprintf(stderr, "Got %d defect", num_returned);
2036
2037                         if ((lists_specified == 0) || (num_returned == 0)) {
2038                                 fprintf(stderr, "s.\n");
2039                                 break;
2040                         } else if (num_returned == 1)
2041                                 fprintf(stderr, ":\n");
2042                         else
2043                                 fprintf(stderr, "s:\n");
2044
2045                         for (i = 0; i < num_returned; i++)
2046                                 fprintf(stdout, "%u\n",
2047                                         scsi_4btoul(dlist[i].address));
2048                         break;
2049                 }
2050                 default:
2051                         fprintf(stderr, "Unknown defect format %d\n",
2052                                 returned_format & SRDDH10_DLIST_FORMAT_MASK);
2053                         error = 1;
2054                         break;
2055         }
2056 defect_bailout:
2057
2058         if (defect_list != NULL)
2059                 free(defect_list);
2060
2061         if (ccb != NULL)
2062                 cam_freeccb(ccb);
2063
2064         return(error);
2065 }
2066 #endif /* MINIMALISTIC */
2067
2068 #if 0
2069 void
2070 reassignblocks(struct cam_device *device, u_int32_t *blocks, int num_blocks)
2071 {
2072         union ccb *ccb;
2073
2074         ccb = cam_getccb(device);
2075
2076         cam_freeccb(ccb);
2077 }
2078 #endif
2079
2080 #ifndef MINIMALISTIC
2081 void
2082 mode_sense(struct cam_device *device, int mode_page, int page_control,
2083            int dbd, int retry_count, int timeout, u_int8_t *data, int datalen)
2084 {
2085         union ccb *ccb;
2086         int retval;
2087
2088         ccb = cam_getccb(device);
2089
2090         if (ccb == NULL)
2091                 errx(1, "mode_sense: couldn't allocate CCB");
2092
2093         bzero(&(&ccb->ccb_h)[1],
2094               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
2095
2096         scsi_mode_sense(&ccb->csio,
2097                         /* retries */ retry_count,
2098                         /* cbfcnp */ NULL,
2099                         /* tag_action */ MSG_SIMPLE_Q_TAG,
2100                         /* dbd */ dbd,
2101                         /* page_code */ page_control << 6,
2102                         /* page */ mode_page,
2103                         /* param_buf */ data,
2104                         /* param_len */ datalen,
2105                         /* sense_len */ SSD_FULL_SIZE,
2106                         /* timeout */ timeout ? timeout : 5000);
2107
2108         if (arglist & CAM_ARG_ERR_RECOVER)
2109                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
2110
2111         /* Disable freezing the device queue */
2112         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
2113
2114         if (((retval = cam_send_ccb(device, ccb)) < 0)
2115          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
2116                 if (arglist & CAM_ARG_VERBOSE) {
2117                         cam_error_print(device, ccb, CAM_ESF_ALL,
2118                                         CAM_EPF_ALL, stderr);
2119                 }
2120                 cam_freeccb(ccb);
2121                 cam_close_device(device);
2122                 if (retval < 0)
2123                         err(1, "error sending mode sense command");
2124                 else
2125                         errx(1, "error sending mode sense command");
2126         }
2127
2128         cam_freeccb(ccb);
2129 }
2130
2131 void
2132 mode_select(struct cam_device *device, int save_pages, int retry_count,
2133            int timeout, u_int8_t *data, int datalen)
2134 {
2135         union ccb *ccb;
2136         int retval;
2137
2138         ccb = cam_getccb(device);
2139
2140         if (ccb == NULL)
2141                 errx(1, "mode_select: couldn't allocate CCB");
2142
2143         bzero(&(&ccb->ccb_h)[1],
2144               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
2145
2146         scsi_mode_select(&ccb->csio,
2147                          /* retries */ retry_count,
2148                          /* cbfcnp */ NULL,
2149                          /* tag_action */ MSG_SIMPLE_Q_TAG,
2150                          /* scsi_page_fmt */ 1,
2151                          /* save_pages */ save_pages,
2152                          /* param_buf */ data,
2153                          /* param_len */ datalen,
2154                          /* sense_len */ SSD_FULL_SIZE,
2155                          /* timeout */ timeout ? timeout : 5000);
2156
2157         if (arglist & CAM_ARG_ERR_RECOVER)
2158                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
2159
2160         /* Disable freezing the device queue */
2161         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
2162
2163         if (((retval = cam_send_ccb(device, ccb)) < 0)
2164          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
2165                 if (arglist & CAM_ARG_VERBOSE) {
2166                         cam_error_print(device, ccb, CAM_ESF_ALL,
2167                                         CAM_EPF_ALL, stderr);
2168                 }
2169                 cam_freeccb(ccb);
2170                 cam_close_device(device);
2171
2172                 if (retval < 0)
2173                         err(1, "error sending mode select command");
2174                 else
2175                         errx(1, "error sending mode select command");
2176
2177         }
2178
2179         cam_freeccb(ccb);
2180 }
2181
2182 void
2183 modepage(struct cam_device *device, int argc, char **argv, char *combinedopt,
2184          int retry_count, int timeout)
2185 {
2186         int c, mode_page = -1, page_control = 0;
2187         int binary = 0, list = 0;
2188
2189         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2190                 switch(c) {
2191                 case 'b':
2192                         binary = 1;
2193                         break;
2194                 case 'd':
2195                         arglist |= CAM_ARG_DBD;
2196                         break;
2197                 case 'e':
2198                         arglist |= CAM_ARG_MODE_EDIT;
2199                         break;
2200                 case 'l':
2201                         list = 1;
2202                         break;
2203                 case 'm':
2204                         mode_page = strtol(optarg, NULL, 0);
2205                         if (mode_page < 0)
2206                                 errx(1, "invalid mode page %d", mode_page);
2207                         break;
2208                 case 'P':
2209                         page_control = strtol(optarg, NULL, 0);
2210                         if ((page_control < 0) || (page_control > 3))
2211                                 errx(1, "invalid page control field %d",
2212                                      page_control);
2213                         arglist |= CAM_ARG_PAGE_CNTL;
2214                         break;
2215                 default:
2216                         break;
2217                 }
2218         }
2219
2220         if (mode_page == -1 && list == 0)
2221                 errx(1, "you must specify a mode page!");
2222
2223         if (list) {
2224                 mode_list(device, page_control, arglist & CAM_ARG_DBD,
2225                     retry_count, timeout);
2226         } else {
2227                 mode_edit(device, mode_page, page_control,
2228                     arglist & CAM_ARG_DBD, arglist & CAM_ARG_MODE_EDIT, binary,
2229                     retry_count, timeout);
2230         }
2231 }
2232
2233 static int
2234 scsicmd(struct cam_device *device, int argc, char **argv, char *combinedopt,
2235         int retry_count, int timeout)
2236 {
2237         union ccb *ccb;
2238         u_int32_t flags = CAM_DIR_NONE;
2239         u_int8_t *data_ptr = NULL;
2240         u_int8_t cdb[20];
2241         u_int8_t atacmd[12];
2242         struct get_hook hook;
2243         int c, data_bytes = 0;
2244         int cdb_len = 0;
2245         int atacmd_len = 0;
2246         int dmacmd = 0;
2247         int fpdmacmd = 0;
2248         int need_res = 0;
2249         char *datastr = NULL, *tstr, *resstr = NULL;
2250         int error = 0;
2251         int fd_data = 0, fd_res = 0;
2252         int retval;
2253
2254         ccb = cam_getccb(device);
2255
2256         if (ccb == NULL) {
2257                 warnx("scsicmd: error allocating ccb");
2258                 return(1);
2259         }
2260
2261         bzero(&(&ccb->ccb_h)[1],
2262               sizeof(union ccb) - sizeof(struct ccb_hdr));
2263
2264         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2265                 switch(c) {
2266                 case 'a':
2267                         tstr = optarg;
2268                         while (isspace(*tstr) && (*tstr != '\0'))
2269                                 tstr++;
2270                         hook.argc = argc - optind;
2271                         hook.argv = argv + optind;
2272                         hook.got = 0;
2273                         atacmd_len = buff_encode_visit(atacmd, sizeof(atacmd), tstr,
2274                                                     iget, &hook);
2275                         /*
2276                          * Increment optind by the number of arguments the
2277                          * encoding routine processed.  After each call to
2278                          * getopt(3), optind points to the argument that
2279                          * getopt should process _next_.  In this case,
2280                          * that means it points to the first command string
2281                          * argument, if there is one.  Once we increment
2282                          * this, it should point to either the next command
2283                          * line argument, or it should be past the end of
2284                          * the list.
2285                          */
2286                         optind += hook.got;
2287                         break;
2288                 case 'c':
2289                         tstr = optarg;
2290                         while (isspace(*tstr) && (*tstr != '\0'))
2291                                 tstr++;
2292                         hook.argc = argc - optind;
2293                         hook.argv = argv + optind;
2294                         hook.got = 0;
2295                         cdb_len = buff_encode_visit(cdb, sizeof(cdb), tstr,
2296                                                     iget, &hook);
2297                         /*
2298                          * Increment optind by the number of arguments the
2299                          * encoding routine processed.  After each call to
2300                          * getopt(3), optind points to the argument that
2301                          * getopt should process _next_.  In this case,
2302                          * that means it points to the first command string
2303                          * argument, if there is one.  Once we increment
2304                          * this, it should point to either the next command
2305                          * line argument, or it should be past the end of
2306                          * the list.
2307                          */
2308                         optind += hook.got;
2309                         break;
2310                 case 'd':
2311                         dmacmd = 1;
2312                         break;
2313                 case 'f':
2314                         fpdmacmd = 1;
2315                         break;
2316                 case 'i':
2317                         if (arglist & CAM_ARG_CMD_OUT) {
2318                                 warnx("command must either be "
2319                                       "read or write, not both");
2320                                 error = 1;
2321                                 goto scsicmd_bailout;
2322                         }
2323                         arglist |= CAM_ARG_CMD_IN;
2324                         flags = CAM_DIR_IN;
2325                         data_bytes = strtol(optarg, NULL, 0);
2326                         if (data_bytes <= 0) {
2327                                 warnx("invalid number of input bytes %d",
2328                                       data_bytes);
2329                                 error = 1;
2330                                 goto scsicmd_bailout;
2331                         }
2332                         hook.argc = argc - optind;
2333                         hook.argv = argv + optind;
2334                         hook.got = 0;
2335                         optind++;
2336                         datastr = cget(&hook, NULL);
2337                         /*
2338                          * If the user supplied "-" instead of a format, he
2339                          * wants the data to be written to stdout.
2340                          */
2341                         if ((datastr != NULL)
2342                          && (datastr[0] == '-'))
2343                                 fd_data = 1;
2344
2345                         data_ptr = (u_int8_t *)malloc(data_bytes);
2346                         if (data_ptr == NULL) {
2347                                 warnx("can't malloc memory for data_ptr");
2348                                 error = 1;
2349                                 goto scsicmd_bailout;
2350                         }
2351                         break;
2352                 case 'o':
2353                         if (arglist & CAM_ARG_CMD_IN) {
2354                                 warnx("command must either be "
2355                                       "read or write, not both");
2356                                 error = 1;
2357                                 goto scsicmd_bailout;
2358                         }
2359                         arglist |= CAM_ARG_CMD_OUT;
2360                         flags = CAM_DIR_OUT;
2361                         data_bytes = strtol(optarg, NULL, 0);
2362                         if (data_bytes <= 0) {
2363                                 warnx("invalid number of output bytes %d",
2364                                       data_bytes);
2365                                 error = 1;
2366                                 goto scsicmd_bailout;
2367                         }
2368                         hook.argc = argc - optind;
2369                         hook.argv = argv + optind;
2370                         hook.got = 0;
2371                         datastr = cget(&hook, NULL);
2372                         data_ptr = (u_int8_t *)malloc(data_bytes);
2373                         if (data_ptr == NULL) {
2374                                 warnx("can't malloc memory for data_ptr");
2375                                 error = 1;
2376                                 goto scsicmd_bailout;
2377                         }
2378                         bzero(data_ptr, data_bytes);
2379                         /*
2380                          * If the user supplied "-" instead of a format, he
2381                          * wants the data to be read from stdin.
2382                          */
2383                         if ((datastr != NULL)
2384                          && (datastr[0] == '-'))
2385                                 fd_data = 1;
2386                         else
2387                                 buff_encode_visit(data_ptr, data_bytes, datastr,
2388                                                   iget, &hook);
2389                         optind += hook.got;
2390                         break;
2391                 case 'r':
2392                         need_res = 1;
2393                         hook.argc = argc - optind;
2394                         hook.argv = argv + optind;
2395                         hook.got = 0;
2396                         resstr = cget(&hook, NULL);
2397                         if ((resstr != NULL) && (resstr[0] == '-'))
2398                                 fd_res = 1;
2399                         optind += hook.got;
2400                         break;
2401                 default:
2402                         break;
2403                 }
2404         }
2405
2406         /*
2407          * If fd_data is set, and we're writing to the device, we need to
2408          * read the data the user wants written from stdin.
2409          */
2410         if ((fd_data == 1) && (arglist & CAM_ARG_CMD_OUT)) {
2411                 ssize_t amt_read;
2412                 int amt_to_read = data_bytes;
2413                 u_int8_t *buf_ptr = data_ptr;
2414
2415                 for (amt_read = 0; amt_to_read > 0;
2416                      amt_read = read(STDIN_FILENO, buf_ptr, amt_to_read)) {
2417                         if (amt_read == -1) {
2418                                 warn("error reading data from stdin");
2419                                 error = 1;
2420                                 goto scsicmd_bailout;
2421                         }
2422                         amt_to_read -= amt_read;
2423                         buf_ptr += amt_read;
2424                 }
2425         }
2426
2427         if (arglist & CAM_ARG_ERR_RECOVER)
2428                 flags |= CAM_PASS_ERR_RECOVER;
2429
2430         /* Disable freezing the device queue */
2431         flags |= CAM_DEV_QFRZDIS;
2432
2433         if (cdb_len) {
2434                 /*
2435                  * This is taken from the SCSI-3 draft spec.
2436                  * (T10/1157D revision 0.3)
2437                  * The top 3 bits of an opcode are the group code.
2438                  * The next 5 bits are the command code.
2439                  * Group 0:  six byte commands
2440                  * Group 1:  ten byte commands
2441                  * Group 2:  ten byte commands
2442                  * Group 3:  reserved
2443                  * Group 4:  sixteen byte commands
2444                  * Group 5:  twelve byte commands
2445                  * Group 6:  vendor specific
2446                  * Group 7:  vendor specific
2447                  */
2448                 switch((cdb[0] >> 5) & 0x7) {
2449                         case 0:
2450                                 cdb_len = 6;
2451                                 break;
2452                         case 1:
2453                         case 2:
2454                                 cdb_len = 10;
2455                                 break;
2456                         case 3:
2457                         case 6:
2458                         case 7:
2459                                 /* computed by buff_encode_visit */
2460                                 break;
2461                         case 4:
2462                                 cdb_len = 16;
2463                                 break;
2464                         case 5:
2465                                 cdb_len = 12;
2466                                 break;
2467                 }
2468
2469                 /*
2470                  * We should probably use csio_build_visit or something like that
2471                  * here, but it's easier to encode arguments as you go.  The
2472                  * alternative would be skipping the CDB argument and then encoding
2473                  * it here, since we've got the data buffer argument by now.
2474                  */
2475                 bcopy(cdb, &ccb->csio.cdb_io.cdb_bytes, cdb_len);
2476
2477                 cam_fill_csio(&ccb->csio,
2478                       /*retries*/ retry_count,
2479                       /*cbfcnp*/ NULL,
2480                       /*flags*/ flags,
2481                       /*tag_action*/ MSG_SIMPLE_Q_TAG,
2482                       /*data_ptr*/ data_ptr,
2483                       /*dxfer_len*/ data_bytes,
2484                       /*sense_len*/ SSD_FULL_SIZE,
2485                       /*cdb_len*/ cdb_len,
2486                       /*timeout*/ timeout ? timeout : 5000);
2487         } else {
2488                 atacmd_len = 12;
2489                 bcopy(atacmd, &ccb->ataio.cmd.command, atacmd_len);
2490                 if (need_res)
2491                         ccb->ataio.cmd.flags |= CAM_ATAIO_NEEDRESULT;
2492                 if (dmacmd)
2493                         ccb->ataio.cmd.flags |= CAM_ATAIO_DMA;
2494                 if (fpdmacmd)
2495                         ccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA;
2496
2497                 cam_fill_ataio(&ccb->ataio,
2498                       /*retries*/ retry_count,
2499                       /*cbfcnp*/ NULL,
2500                       /*flags*/ flags,
2501                       /*tag_action*/ 0,
2502                       /*data_ptr*/ data_ptr,
2503                       /*dxfer_len*/ data_bytes,
2504                       /*timeout*/ timeout ? timeout : 5000);
2505         }
2506
2507         if (((retval = cam_send_ccb(device, ccb)) < 0)
2508          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
2509                 const char warnstr[] = "error sending command";
2510
2511                 if (retval < 0)
2512                         warn(warnstr);
2513                 else
2514                         warnx(warnstr);
2515
2516                 if (arglist & CAM_ARG_VERBOSE) {
2517                         cam_error_print(device, ccb, CAM_ESF_ALL,
2518                                         CAM_EPF_ALL, stderr);
2519                 }
2520
2521                 error = 1;
2522                 goto scsicmd_bailout;
2523         }
2524
2525         if (atacmd_len && need_res) {
2526                 if (fd_res == 0) {
2527                         buff_decode_visit(&ccb->ataio.res.status, 11, resstr,
2528                                           arg_put, NULL);
2529                         fprintf(stdout, "\n");
2530                 } else {
2531                         fprintf(stdout,
2532                             "%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
2533                             ccb->ataio.res.status,
2534                             ccb->ataio.res.error,
2535                             ccb->ataio.res.lba_low,
2536                             ccb->ataio.res.lba_mid,
2537                             ccb->ataio.res.lba_high,
2538                             ccb->ataio.res.device,
2539                             ccb->ataio.res.lba_low_exp,
2540                             ccb->ataio.res.lba_mid_exp,
2541                             ccb->ataio.res.lba_high_exp,
2542                             ccb->ataio.res.sector_count,
2543                             ccb->ataio.res.sector_count_exp);
2544                         fflush(stdout);
2545                 }
2546         }
2547
2548         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
2549          && (arglist & CAM_ARG_CMD_IN)
2550          && (data_bytes > 0)) {
2551                 if (fd_data == 0) {
2552                         buff_decode_visit(data_ptr, data_bytes, datastr,
2553                                           arg_put, NULL);
2554                         fprintf(stdout, "\n");
2555                 } else {
2556                         ssize_t amt_written;
2557                         int amt_to_write = data_bytes;
2558                         u_int8_t *buf_ptr = data_ptr;
2559
2560                         for (amt_written = 0; (amt_to_write > 0) &&
2561                              (amt_written =write(1, buf_ptr,amt_to_write))> 0;){
2562                                 amt_to_write -= amt_written;
2563                                 buf_ptr += amt_written;
2564                         }
2565                         if (amt_written == -1) {
2566                                 warn("error writing data to stdout");
2567                                 error = 1;
2568                                 goto scsicmd_bailout;
2569                         } else if ((amt_written == 0)
2570                                 && (amt_to_write > 0)) {
2571                                 warnx("only wrote %u bytes out of %u",
2572                                       data_bytes - amt_to_write, data_bytes);
2573                         }
2574                 }
2575         }
2576
2577 scsicmd_bailout:
2578
2579         if ((data_bytes > 0) && (data_ptr != NULL))
2580                 free(data_ptr);
2581
2582         cam_freeccb(ccb);
2583
2584         return(error);
2585 }
2586
2587 static int
2588 camdebug(int argc, char **argv, char *combinedopt)
2589 {
2590         int c, fd;
2591         int bus = -1, target = -1, lun = -1;
2592         char *tstr, *tmpstr = NULL;
2593         union ccb ccb;
2594         int error = 0;
2595
2596         bzero(&ccb, sizeof(union ccb));
2597
2598         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2599                 switch(c) {
2600                 case 'I':
2601                         arglist |= CAM_ARG_DEBUG_INFO;
2602                         ccb.cdbg.flags |= CAM_DEBUG_INFO;
2603                         break;
2604                 case 'P':
2605                         arglist |= CAM_ARG_DEBUG_PERIPH;
2606                         ccb.cdbg.flags |= CAM_DEBUG_PERIPH;
2607                         break;
2608                 case 'S':
2609                         arglist |= CAM_ARG_DEBUG_SUBTRACE;
2610                         ccb.cdbg.flags |= CAM_DEBUG_SUBTRACE;
2611                         break;
2612                 case 'T':
2613                         arglist |= CAM_ARG_DEBUG_TRACE;
2614                         ccb.cdbg.flags |= CAM_DEBUG_TRACE;
2615                         break;
2616                 case 'X':
2617                         arglist |= CAM_ARG_DEBUG_XPT;
2618                         ccb.cdbg.flags |= CAM_DEBUG_XPT;
2619                         break;
2620                 case 'c':
2621                         arglist |= CAM_ARG_DEBUG_CDB;
2622                         ccb.cdbg.flags |= CAM_DEBUG_CDB;
2623                         break;
2624                 default:
2625                         break;
2626                 }
2627         }
2628
2629         if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
2630                 warnx("error opening transport layer device %s", XPT_DEVICE);
2631                 warn("%s", XPT_DEVICE);
2632                 return(1);
2633         }
2634         argc -= optind;
2635         argv += optind;
2636
2637         if (argc <= 0) {
2638                 warnx("you must specify \"off\", \"all\" or a bus,");
2639                 warnx("bus:target, or bus:target:lun");
2640                 close(fd);
2641                 return(1);
2642         }
2643
2644         tstr = *argv;
2645
2646         while (isspace(*tstr) && (*tstr != '\0'))
2647                 tstr++;
2648
2649         if (strncmp(tstr, "off", 3) == 0) {
2650                 ccb.cdbg.flags = CAM_DEBUG_NONE;
2651                 arglist &= ~(CAM_ARG_DEBUG_INFO|CAM_ARG_DEBUG_PERIPH|
2652                              CAM_ARG_DEBUG_TRACE|CAM_ARG_DEBUG_SUBTRACE|
2653                              CAM_ARG_DEBUG_XPT);
2654         } else if (strncmp(tstr, "all", 3) != 0) {
2655                 tmpstr = (char *)strtok(tstr, ":");
2656                 if ((tmpstr != NULL) && (*tmpstr != '\0')){
2657                         bus = strtol(tmpstr, NULL, 0);
2658                         arglist |= CAM_ARG_BUS;
2659                         tmpstr = (char *)strtok(NULL, ":");
2660                         if ((tmpstr != NULL) && (*tmpstr != '\0')){
2661                                 target = strtol(tmpstr, NULL, 0);
2662                                 arglist |= CAM_ARG_TARGET;
2663                                 tmpstr = (char *)strtok(NULL, ":");
2664                                 if ((tmpstr != NULL) && (*tmpstr != '\0')){
2665                                         lun = strtol(tmpstr, NULL, 0);
2666                                         arglist |= CAM_ARG_LUN;
2667                                 }
2668                         }
2669                 } else {
2670                         error = 1;
2671                         warnx("you must specify \"all\", \"off\", or a bus,");
2672                         warnx("bus:target, or bus:target:lun to debug");
2673                 }
2674         }
2675
2676         if (error == 0) {
2677
2678                 ccb.ccb_h.func_code = XPT_DEBUG;
2679                 ccb.ccb_h.path_id = bus;
2680                 ccb.ccb_h.target_id = target;
2681                 ccb.ccb_h.target_lun = lun;
2682
2683                 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
2684                         warn("CAMIOCOMMAND ioctl failed");
2685                         error = 1;
2686                 }
2687
2688                 if (error == 0) {
2689                         if ((ccb.ccb_h.status & CAM_STATUS_MASK) ==
2690                              CAM_FUNC_NOTAVAIL) {
2691                                 warnx("CAM debugging not available");
2692                                 warnx("you need to put options CAMDEBUG in"
2693                                       " your kernel config file!");
2694                                 error = 1;
2695                         } else if ((ccb.ccb_h.status & CAM_STATUS_MASK) !=
2696                                     CAM_REQ_CMP) {
2697                                 warnx("XPT_DEBUG CCB failed with status %#x",
2698                                       ccb.ccb_h.status);
2699                                 error = 1;
2700                         } else {
2701                                 if (ccb.cdbg.flags == CAM_DEBUG_NONE) {
2702                                         fprintf(stderr,
2703                                                 "Debugging turned off\n");
2704                                 } else {
2705                                         fprintf(stderr,
2706                                                 "Debugging enabled for "
2707                                                 "%d:%d:%d\n",
2708                                                 bus, target, lun);
2709                                 }
2710                         }
2711                 }
2712                 close(fd);
2713         }
2714
2715         return(error);
2716 }
2717
2718 static int
2719 tagcontrol(struct cam_device *device, int argc, char **argv,
2720            char *combinedopt)
2721 {
2722         int c;
2723         union ccb *ccb;
2724         int numtags = -1;
2725         int retval = 0;
2726         int quiet = 0;
2727         char pathstr[1024];
2728
2729         ccb = cam_getccb(device);
2730
2731         if (ccb == NULL) {
2732                 warnx("tagcontrol: error allocating ccb");
2733                 return(1);
2734         }
2735
2736         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2737                 switch(c) {
2738                 case 'N':
2739                         numtags = strtol(optarg, NULL, 0);
2740                         if (numtags < 0) {
2741                                 warnx("tag count %d is < 0", numtags);
2742                                 retval = 1;
2743                                 goto tagcontrol_bailout;
2744                         }
2745                         break;
2746                 case 'q':
2747                         quiet++;
2748                         break;
2749                 default:
2750                         break;
2751                 }
2752         }
2753
2754         cam_path_string(device, pathstr, sizeof(pathstr));
2755
2756         if (numtags >= 0) {
2757                 bzero(&(&ccb->ccb_h)[1],
2758                       sizeof(struct ccb_relsim) - sizeof(struct ccb_hdr));
2759                 ccb->ccb_h.func_code = XPT_REL_SIMQ;
2760                 ccb->ccb_h.flags = CAM_DEV_QFREEZE;
2761                 ccb->crs.release_flags = RELSIM_ADJUST_OPENINGS;
2762                 ccb->crs.openings = numtags;
2763
2764
2765                 if (cam_send_ccb(device, ccb) < 0) {
2766                         perror("error sending XPT_REL_SIMQ CCB");
2767                         retval = 1;
2768                         goto tagcontrol_bailout;
2769                 }
2770
2771                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2772                         warnx("XPT_REL_SIMQ CCB failed");
2773                         cam_error_print(device, ccb, CAM_ESF_ALL,
2774                                         CAM_EPF_ALL, stderr);
2775                         retval = 1;
2776                         goto tagcontrol_bailout;
2777                 }
2778
2779
2780                 if (quiet == 0)
2781                         fprintf(stdout, "%stagged openings now %d\n",
2782                                 pathstr, ccb->crs.openings);
2783         }
2784
2785         bzero(&(&ccb->ccb_h)[1],
2786               sizeof(struct ccb_getdevstats) - sizeof(struct ccb_hdr));
2787
2788         ccb->ccb_h.func_code = XPT_GDEV_STATS;
2789
2790         if (cam_send_ccb(device, ccb) < 0) {
2791                 perror("error sending XPT_GDEV_STATS CCB");
2792                 retval = 1;
2793                 goto tagcontrol_bailout;
2794         }
2795
2796         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2797                 warnx("XPT_GDEV_STATS CCB failed");
2798                 cam_error_print(device, ccb, CAM_ESF_ALL,
2799                                 CAM_EPF_ALL, stderr);
2800                 retval = 1;
2801                 goto tagcontrol_bailout;
2802         }
2803
2804         if (arglist & CAM_ARG_VERBOSE) {
2805                 fprintf(stdout, "%s", pathstr);
2806                 fprintf(stdout, "dev_openings  %d\n", ccb->cgds.dev_openings);
2807                 fprintf(stdout, "%s", pathstr);
2808                 fprintf(stdout, "dev_active    %d\n", ccb->cgds.dev_active);
2809                 fprintf(stdout, "%s", pathstr);
2810                 fprintf(stdout, "devq_openings %d\n", ccb->cgds.devq_openings);
2811                 fprintf(stdout, "%s", pathstr);
2812                 fprintf(stdout, "devq_queued   %d\n", ccb->cgds.devq_queued);
2813                 fprintf(stdout, "%s", pathstr);
2814                 fprintf(stdout, "held          %d\n", ccb->cgds.held);
2815                 fprintf(stdout, "%s", pathstr);
2816                 fprintf(stdout, "mintags       %d\n", ccb->cgds.mintags);
2817                 fprintf(stdout, "%s", pathstr);
2818                 fprintf(stdout, "maxtags       %d\n", ccb->cgds.maxtags);
2819         } else {
2820                 if (quiet == 0) {
2821                         fprintf(stdout, "%s", pathstr);
2822                         fprintf(stdout, "device openings: ");
2823                 }
2824                 fprintf(stdout, "%d\n", ccb->cgds.dev_openings +
2825                         ccb->cgds.dev_active);
2826         }
2827
2828 tagcontrol_bailout:
2829
2830         cam_freeccb(ccb);
2831         return(retval);
2832 }
2833
2834 static void
2835 cts_print(struct cam_device *device, struct ccb_trans_settings *cts)
2836 {
2837         char pathstr[1024];
2838
2839         cam_path_string(device, pathstr, sizeof(pathstr));
2840
2841         if (cts->transport == XPORT_SPI) {
2842                 struct ccb_trans_settings_spi *spi =
2843                     &cts->xport_specific.spi;
2844
2845                 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) {
2846
2847                         fprintf(stdout, "%ssync parameter: %d\n", pathstr,
2848                                 spi->sync_period);
2849
2850                         if (spi->sync_offset != 0) {
2851                                 u_int freq;
2852
2853                                 freq = scsi_calc_syncsrate(spi->sync_period);
2854                                 fprintf(stdout, "%sfrequency: %d.%03dMHz\n",
2855                                         pathstr, freq / 1000, freq % 1000);
2856                         }
2857                 }
2858
2859                 if (spi->valid & CTS_SPI_VALID_SYNC_OFFSET) {
2860                         fprintf(stdout, "%soffset: %d\n", pathstr,
2861                             spi->sync_offset);
2862                 }
2863
2864                 if (spi->valid & CTS_SPI_VALID_BUS_WIDTH) {
2865                         fprintf(stdout, "%sbus width: %d bits\n", pathstr,
2866                                 (0x01 << spi->bus_width) * 8);
2867                 }
2868
2869                 if (spi->valid & CTS_SPI_VALID_DISC) {
2870                         fprintf(stdout, "%sdisconnection is %s\n", pathstr,
2871                                 (spi->flags & CTS_SPI_FLAGS_DISC_ENB) ?
2872                                 "enabled" : "disabled");
2873                 }
2874         }
2875         if (cts->transport == XPORT_ATA) {
2876                 struct ccb_trans_settings_ata *ata =
2877                     &cts->xport_specific.ata;
2878
2879                 if ((ata->valid & CTS_ATA_VALID_MODE) != 0) {
2880                         fprintf(stdout, "%sATA mode: %s\n", pathstr,
2881                                 ata_mode2string(ata->mode));
2882                 }
2883                 if ((ata->valid & CTS_ATA_VALID_ATAPI) != 0) {
2884                         fprintf(stdout, "%sATAPI packet length: %d\n", pathstr,
2885                                 ata->atapi);
2886                 }
2887                 if ((ata->valid & CTS_ATA_VALID_BYTECOUNT) != 0) {
2888                         fprintf(stdout, "%sPIO transaction length: %d\n",
2889                                 pathstr, ata->bytecount);
2890                 }
2891         }
2892         if (cts->transport == XPORT_SATA) {
2893                 struct ccb_trans_settings_sata *sata =
2894                     &cts->xport_specific.sata;
2895
2896                 if ((sata->valid & CTS_SATA_VALID_REVISION) != 0) {
2897                         fprintf(stdout, "%sSATA revision: %d.x\n", pathstr,
2898                                 sata->revision);
2899                 }
2900                 if ((sata->valid & CTS_SATA_VALID_MODE) != 0) {
2901                         fprintf(stdout, "%sATA mode: %s\n", pathstr,
2902                                 ata_mode2string(sata->mode));
2903                 }
2904                 if ((sata->valid & CTS_SATA_VALID_ATAPI) != 0) {
2905                         fprintf(stdout, "%sATAPI packet length: %d\n", pathstr,
2906                                 sata->atapi);
2907                 }
2908                 if ((sata->valid & CTS_SATA_VALID_BYTECOUNT) != 0) {
2909                         fprintf(stdout, "%sPIO transaction length: %d\n",
2910                                 pathstr, sata->bytecount);
2911                 }
2912                 if ((sata->valid & CTS_SATA_VALID_PM) != 0) {
2913                         fprintf(stdout, "%sPMP presence: %d\n", pathstr,
2914                                 sata->pm_present);
2915                 }
2916                 if ((sata->valid & CTS_SATA_VALID_TAGS) != 0) {
2917                         fprintf(stdout, "%sNumber of tags: %d\n", pathstr,
2918                                 sata->tags);
2919                 }
2920                 if ((sata->valid & CTS_SATA_VALID_CAPS) != 0) {
2921                         fprintf(stdout, "%sSATA capabilities: %08x\n", pathstr,
2922                                 sata->caps);
2923                 }
2924         }
2925         if (cts->protocol == PROTO_SCSI) {
2926                 struct ccb_trans_settings_scsi *scsi=
2927                     &cts->proto_specific.scsi;
2928
2929                 if (scsi->valid & CTS_SCSI_VALID_TQ) {
2930                         fprintf(stdout, "%stagged queueing is %s\n", pathstr,
2931                                 (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) ?
2932                                 "enabled" : "disabled");
2933                 }
2934         }
2935
2936 }
2937
2938 /*
2939  * Get a path inquiry CCB for the specified device.
2940  */
2941 static int
2942 get_cpi(struct cam_device *device, struct ccb_pathinq *cpi)
2943 {
2944         union ccb *ccb;
2945         int retval = 0;
2946
2947         ccb = cam_getccb(device);
2948         if (ccb == NULL) {
2949                 warnx("get_cpi: couldn't allocate CCB");
2950                 return(1);
2951         }
2952         bzero(&(&ccb->ccb_h)[1],
2953               sizeof(struct ccb_pathinq) - sizeof(struct ccb_hdr));
2954         ccb->ccb_h.func_code = XPT_PATH_INQ;
2955         if (cam_send_ccb(device, ccb) < 0) {
2956                 warn("get_cpi: error sending Path Inquiry CCB");
2957                 if (arglist & CAM_ARG_VERBOSE)
2958                         cam_error_print(device, ccb, CAM_ESF_ALL,
2959                                         CAM_EPF_ALL, stderr);
2960                 retval = 1;
2961                 goto get_cpi_bailout;
2962         }
2963         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2964                 if (arglist & CAM_ARG_VERBOSE)
2965                         cam_error_print(device, ccb, CAM_ESF_ALL,
2966                                         CAM_EPF_ALL, stderr);
2967                 retval = 1;
2968                 goto get_cpi_bailout;
2969         }
2970         bcopy(&ccb->cpi, cpi, sizeof(struct ccb_pathinq));
2971
2972 get_cpi_bailout:
2973         cam_freeccb(ccb);
2974         return(retval);
2975 }
2976
2977 /*
2978  * Get a get device CCB for the specified device.
2979  */
2980 static int
2981 get_cgd(struct cam_device *device, struct ccb_getdev *cgd)
2982 {
2983         union ccb *ccb;
2984         int retval = 0;
2985
2986         ccb = cam_getccb(device);
2987         if (ccb == NULL) {
2988                 warnx("get_cgd: couldn't allocate CCB");
2989                 return(1);
2990         }
2991         bzero(&(&ccb->ccb_h)[1],
2992               sizeof(struct ccb_pathinq) - sizeof(struct ccb_hdr));
2993         ccb->ccb_h.func_code = XPT_GDEV_TYPE;
2994         if (cam_send_ccb(device, ccb) < 0) {
2995                 warn("get_cgd: error sending Path Inquiry CCB");
2996                 if (arglist & CAM_ARG_VERBOSE)
2997                         cam_error_print(device, ccb, CAM_ESF_ALL,
2998                                         CAM_EPF_ALL, stderr);
2999                 retval = 1;
3000                 goto get_cgd_bailout;
3001         }
3002         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3003                 if (arglist & CAM_ARG_VERBOSE)
3004                         cam_error_print(device, ccb, CAM_ESF_ALL,
3005                                         CAM_EPF_ALL, stderr);
3006                 retval = 1;
3007                 goto get_cgd_bailout;
3008         }
3009         bcopy(&ccb->cgd, cgd, sizeof(struct ccb_getdev));
3010
3011 get_cgd_bailout:
3012         cam_freeccb(ccb);
3013         return(retval);
3014 }
3015
3016 static void
3017 cpi_print(struct ccb_pathinq *cpi)
3018 {
3019         char adapter_str[1024];
3020         int i;
3021
3022         snprintf(adapter_str, sizeof(adapter_str),
3023                  "%s%d:", cpi->dev_name, cpi->unit_number);
3024
3025         fprintf(stdout, "%s SIM/HBA version: %d\n", adapter_str,
3026                 cpi->version_num);
3027
3028         for (i = 1; i < 0xff; i = i << 1) {
3029                 const char *str;
3030
3031                 if ((i & cpi->hba_inquiry) == 0)
3032                         continue;
3033
3034                 fprintf(stdout, "%s supports ", adapter_str);
3035
3036                 switch(i) {
3037                 case PI_MDP_ABLE:
3038                         str = "MDP message";
3039                         break;
3040                 case PI_WIDE_32:
3041                         str = "32 bit wide SCSI";
3042                         break;
3043                 case PI_WIDE_16:
3044                         str = "16 bit wide SCSI";
3045                         break;
3046                 case PI_SDTR_ABLE:
3047                         str = "SDTR message";
3048                         break;
3049                 case PI_LINKED_CDB:
3050                         str = "linked CDBs";
3051                         break;
3052                 case PI_TAG_ABLE:
3053                         str = "tag queue messages";
3054                         break;
3055                 case PI_SOFT_RST:
3056                         str = "soft reset alternative";
3057                         break;
3058                 case PI_SATAPM:
3059                         str = "SATA Port Multiplier";
3060                         break;
3061                 default:
3062                         str = "unknown PI bit set";
3063                         break;
3064                 }
3065                 fprintf(stdout, "%s\n", str);
3066         }
3067
3068         for (i = 1; i < 0xff; i = i << 1) {
3069                 const char *str;
3070
3071                 if ((i & cpi->hba_misc) == 0)
3072                         continue;
3073
3074                 fprintf(stdout, "%s ", adapter_str);
3075
3076                 switch(i) {
3077                 case PIM_SCANHILO:
3078                         str = "bus scans from high ID to low ID";
3079                         break;
3080                 case PIM_NOREMOVE:
3081                         str = "removable devices not included in scan";
3082                         break;
3083                 case PIM_NOINITIATOR:
3084                         str = "initiator role not supported";
3085                         break;
3086                 case PIM_NOBUSRESET:
3087                         str = "user has disabled initial BUS RESET or"
3088                               " controller is in target/mixed mode";
3089                         break;
3090                 case PIM_NO_6_BYTE:
3091                         str = "do not send 6-byte commands";
3092                         break;
3093                 case PIM_SEQSCAN:
3094                         str = "scan bus sequentially";
3095                         break;
3096                 default:
3097                         str = "unknown PIM bit set";
3098                         break;
3099                 }
3100                 fprintf(stdout, "%s\n", str);
3101         }
3102
3103         for (i = 1; i < 0xff; i = i << 1) {
3104                 const char *str;
3105
3106                 if ((i & cpi->target_sprt) == 0)
3107                         continue;
3108
3109                 fprintf(stdout, "%s supports ", adapter_str);
3110                 switch(i) {
3111                 case PIT_PROCESSOR:
3112                         str = "target mode processor mode";
3113                         break;
3114                 case PIT_PHASE:
3115                         str = "target mode phase cog. mode";
3116                         break;
3117                 case PIT_DISCONNECT:
3118                         str = "disconnects in target mode";
3119                         break;
3120                 case PIT_TERM_IO:
3121                         str = "terminate I/O message in target mode";
3122                         break;
3123                 case PIT_GRP_6:
3124                         str = "group 6 commands in target mode";
3125                         break;
3126                 case PIT_GRP_7:
3127                         str = "group 7 commands in target mode";
3128                         break;
3129                 default:
3130                         str = "unknown PIT bit set";
3131                         break;
3132                 }
3133
3134                 fprintf(stdout, "%s\n", str);
3135         }
3136         fprintf(stdout, "%s HBA engine count: %d\n", adapter_str,
3137                 cpi->hba_eng_cnt);
3138         fprintf(stdout, "%s maximum target: %d\n", adapter_str,
3139                 cpi->max_target);
3140         fprintf(stdout, "%s maximum LUN: %d\n", adapter_str,
3141                 cpi->max_lun);
3142         fprintf(stdout, "%s highest path ID in subsystem: %d\n",
3143                 adapter_str, cpi->hpath_id);
3144         fprintf(stdout, "%s initiator ID: %d\n", adapter_str,
3145                 cpi->initiator_id);
3146         fprintf(stdout, "%s SIM vendor: %s\n", adapter_str, cpi->sim_vid);
3147         fprintf(stdout, "%s HBA vendor: %s\n", adapter_str, cpi->hba_vid);
3148         fprintf(stdout, "%s HBA vendor ID: 0x%04x\n",
3149             adapter_str, cpi->hba_vendor);
3150         fprintf(stdout, "%s HBA device ID: 0x%04x\n",
3151             adapter_str, cpi->hba_device);
3152         fprintf(stdout, "%s HBA subvendor ID: 0x%04x\n",
3153             adapter_str, cpi->hba_subvendor);
3154         fprintf(stdout, "%s HBA subdevice ID: 0x%04x\n",
3155             adapter_str, cpi->hba_subdevice);
3156         fprintf(stdout, "%s bus ID: %d\n", adapter_str, cpi->bus_id);
3157         fprintf(stdout, "%s base transfer speed: ", adapter_str);
3158         if (cpi->base_transfer_speed > 1000)
3159                 fprintf(stdout, "%d.%03dMB/sec\n",
3160                         cpi->base_transfer_speed / 1000,
3161                         cpi->base_transfer_speed % 1000);
3162         else
3163                 fprintf(stdout, "%dKB/sec\n",
3164                         (cpi->base_transfer_speed % 1000) * 1000);
3165         fprintf(stdout, "%s maximum transfer size: %u bytes\n",
3166             adapter_str, cpi->maxio);
3167 }
3168
3169 static int
3170 get_print_cts(struct cam_device *device, int user_settings, int quiet,
3171               struct ccb_trans_settings *cts)
3172 {
3173         int retval;
3174         union ccb *ccb;
3175
3176         retval = 0;
3177         ccb = cam_getccb(device);
3178
3179         if (ccb == NULL) {
3180                 warnx("get_print_cts: error allocating ccb");
3181                 return(1);
3182         }
3183
3184         bzero(&(&ccb->ccb_h)[1],
3185               sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr));
3186
3187         ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
3188
3189         if (user_settings == 0)
3190                 ccb->cts.type = CTS_TYPE_CURRENT_SETTINGS;
3191         else
3192                 ccb->cts.type = CTS_TYPE_USER_SETTINGS;
3193
3194         if (cam_send_ccb(device, ccb) < 0) {
3195                 perror("error sending XPT_GET_TRAN_SETTINGS CCB");
3196                 if (arglist & CAM_ARG_VERBOSE)
3197                         cam_error_print(device, ccb, CAM_ESF_ALL,
3198                                         CAM_EPF_ALL, stderr);
3199                 retval = 1;
3200                 goto get_print_cts_bailout;
3201         }
3202
3203         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3204                 warnx("XPT_GET_TRANS_SETTINGS CCB failed");
3205                 if (arglist & CAM_ARG_VERBOSE)
3206                         cam_error_print(device, ccb, CAM_ESF_ALL,
3207                                         CAM_EPF_ALL, stderr);
3208                 retval = 1;
3209                 goto get_print_cts_bailout;
3210         }
3211
3212         if (quiet == 0)
3213                 cts_print(device, &ccb->cts);
3214
3215         if (cts != NULL)
3216                 bcopy(&ccb->cts, cts, sizeof(struct ccb_trans_settings));
3217
3218 get_print_cts_bailout:
3219
3220         cam_freeccb(ccb);
3221
3222         return(retval);
3223 }
3224
3225 static int
3226 ratecontrol(struct cam_device *device, int retry_count, int timeout,
3227             int argc, char **argv, char *combinedopt)
3228 {
3229         int c;
3230         union ccb *ccb;
3231         int user_settings = 0;
3232         int retval = 0;
3233         int disc_enable = -1, tag_enable = -1;
3234         int mode = -1;
3235         int offset = -1;
3236         double syncrate = -1;
3237         int bus_width = -1;
3238         int quiet = 0;
3239         int change_settings = 0, send_tur = 0;
3240         struct ccb_pathinq cpi;
3241
3242         ccb = cam_getccb(device);
3243         if (ccb == NULL) {
3244                 warnx("ratecontrol: error allocating ccb");
3245                 return(1);
3246         }
3247         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3248                 switch(c){
3249                 case 'a':
3250                         send_tur = 1;
3251                         break;
3252                 case 'c':
3253                         user_settings = 0;
3254                         break;
3255                 case 'D':
3256                         if (strncasecmp(optarg, "enable", 6) == 0)
3257                                 disc_enable = 1;
3258                         else if (strncasecmp(optarg, "disable", 7) == 0)
3259                                 disc_enable = 0;
3260                         else {
3261                                 warnx("-D argument \"%s\" is unknown", optarg);
3262                                 retval = 1;
3263                                 goto ratecontrol_bailout;
3264                         }
3265                         change_settings = 1;
3266                         break;
3267                 case 'M':
3268                         mode = ata_string2mode(optarg);
3269                         if (mode < 0) {
3270                                 warnx("unknown mode '%s'", optarg);
3271                                 retval = 1;
3272                                 goto ratecontrol_bailout;
3273                         }
3274                         change_settings = 1;
3275                         break;
3276                 case 'O':
3277                         offset = strtol(optarg, NULL, 0);
3278                         if (offset < 0) {
3279                                 warnx("offset value %d is < 0", offset);
3280                                 retval = 1;
3281                                 goto ratecontrol_bailout;
3282                         }
3283                         change_settings = 1;
3284                         break;
3285                 case 'q':
3286                         quiet++;
3287                         break;
3288                 case 'R':
3289                         syncrate = atof(optarg);
3290                         if (syncrate < 0) {
3291                                 warnx("sync rate %f is < 0", syncrate);
3292                                 retval = 1;
3293                                 goto ratecontrol_bailout;
3294                         }
3295                         change_settings = 1;
3296                         break;
3297                 case 'T':
3298                         if (strncasecmp(optarg, "enable", 6) == 0)
3299                                 tag_enable = 1;
3300                         else if (strncasecmp(optarg, "disable", 7) == 0)
3301                                 tag_enable = 0;
3302                         else {
3303                                 warnx("-T argument \"%s\" is unknown", optarg);
3304                                 retval = 1;
3305                                 goto ratecontrol_bailout;
3306                         }
3307                         change_settings = 1;
3308                         break;
3309                 case 'U':
3310                         user_settings = 1;
3311                         break;
3312                 case 'W':
3313                         bus_width = strtol(optarg, NULL, 0);
3314                         if (bus_width < 0) {
3315                                 warnx("bus width %d is < 0", bus_width);
3316                                 retval = 1;
3317                                 goto ratecontrol_bailout;
3318                         }
3319                         change_settings = 1;
3320                         break;
3321                 default:
3322                         break;
3323                 }
3324         }
3325         bzero(&(&ccb->ccb_h)[1],
3326               sizeof(struct ccb_pathinq) - sizeof(struct ccb_hdr));
3327         /*
3328          * Grab path inquiry information, so we can determine whether
3329          * or not the initiator is capable of the things that the user
3330          * requests.
3331          */
3332         ccb->ccb_h.func_code = XPT_PATH_INQ;
3333         if (cam_send_ccb(device, ccb) < 0) {
3334                 perror("error sending XPT_PATH_INQ CCB");
3335                 if (arglist & CAM_ARG_VERBOSE) {
3336                         cam_error_print(device, ccb, CAM_ESF_ALL,
3337                                         CAM_EPF_ALL, stderr);
3338                 }
3339                 retval = 1;
3340                 goto ratecontrol_bailout;
3341         }
3342         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3343                 warnx("XPT_PATH_INQ CCB failed");
3344                 if (arglist & CAM_ARG_VERBOSE) {
3345                         cam_error_print(device, ccb, CAM_ESF_ALL,
3346                                         CAM_EPF_ALL, stderr);
3347                 }
3348                 retval = 1;
3349                 goto ratecontrol_bailout;
3350         }
3351         bcopy(&ccb->cpi, &cpi, sizeof(struct ccb_pathinq));
3352         bzero(&(&ccb->ccb_h)[1],
3353               sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr));
3354         if (quiet == 0) {
3355                 fprintf(stdout, "%s parameters:\n",
3356                     user_settings ? "User" : "Current");
3357         }
3358         retval = get_print_cts(device, user_settings, quiet, &ccb->cts);
3359         if (retval != 0)
3360                 goto ratecontrol_bailout;
3361
3362         if (arglist & CAM_ARG_VERBOSE)
3363                 cpi_print(&cpi);
3364
3365         if (change_settings) {
3366                 int didsettings = 0;
3367                 struct ccb_trans_settings_spi *spi = NULL;
3368                 struct ccb_trans_settings_ata *ata = NULL;
3369                 struct ccb_trans_settings_sata *sata = NULL;
3370                 struct ccb_trans_settings_scsi *scsi = NULL;
3371
3372                 if (ccb->cts.transport == XPORT_SPI)
3373                         spi = &ccb->cts.xport_specific.spi;
3374                 if (ccb->cts.transport == XPORT_ATA)
3375                         ata = &ccb->cts.xport_specific.ata;
3376                 if (ccb->cts.transport == XPORT_SATA)
3377                         sata = &ccb->cts.xport_specific.sata;
3378                 if (ccb->cts.protocol == PROTO_SCSI)
3379                         scsi = &ccb->cts.proto_specific.scsi;
3380                 ccb->cts.xport_specific.valid = 0;
3381                 ccb->cts.proto_specific.valid = 0;
3382                 if (spi && disc_enable != -1) {
3383                         spi->valid |= CTS_SPI_VALID_DISC;
3384                         if (disc_enable == 0)
3385                                 spi->flags &= ~CTS_SPI_FLAGS_DISC_ENB;
3386                         else
3387                                 spi->flags |= CTS_SPI_FLAGS_DISC_ENB;
3388                         didsettings++;
3389                 }
3390                 if (scsi && tag_enable != -1) {
3391                         if ((cpi.hba_inquiry & PI_TAG_ABLE) == 0) {
3392                                 warnx("HBA does not support tagged queueing, "
3393                                       "so you cannot modify tag settings");
3394                                 retval = 1;
3395                                 goto ratecontrol_bailout;
3396                         }
3397                         scsi->valid |= CTS_SCSI_VALID_TQ;
3398                         if (tag_enable == 0)
3399                                 scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB;
3400                         else
3401                                 scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB;
3402                         didsettings++;
3403                 }
3404                 if (spi && offset != -1) {
3405                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
3406                                 warnx("HBA is not capable of changing offset");
3407                                 retval = 1;
3408                                 goto ratecontrol_bailout;
3409                         }
3410                         spi->valid |= CTS_SPI_VALID_SYNC_OFFSET;
3411                         spi->sync_offset = offset;
3412                         didsettings++;
3413                 }
3414                 if (spi && syncrate != -1) {
3415                         int prelim_sync_period;
3416
3417                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
3418                                 warnx("HBA is not capable of changing "
3419                                       "transfer rates");
3420                                 retval = 1;
3421                                 goto ratecontrol_bailout;
3422                         }
3423                         spi->valid |= CTS_SPI_VALID_SYNC_RATE;
3424                         /*
3425                          * The sync rate the user gives us is in MHz.
3426                          * We need to translate it into KHz for this
3427                          * calculation.
3428                          */
3429                         syncrate *= 1000;
3430                         /*
3431                          * Next, we calculate a "preliminary" sync period
3432                          * in tenths of a nanosecond.
3433                          */
3434                         if (syncrate == 0)
3435                                 prelim_sync_period = 0;
3436                         else
3437                                 prelim_sync_period = 10000000 / syncrate;
3438                         spi->sync_period =
3439                                 scsi_calc_syncparam(prelim_sync_period);
3440                         didsettings++;
3441                 }
3442                 if (sata && syncrate != -1) {
3443                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
3444                                 warnx("HBA is not capable of changing "
3445                                       "transfer rates");
3446                                 retval = 1;
3447                                 goto ratecontrol_bailout;
3448                         }
3449                         sata->revision = ata_speed2revision(syncrate * 100);
3450                         if (sata->revision < 0) {
3451                                 warnx("Invalid rate %f", syncrate);
3452                                 retval = 1;
3453                                 goto ratecontrol_bailout;
3454                         }
3455                         sata->valid |= CTS_SATA_VALID_REVISION;
3456                         didsettings++;
3457                 }
3458                 if ((ata || sata) && mode != -1) {
3459                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
3460                                 warnx("HBA is not capable of changing "
3461                                       "transfer rates");
3462                                 retval = 1;
3463                                 goto ratecontrol_bailout;
3464                         }
3465                         if (ata) {
3466                                 ata->mode = mode;
3467                                 ata->valid |= CTS_ATA_VALID_MODE;
3468                         } else {
3469                                 sata->mode = mode;
3470                                 sata->valid |= CTS_SATA_VALID_MODE;
3471                         }
3472                         didsettings++;
3473                 }
3474                 /*
3475                  * The bus_width argument goes like this:
3476                  * 0 == 8 bit
3477                  * 1 == 16 bit
3478                  * 2 == 32 bit
3479                  * Therefore, if you shift the number of bits given on the
3480                  * command line right by 4, you should get the correct
3481                  * number.
3482                  */
3483                 if (spi && bus_width != -1) {
3484                         /*
3485                          * We might as well validate things here with a
3486                          * decipherable error message, rather than what
3487                          * will probably be an indecipherable error message
3488                          * by the time it gets back to us.
3489                          */
3490                         if ((bus_width == 16)
3491                          && ((cpi.hba_inquiry & PI_WIDE_16) == 0)) {
3492                                 warnx("HBA does not support 16 bit bus width");
3493                                 retval = 1;
3494                                 goto ratecontrol_bailout;
3495                         } else if ((bus_width == 32)
3496                                 && ((cpi.hba_inquiry & PI_WIDE_32) == 0)) {
3497                                 warnx("HBA does not support 32 bit bus width");
3498                                 retval = 1;
3499                                 goto ratecontrol_bailout;
3500                         } else if ((bus_width != 8)
3501                                 && (bus_width != 16)
3502                                 && (bus_width != 32)) {
3503                                 warnx("Invalid bus width %d", bus_width);
3504                                 retval = 1;
3505                                 goto ratecontrol_bailout;
3506                         }
3507                         spi->valid |= CTS_SPI_VALID_BUS_WIDTH;
3508                         spi->bus_width = bus_width >> 4;
3509                         didsettings++;
3510                 }
3511                 if  (didsettings == 0) {
3512                         goto ratecontrol_bailout;
3513                 }
3514                 if  (!user_settings && (ata || sata)) {
3515                         warnx("You can modify only user settings for ATA/SATA");
3516                         retval = 1;
3517                         goto ratecontrol_bailout;
3518                 }
3519                 ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
3520                 if (cam_send_ccb(device, ccb) < 0) {
3521                         perror("error sending XPT_SET_TRAN_SETTINGS CCB");
3522                         if (arglist & CAM_ARG_VERBOSE) {
3523                                 cam_error_print(device, ccb, CAM_ESF_ALL,
3524                                                 CAM_EPF_ALL, stderr);
3525                         }
3526                         retval = 1;
3527                         goto ratecontrol_bailout;
3528                 }
3529                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3530                         warnx("XPT_SET_TRANS_SETTINGS CCB failed");
3531                         if (arglist & CAM_ARG_VERBOSE) {
3532                                 cam_error_print(device, ccb, CAM_ESF_ALL,
3533                                                 CAM_EPF_ALL, stderr);
3534                         }
3535                         retval = 1;
3536                         goto ratecontrol_bailout;
3537                 }
3538         }
3539         if (send_tur) {
3540                 retval = testunitready(device, retry_count, timeout,
3541                                        (arglist & CAM_ARG_VERBOSE) ? 0 : 1);
3542                 /*
3543                  * If the TUR didn't succeed, just bail.
3544                  */
3545                 if (retval != 0) {
3546                         if (quiet == 0)
3547                                 fprintf(stderr, "Test Unit Ready failed\n");
3548                         goto ratecontrol_bailout;
3549                 }
3550                 /*
3551                  * If the user wants things quiet, there's no sense in
3552                  * getting the transfer settings, if we're not going
3553                  * to print them.
3554                  */
3555                 if (quiet != 0)
3556                         goto ratecontrol_bailout;
3557                 fprintf(stdout, "New parameters:\n");
3558                 retval = get_print_cts(device, user_settings, 0, NULL);
3559         }
3560
3561 ratecontrol_bailout:
3562         cam_freeccb(ccb);
3563         return(retval);
3564 }
3565
3566 static int
3567 scsiformat(struct cam_device *device, int argc, char **argv,
3568            char *combinedopt, int retry_count, int timeout)
3569 {
3570         union ccb *ccb;
3571         int c;
3572         int ycount = 0, quiet = 0;
3573         int error = 0, response = 0, retval = 0;
3574         int use_timeout = 10800 * 1000;
3575         int immediate = 1;
3576         struct format_defect_list_header fh;
3577         u_int8_t *data_ptr = NULL;
3578         u_int32_t dxfer_len = 0;
3579         u_int8_t byte2 = 0;
3580         int num_warnings = 0;
3581         int reportonly = 0;
3582
3583         ccb = cam_getccb(device);
3584
3585         if (ccb == NULL) {
3586                 warnx("scsiformat: error allocating ccb");
3587                 return(1);
3588         }
3589
3590         bzero(&(&ccb->ccb_h)[1],
3591               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
3592
3593         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3594                 switch(c) {
3595                 case 'q':
3596                         quiet++;
3597                         break;
3598                 case 'r':
3599                         reportonly = 1;
3600                         break;
3601                 case 'w':
3602                         immediate = 0;
3603                         break;
3604                 case 'y':
3605                         ycount++;
3606                         break;
3607                 }
3608         }
3609
3610         if (reportonly)
3611                 goto doreport;
3612
3613         if (quiet == 0) {
3614                 fprintf(stdout, "You are about to REMOVE ALL DATA from the "
3615                         "following device:\n");
3616
3617                 error = scsidoinquiry(device, argc, argv, combinedopt,
3618                                       retry_count, timeout);
3619
3620                 if (error != 0) {
3621                         warnx("scsiformat: error sending inquiry");
3622                         goto scsiformat_bailout;
3623                 }
3624         }
3625
3626         if (ycount == 0) {
3627
3628                 do {
3629                         char str[1024];
3630
3631                         fprintf(stdout, "Are you SURE you want to do "
3632                                 "this? (yes/no) ");
3633
3634                         if (fgets(str, sizeof(str), stdin) != NULL) {
3635
3636                                 if (strncasecmp(str, "yes", 3) == 0)
3637                                         response = 1;
3638                                 else if (strncasecmp(str, "no", 2) == 0)
3639                                         response = -1;
3640                                 else {
3641                                         fprintf(stdout, "Please answer"
3642                                                 " \"yes\" or \"no\"\n");
3643                                 }
3644                         }
3645                 } while (response == 0);
3646
3647                 if (response == -1) {
3648                         error = 1;
3649                         goto scsiformat_bailout;
3650                 }
3651         }
3652
3653         if (timeout != 0)
3654                 use_timeout = timeout;
3655
3656         if (quiet == 0) {
3657                 fprintf(stdout, "Current format timeout is %d seconds\n",
3658                         use_timeout / 1000);
3659         }
3660
3661         /*
3662          * If the user hasn't disabled questions and didn't specify a
3663          * timeout on the command line, ask them if they want the current
3664          * timeout.
3665          */
3666         if ((ycount == 0)
3667          && (timeout == 0)) {
3668                 char str[1024];
3669                 int new_timeout = 0;
3670
3671                 fprintf(stdout, "Enter new timeout in seconds or press\n"
3672                         "return to keep the current timeout [%d] ",
3673                         use_timeout / 1000);
3674
3675                 if (fgets(str, sizeof(str), stdin) != NULL) {
3676                         if (str[0] != '\0')
3677                                 new_timeout = atoi(str);
3678                 }
3679
3680                 if (new_timeout != 0) {
3681                         use_timeout = new_timeout * 1000;
3682                         fprintf(stdout, "Using new timeout value %d\n",
3683                                 use_timeout / 1000);
3684                 }
3685         }
3686
3687         /*
3688          * Keep this outside the if block below to silence any unused
3689          * variable warnings.
3690          */
3691         bzero(&fh, sizeof(fh));
3692
3693         /*
3694          * If we're in immediate mode, we've got to include the format
3695          * header
3696          */
3697         if (immediate != 0) {
3698                 fh.byte2 = FU_DLH_IMMED;
3699                 data_ptr = (u_int8_t *)&fh;
3700                 dxfer_len = sizeof(fh);
3701                 byte2 = FU_FMT_DATA;
3702         } else if (quiet == 0) {
3703                 fprintf(stdout, "Formatting...");
3704                 fflush(stdout);
3705         }
3706
3707         scsi_format_unit(&ccb->csio,
3708                          /* retries */ retry_count,
3709                          /* cbfcnp */ NULL,
3710                          /* tag_action */ MSG_SIMPLE_Q_TAG,
3711                          /* byte2 */ byte2,
3712                          /* ileave */ 0,
3713                          /* data_ptr */ data_ptr,
3714                          /* dxfer_len */ dxfer_len,
3715                          /* sense_len */ SSD_FULL_SIZE,
3716                          /* timeout */ use_timeout);
3717
3718         /* Disable freezing the device queue */
3719         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
3720
3721         if (arglist & CAM_ARG_ERR_RECOVER)
3722                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
3723
3724         if (((retval = cam_send_ccb(device, ccb)) < 0)
3725          || ((immediate == 0)
3726            && ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP))) {
3727                 const char errstr[] = "error sending format command";
3728
3729                 if (retval < 0)
3730                         warn(errstr);
3731                 else
3732                         warnx(errstr);
3733
3734                 if (arglist & CAM_ARG_VERBOSE) {
3735                         cam_error_print(device, ccb, CAM_ESF_ALL,
3736                                         CAM_EPF_ALL, stderr);
3737                 }
3738                 error = 1;
3739                 goto scsiformat_bailout;
3740         }
3741
3742         /*
3743          * If we ran in non-immediate mode, we already checked for errors
3744          * above and printed out any necessary information.  If we're in
3745          * immediate mode, we need to loop through and get status
3746          * information periodically.
3747          */
3748         if (immediate == 0) {
3749                 if (quiet == 0) {
3750                         fprintf(stdout, "Format Complete\n");
3751                 }
3752                 goto scsiformat_bailout;
3753         }
3754
3755 doreport:
3756         do {
3757                 cam_status status;
3758
3759                 bzero(&(&ccb->ccb_h)[1],
3760                       sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
3761
3762                 /*
3763                  * There's really no need to do error recovery or
3764                  * retries here, since we're just going to sit in a
3765                  * loop and wait for the device to finish formatting.
3766                  */
3767                 scsi_test_unit_ready(&ccb->csio,
3768                                      /* retries */ 0,
3769                                      /* cbfcnp */ NULL,
3770                                      /* tag_action */ MSG_SIMPLE_Q_TAG,
3771                                      /* sense_len */ SSD_FULL_SIZE,
3772                                      /* timeout */ 5000);
3773
3774                 /* Disable freezing the device queue */
3775                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
3776
3777                 retval = cam_send_ccb(device, ccb);
3778
3779                 /*
3780                  * If we get an error from the ioctl, bail out.  SCSI
3781                  * errors are expected.
3782                  */
3783                 if (retval < 0) {
3784                         warn("error sending CAMIOCOMMAND ioctl");
3785                         if (arglist & CAM_ARG_VERBOSE) {
3786                                 cam_error_print(device, ccb, CAM_ESF_ALL,
3787                                                 CAM_EPF_ALL, stderr);
3788                         }
3789                         error = 1;
3790                         goto scsiformat_bailout;
3791                 }
3792
3793                 status = ccb->ccb_h.status & CAM_STATUS_MASK;
3794
3795                 if ((status != CAM_REQ_CMP)
3796                  && (status == CAM_SCSI_STATUS_ERROR)
3797                  && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
3798                         struct scsi_sense_data *sense;
3799                         int error_code, sense_key, asc, ascq;
3800
3801                         sense = &ccb->csio.sense_data;
3802                         scsi_extract_sense_len(sense, ccb->csio.sense_len -
3803                             ccb->csio.sense_resid, &error_code, &sense_key,
3804                             &asc, &ascq, /*show_errors*/ 1);
3805
3806                         /*
3807                          * According to the SCSI-2 and SCSI-3 specs, a
3808                          * drive that is in the middle of a format should
3809                          * return NOT READY with an ASC of "logical unit
3810                          * not ready, format in progress".  The sense key
3811                          * specific bytes will then be a progress indicator.
3812                          */
3813                         if ((sense_key == SSD_KEY_NOT_READY)
3814                          && (asc == 0x04) && (ascq == 0x04)) {
3815                                 uint8_t sks[3];
3816
3817                                 if ((scsi_get_sks(sense, ccb->csio.sense_len -
3818                                      ccb->csio.sense_resid, sks) == 0)
3819                                  && (quiet == 0)) {
3820                                         int val;
3821                                         u_int64_t percentage;
3822
3823                                         val = scsi_2btoul(&sks[1]);
3824                                         percentage = 10000 * val;
3825
3826                                         fprintf(stdout,
3827                                                 "\rFormatting:  %ju.%02u %% "
3828                                                 "(%d/%d) done",
3829                                                 (uintmax_t)(percentage /
3830                                                 (0x10000 * 100)),
3831                                                 (unsigned)((percentage /
3832                                                 0x10000) % 100),
3833                                                 val, 0x10000);
3834                                         fflush(stdout);
3835                                 } else if ((quiet == 0)
3836                                         && (++num_warnings <= 1)) {
3837                                         warnx("Unexpected SCSI Sense Key "
3838                                               "Specific value returned "
3839                                               "during format:");
3840                                         scsi_sense_print(device, &ccb->csio,
3841                                                          stderr);
3842                                         warnx("Unable to print status "
3843                                               "information, but format will "
3844                                               "proceed.");
3845                                         warnx("will exit when format is "
3846                                               "complete");
3847                                 }
3848                                 sleep(1);
3849                         } else {
3850                                 warnx("Unexpected SCSI error during format");
3851                                 cam_error_print(device, ccb, CAM_ESF_ALL,
3852                                                 CAM_EPF_ALL, stderr);
3853                                 error = 1;
3854                                 goto scsiformat_bailout;
3855                         }
3856
3857                 } else if (status != CAM_REQ_CMP) {
3858                         warnx("Unexpected CAM status %#x", status);
3859                         if (arglist & CAM_ARG_VERBOSE)
3860                                 cam_error_print(device, ccb, CAM_ESF_ALL,
3861                                                 CAM_EPF_ALL, stderr);
3862                         error = 1;
3863                         goto scsiformat_bailout;
3864                 }
3865
3866         } while((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP);
3867
3868         if (quiet == 0)
3869                 fprintf(stdout, "\nFormat Complete\n");
3870
3871 scsiformat_bailout:
3872
3873         cam_freeccb(ccb);
3874
3875         return(error);
3876 }
3877
3878 static int
3879 scsireportluns(struct cam_device *device, int argc, char **argv,
3880                char *combinedopt, int retry_count, int timeout)
3881 {
3882         union ccb *ccb;
3883         int c, countonly, lunsonly;
3884         struct scsi_report_luns_data *lundata;
3885         int alloc_len;
3886         uint8_t report_type;
3887         uint32_t list_len, i, j;
3888         int retval;
3889
3890         retval = 0;
3891         lundata = NULL;
3892         report_type = RPL_REPORT_DEFAULT;
3893         ccb = cam_getccb(device);
3894
3895         if (ccb == NULL) {
3896                 warnx("%s: error allocating ccb", __func__);
3897                 return (1);
3898         }
3899
3900         bzero(&(&ccb->ccb_h)[1],
3901               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
3902
3903         countonly = 0;
3904         lunsonly = 0;
3905
3906         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3907                 switch (c) {
3908                 case 'c':
3909                         countonly++;
3910                         break;
3911                 case 'l':
3912                         lunsonly++;
3913                         break;
3914                 case 'r':
3915                         if (strcasecmp(optarg, "default") == 0)
3916                                 report_type = RPL_REPORT_DEFAULT;
3917                         else if (strcasecmp(optarg, "wellknown") == 0)
3918                                 report_type = RPL_REPORT_WELLKNOWN;
3919                         else if (strcasecmp(optarg, "all") == 0)
3920                                 report_type = RPL_REPORT_ALL;
3921                         else {
3922                                 warnx("%s: invalid report type \"%s\"",
3923                                       __func__, optarg);
3924                                 retval = 1;
3925                                 goto bailout;
3926                         }
3927                         break;
3928                 default:
3929                         break;
3930                 }
3931         }
3932
3933         if ((countonly != 0)
3934          && (lunsonly != 0)) {
3935                 warnx("%s: you can only specify one of -c or -l", __func__);
3936                 retval = 1;
3937                 goto bailout;
3938         }
3939         /*
3940          * According to SPC-4, the allocation length must be at least 16
3941          * bytes -- enough for the header and one LUN.
3942          */
3943         alloc_len = sizeof(*lundata) + 8;
3944
3945 retry:
3946
3947         lundata = malloc(alloc_len);
3948
3949         if (lundata == NULL) {
3950                 warn("%s: error mallocing %d bytes", __func__, alloc_len);
3951                 retval = 1;
3952                 goto bailout;
3953         }
3954
3955         scsi_report_luns(&ccb->csio,
3956                          /*retries*/ retry_count,
3957                          /*cbfcnp*/ NULL,
3958                          /*tag_action*/ MSG_SIMPLE_Q_TAG,
3959                          /*select_report*/ report_type,
3960                          /*rpl_buf*/ lundata,
3961                          /*alloc_len*/ alloc_len,
3962                          /*sense_len*/ SSD_FULL_SIZE,
3963                          /*timeout*/ timeout ? timeout : 5000);
3964
3965         /* Disable freezing the device queue */
3966         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
3967
3968         if (arglist & CAM_ARG_ERR_RECOVER)
3969                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
3970
3971         if (cam_send_ccb(device, ccb) < 0) {
3972                 warn("error sending REPORT LUNS command");
3973
3974                 if (arglist & CAM_ARG_VERBOSE)
3975                         cam_error_print(device, ccb, CAM_ESF_ALL,
3976                                         CAM_EPF_ALL, stderr);
3977
3978                 retval = 1;
3979                 goto bailout;
3980         }
3981
3982         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3983                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
3984                 retval = 1;
3985                 goto bailout;
3986         }
3987
3988
3989         list_len = scsi_4btoul(lundata->length);
3990
3991         /*
3992          * If we need to list the LUNs, and our allocation
3993          * length was too short, reallocate and retry.
3994          */
3995         if ((countonly == 0)
3996          && (list_len > (alloc_len - sizeof(*lundata)))) {
3997                 alloc_len = list_len + sizeof(*lundata);
3998                 free(lundata);
3999                 goto retry;
4000         }
4001
4002         if (lunsonly == 0)
4003                 fprintf(stdout, "%u LUN%s found\n", list_len / 8,
4004                         ((list_len / 8) > 1) ? "s" : "");
4005
4006         if (countonly != 0)
4007                 goto bailout;
4008
4009         for (i = 0; i < (list_len / 8); i++) {
4010                 int no_more;
4011
4012                 no_more = 0;
4013                 for (j = 0; j < sizeof(lundata->luns[i].lundata); j += 2) {
4014                         if (j != 0)
4015                                 fprintf(stdout, ",");
4016                         switch (lundata->luns[i].lundata[j] &
4017                                 RPL_LUNDATA_ATYP_MASK) {
4018                         case RPL_LUNDATA_ATYP_PERIPH:
4019                                 if ((lundata->luns[i].lundata[j] &
4020                                     RPL_LUNDATA_PERIPH_BUS_MASK) != 0)
4021                                         fprintf(stdout, "%d:",
4022                                                 lundata->luns[i].lundata[j] &
4023                                                 RPL_LUNDATA_PERIPH_BUS_MASK);
4024                                 else if ((j == 0)
4025                                       && ((lundata->luns[i].lundata[j+2] &
4026                                           RPL_LUNDATA_PERIPH_BUS_MASK) == 0))
4027                                         no_more = 1;
4028
4029                                 fprintf(stdout, "%d",
4030                                         lundata->luns[i].lundata[j+1]);
4031                                 break;
4032                         case RPL_LUNDATA_ATYP_FLAT: {
4033                                 uint8_t tmplun[2];
4034                                 tmplun[0] = lundata->luns[i].lundata[j] &
4035                                         RPL_LUNDATA_FLAT_LUN_MASK;
4036                                 tmplun[1] = lundata->luns[i].lundata[j+1];
4037
4038                                 fprintf(stdout, "%d", scsi_2btoul(tmplun));
4039                                 no_more = 1;
4040                                 break;
4041                         }
4042                         case RPL_LUNDATA_ATYP_LUN:
4043                                 fprintf(stdout, "%d:%d:%d",
4044                                         (lundata->luns[i].lundata[j+1] &
4045                                         RPL_LUNDATA_LUN_BUS_MASK) >> 5,
4046                                         lundata->luns[i].lundata[j] &
4047                                         RPL_LUNDATA_LUN_TARG_MASK,
4048                                         lundata->luns[i].lundata[j+1] &
4049                                         RPL_LUNDATA_LUN_LUN_MASK);
4050                                 break;
4051                         case RPL_LUNDATA_ATYP_EXTLUN: {
4052                                 int field_len_code, eam_code;
4053
4054                                 eam_code = lundata->luns[i].lundata[j] &
4055                                         RPL_LUNDATA_EXT_EAM_MASK;
4056                                 field_len_code = (lundata->luns[i].lundata[j] &
4057                                         RPL_LUNDATA_EXT_LEN_MASK) >> 4;
4058
4059                                 if ((eam_code == RPL_LUNDATA_EXT_EAM_WK)
4060                                  && (field_len_code == 0x00)) {
4061                                         fprintf(stdout, "%d",
4062                                                 lundata->luns[i].lundata[j+1]);
4063                                 } else if ((eam_code ==
4064                                             RPL_LUNDATA_EXT_EAM_NOT_SPEC)
4065                                         && (field_len_code == 0x03)) {
4066                                         uint8_t tmp_lun[8];
4067
4068                                         /*
4069                                          * This format takes up all 8 bytes.
4070                                          * If we aren't starting at offset 0,
4071                                          * that's a bug.
4072                                          */
4073                                         if (j != 0) {
4074                                                 fprintf(stdout, "Invalid "
4075                                                         "offset %d for "
4076                                                         "Extended LUN not "
4077                                                         "specified format", j);
4078                                                 no_more = 1;
4079                                                 break;
4080                                         }
4081                                         bzero(tmp_lun, sizeof(tmp_lun));
4082                                         bcopy(&lundata->luns[i].lundata[j+1],
4083                                               &tmp_lun[1], sizeof(tmp_lun) - 1);
4084                                         fprintf(stdout, "%#jx",
4085                                                (intmax_t)scsi_8btou64(tmp_lun));
4086                                         no_more = 1;
4087                                 } else {
4088                                         fprintf(stderr, "Unknown Extended LUN"
4089                                                 "Address method %#x, length "
4090                                                 "code %#x", eam_code,
4091                                                 field_len_code);
4092                                         no_more = 1;
4093                                 }
4094                                 break;
4095                         }
4096                         default:
4097                                 fprintf(stderr, "Unknown LUN address method "
4098                                         "%#x\n", lundata->luns[i].lundata[0] &
4099                                         RPL_LUNDATA_ATYP_MASK);
4100                                 break;
4101                         }
4102                         /*
4103                          * For the flat addressing method, there are no
4104                          * other levels after it.
4105                          */
4106                         if (no_more != 0)
4107                                 break;
4108                 }
4109                 fprintf(stdout, "\n");
4110         }
4111
4112 bailout:
4113
4114         cam_freeccb(ccb);
4115
4116         free(lundata);
4117
4118         return (retval);
4119 }
4120
4121 static int
4122 scsireadcapacity(struct cam_device *device, int argc, char **argv,
4123                  char *combinedopt, int retry_count, int timeout)
4124 {
4125         union ccb *ccb;
4126         int blocksizeonly, humanize, numblocks, quiet, sizeonly, baseten;
4127         struct scsi_read_capacity_data rcap;
4128         struct scsi_read_capacity_data_long rcaplong;
4129         uint64_t maxsector;
4130         uint32_t block_len;
4131         int retval;
4132         int c;
4133
4134         blocksizeonly = 0;
4135         humanize = 0;
4136         numblocks = 0;
4137         quiet = 0;
4138         sizeonly = 0;
4139         baseten = 0;
4140         retval = 0;
4141
4142         ccb = cam_getccb(device);
4143
4144         if (ccb == NULL) {
4145                 warnx("%s: error allocating ccb", __func__);
4146                 return (1);
4147         }
4148
4149         bzero(&(&ccb->ccb_h)[1],
4150               sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
4151
4152         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4153                 switch (c) {
4154                 case 'b':
4155                         blocksizeonly++;
4156                         break;
4157                 case 'h':
4158                         humanize++;
4159                         baseten = 0;
4160                         break;
4161                 case 'H':
4162                         humanize++;
4163                         baseten++;
4164                         break;
4165                 case 'N':
4166                         numblocks++;
4167                         break;
4168                 case 'q':
4169                         quiet++;
4170                         break;
4171                 case 's':
4172                         sizeonly++;
4173                         break;
4174                 default:
4175                         break;
4176                 }
4177         }
4178
4179         if ((blocksizeonly != 0)
4180          && (numblocks != 0)) {
4181                 warnx("%s: you can only specify one of -b or -N", __func__);
4182                 retval = 1;
4183                 goto bailout;
4184         }
4185
4186         if ((blocksizeonly != 0)
4187          && (sizeonly != 0)) {
4188                 warnx("%s: you can only specify one of -b or -s", __func__);
4189                 retval = 1;
4190                 goto bailout;
4191         }
4192
4193         if ((humanize != 0)
4194          && (quiet != 0)) {
4195                 warnx("%s: you can only specify one of -h/-H or -q", __func__);
4196                 retval = 1;
4197                 goto bailout;
4198         }
4199
4200         if ((humanize != 0)
4201          && (blocksizeonly != 0)) {
4202                 warnx("%s: you can only specify one of -h/-H or -b", __func__);
4203                 retval = 1;
4204                 goto bailout;
4205         }
4206
4207         scsi_read_capacity(&ccb->csio,
4208                            /*retries*/ retry_count,
4209                            /*cbfcnp*/ NULL,
4210                            /*tag_action*/ MSG_SIMPLE_Q_TAG,
4211                            &rcap,
4212                            SSD_FULL_SIZE,
4213                            /*timeout*/ timeout ? timeout : 5000);
4214
4215         /* Disable freezing the device queue */
4216         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
4217
4218         if (arglist & CAM_ARG_ERR_RECOVER)
4219                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
4220
4221         if (cam_send_ccb(device, ccb) < 0) {
4222                 warn("error sending READ CAPACITY command");
4223
4224                 if (arglist & CAM_ARG_VERBOSE)
4225                         cam_error_print(device, ccb, CAM_ESF_ALL,
4226                                         CAM_EPF_ALL, stderr);
4227
4228                 retval = 1;
4229                 goto bailout;
4230         }
4231
4232         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
4233                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
4234                 retval = 1;
4235                 goto bailout;
4236         }
4237
4238         maxsector = scsi_4btoul(rcap.addr);
4239         block_len = scsi_4btoul(rcap.length);
4240
4241         /*
4242          * A last block of 2^32-1 means that the true capacity is over 2TB,
4243          * and we need to issue the long READ CAPACITY to get the real
4244          * capacity.  Otherwise, we're all set.
4245          */
4246         if (maxsector != 0xffffffff)
4247                 goto do_print;
4248
4249         scsi_read_capacity_16(&ccb->csio,
4250                               /*retries*/ retry_count,
4251                               /*cbfcnp*/ NULL,
4252                               /*tag_action*/ MSG_SIMPLE_Q_TAG,
4253                               /*lba*/ 0,
4254                               /*reladdr*/ 0,
4255                               /*pmi*/ 0,
4256                               &rcaplong,
4257                               /*sense_len*/ SSD_FULL_SIZE,
4258                               /*timeout*/ timeout ? timeout : 5000);
4259
4260         /* Disable freezing the device queue */
4261         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
4262
4263         if (arglist & CAM_ARG_ERR_RECOVER)
4264                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
4265
4266         if (cam_send_ccb(device, ccb) < 0) {
4267                 warn("error sending READ CAPACITY (16) command");
4268
4269                 if (arglist & CAM_ARG_VERBOSE)
4270                         cam_error_print(device, ccb, CAM_ESF_ALL,
4271                                         CAM_EPF_ALL, stderr);
4272
4273                 retval = 1;
4274                 goto bailout;
4275         }
4276
4277         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
4278                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
4279                 retval = 1;
4280                 goto bailout;
4281         }
4282
4283         maxsector = scsi_8btou64(rcaplong.addr);
4284         block_len = scsi_4btoul(rcaplong.length);
4285
4286 do_print:
4287         if (blocksizeonly == 0) {
4288                 /*
4289                  * Humanize implies !quiet, and also implies numblocks.
4290                  */
4291                 if (humanize != 0) {
4292                         char tmpstr[6];
4293                         int64_t tmpbytes;
4294                         int ret;
4295
4296                         tmpbytes = (maxsector + 1) * block_len;
4297                         ret = humanize_number(tmpstr, sizeof(tmpstr),
4298                                               tmpbytes, "", HN_AUTOSCALE,
4299                                               HN_B | HN_DECIMAL |
4300                                               ((baseten != 0) ?
4301                                               HN_DIVISOR_1000 : 0));
4302                         if (ret == -1) {
4303                                 warnx("%s: humanize_number failed!", __func__);
4304                                 retval = 1;
4305                                 goto bailout;
4306                         }
4307                         fprintf(stdout, "Device Size: %s%s", tmpstr,
4308                                 (sizeonly == 0) ?  ", " : "\n");
4309                 } else if (numblocks != 0) {
4310                         fprintf(stdout, "%s%ju%s", (quiet == 0) ?
4311                                 "Blocks: " : "", (uintmax_t)maxsector + 1,
4312                                 (sizeonly == 0) ? ", " : "\n");
4313                 } else {
4314                         fprintf(stdout, "%s%ju%s", (quiet == 0) ?
4315                                 "Last Block: " : "", (uintmax_t)maxsector,
4316                                 (sizeonly == 0) ? ", " : "\n");
4317                 }
4318         }
4319         if (sizeonly == 0)
4320                 fprintf(stdout, "%s%u%s\n", (quiet == 0) ?
4321                         "Block Length: " : "", block_len, (quiet == 0) ?
4322                         " bytes" : "");
4323 bailout:
4324         cam_freeccb(ccb);
4325
4326         return (retval);
4327 }
4328
4329 static int
4330 smpcmd(struct cam_device *device, int argc, char **argv, char *combinedopt,
4331        int retry_count, int timeout)
4332 {
4333         int c, error;
4334         union ccb *ccb;
4335         uint8_t *smp_request = NULL, *smp_response = NULL;
4336         int request_size = 0, response_size = 0;
4337         int fd_request = 0, fd_response = 0;
4338         char *datastr = NULL;
4339         struct get_hook hook;
4340         int retval;
4341         int flags = 0;
4342
4343         /*
4344          * Note that at the moment we don't support sending SMP CCBs to
4345          * devices that aren't probed by CAM.
4346          */
4347         ccb = cam_getccb(device);
4348         if (ccb == NULL) {
4349                 warnx("%s: error allocating CCB", __func__);
4350                 return (1);
4351         }
4352
4353         bzero(&(&ccb->ccb_h)[1],
4354               sizeof(union ccb) - sizeof(struct ccb_hdr));
4355
4356         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4357                 switch (c) {
4358                 case 'R':
4359                         arglist |= CAM_ARG_CMD_IN;
4360                         response_size = strtol(optarg, NULL, 0);
4361                         if (response_size <= 0) {
4362                                 warnx("invalid number of response bytes %d",
4363                                       response_size);
4364                                 error = 1;
4365                                 goto smpcmd_bailout;
4366                         }
4367                         hook.argc = argc - optind;
4368                         hook.argv = argv + optind;
4369                         hook.got = 0;
4370                         optind++;
4371                         datastr = cget(&hook, NULL);
4372                         /*
4373                          * If the user supplied "-" instead of a format, he
4374                          * wants the data to be written to stdout.
4375                          */
4376                         if ((datastr != NULL)
4377                          && (datastr[0] == '-'))
4378                                 fd_response = 1;
4379
4380                         smp_response = (u_int8_t *)malloc(response_size);
4381                         if (smp_response == NULL) {
4382                                 warn("can't malloc memory for SMP response");
4383                                 error = 1;
4384                                 goto smpcmd_bailout;
4385                         }
4386                         break;
4387                 case 'r':
4388                         arglist |= CAM_ARG_CMD_OUT;
4389                         request_size = strtol(optarg, NULL, 0);
4390                         if (request_size <= 0) {
4391                                 warnx("invalid number of request bytes %d",
4392                                       request_size);
4393                                 error = 1;
4394                                 goto smpcmd_bailout;
4395                         }
4396                         hook.argc = argc - optind;
4397                         hook.argv = argv + optind;
4398                         hook.got = 0;
4399                         datastr = cget(&hook, NULL);
4400                         smp_request = (u_int8_t *)malloc(request_size);
4401                         if (smp_request == NULL) {
4402                                 warn("can't malloc memory for SMP request");
4403                                 error = 1;
4404                                 goto smpcmd_bailout;
4405                         }
4406                         bzero(smp_request, request_size);
4407                         /*
4408                          * If the user supplied "-" instead of a format, he
4409                          * wants the data to be read from stdin.
4410                          */
4411                         if ((datastr != NULL)
4412                          && (datastr[0] == '-'))
4413                                 fd_request = 1;
4414                         else
4415                                 buff_encode_visit(smp_request, request_size,
4416                                                   datastr,
4417                                                   iget, &hook);
4418                         optind += hook.got;
4419                         break;
4420                 default:
4421                         break;
4422                 }
4423         }
4424
4425         /*
4426          * If fd_data is set, and we're writing to the device, we need to
4427          * read the data the user wants written from stdin.
4428          */
4429         if ((fd_request == 1) && (arglist & CAM_ARG_CMD_OUT)) {
4430                 ssize_t amt_read;
4431                 int amt_to_read = request_size;
4432                 u_int8_t *buf_ptr = smp_request;
4433
4434                 for (amt_read = 0; amt_to_read > 0;
4435                      amt_read = read(STDIN_FILENO, buf_ptr, amt_to_read)) {
4436                         if (amt_read == -1) {
4437                                 warn("error reading data from stdin");
4438                                 error = 1;
4439                                 goto smpcmd_bailout;
4440                         }
4441                         amt_to_read -= amt_read;
4442                         buf_ptr += amt_read;
4443                 }
4444         }
4445
4446         if (((arglist & CAM_ARG_CMD_IN) == 0)
4447          || ((arglist & CAM_ARG_CMD_OUT) == 0)) {
4448                 warnx("%s: need both the request (-r) and response (-R) "
4449                       "arguments", __func__);
4450                 error = 1;
4451                 goto smpcmd_bailout;
4452         }
4453
4454         flags |= CAM_DEV_QFRZDIS;
4455
4456         cam_fill_smpio(&ccb->smpio,
4457                        /*retries*/ retry_count,
4458                        /*cbfcnp*/ NULL,
4459                        /*flags*/ flags,
4460                        /*smp_request*/ smp_request,
4461                        /*smp_request_len*/ request_size,
4462                        /*smp_response*/ smp_response,
4463                        /*smp_response_len*/ response_size,
4464                        /*timeout*/ timeout ? timeout : 5000);
4465
4466         ccb->smpio.flags = SMP_FLAG_NONE;
4467
4468         if (((retval = cam_send_ccb(device, ccb)) < 0)
4469          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
4470                 const char warnstr[] = "error sending command";
4471
4472                 if (retval < 0)
4473                         warn(warnstr);
4474                 else
4475                         warnx(warnstr);
4476
4477                 if (arglist & CAM_ARG_VERBOSE) {
4478                         cam_error_print(device, ccb, CAM_ESF_ALL,
4479                                         CAM_EPF_ALL, stderr);
4480                 }
4481         }
4482
4483         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
4484          && (response_size > 0)) {
4485                 if (fd_response == 0) {
4486                         buff_decode_visit(smp_response, response_size,
4487                                           datastr, arg_put, NULL);
4488                         fprintf(stdout, "\n");
4489                 } else {
4490                         ssize_t amt_written;
4491                         int amt_to_write = response_size;
4492                         u_int8_t *buf_ptr = smp_response;
4493
4494                         for (amt_written = 0; (amt_to_write > 0) &&
4495                              (amt_written = write(STDOUT_FILENO, buf_ptr,
4496                                                   amt_to_write)) > 0;){
4497                                 amt_to_write -= amt_written;
4498                                 buf_ptr += amt_written;
4499                         }
4500                         if (amt_written == -1) {
4501                                 warn("error writing data to stdout");
4502                                 error = 1;
4503                                 goto smpcmd_bailout;
4504                         } else if ((amt_written == 0)
4505                                 && (amt_to_write > 0)) {
4506                                 warnx("only wrote %u bytes out of %u",
4507                                       response_size - amt_to_write,
4508                                       response_size);
4509                         }
4510                 }
4511         }
4512 smpcmd_bailout:
4513         if (ccb != NULL)
4514                 cam_freeccb(ccb);
4515
4516         if (smp_request != NULL)
4517                 free(smp_request);
4518
4519         if (smp_response != NULL)
4520                 free(smp_response);
4521
4522         return (error);
4523 }
4524
4525 static int
4526 smpreportgeneral(struct cam_device *device, int argc, char **argv,
4527                  char *combinedopt, int retry_count, int timeout)
4528 {
4529         union ccb *ccb;
4530         struct smp_report_general_request *request = NULL;
4531         struct smp_report_general_response *response = NULL;
4532         struct sbuf *sb = NULL;
4533         int error = 0;
4534         int c, long_response = 0;
4535         int retval;
4536
4537         /*
4538          * Note that at the moment we don't support sending SMP CCBs to
4539          * devices that aren't probed by CAM.
4540          */
4541         ccb = cam_getccb(device);
4542         if (ccb == NULL) {
4543                 warnx("%s: error allocating CCB", __func__);
4544                 return (1);
4545         }
4546
4547         bzero(&(&ccb->ccb_h)[1],
4548               sizeof(union ccb) - sizeof(struct ccb_hdr));
4549
4550         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4551                 switch (c) {
4552                 case 'l':
4553                         long_response = 1;
4554                         break;
4555                 default:
4556                         break;
4557                 }
4558         }
4559         request = malloc(sizeof(*request));
4560         if (request == NULL) {
4561                 warn("%s: unable to allocate %zd bytes", __func__,
4562                      sizeof(*request));
4563                 error = 1;
4564                 goto bailout;
4565         }
4566
4567         response = malloc(sizeof(*response));
4568         if (response == NULL) {
4569                 warn("%s: unable to allocate %zd bytes", __func__,
4570                      sizeof(*response));
4571                 error = 1;
4572                 goto bailout;
4573         }
4574
4575 try_long:
4576         smp_report_general(&ccb->smpio,
4577                            retry_count,
4578                            /*cbfcnp*/ NULL,
4579                            request,
4580                            /*request_len*/ sizeof(*request),
4581                            (uint8_t *)response,
4582                            /*response_len*/ sizeof(*response),
4583                            /*long_response*/ long_response,
4584                            timeout);
4585
4586         if (((retval = cam_send_ccb(device, ccb)) < 0)
4587          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
4588                 const char warnstr[] = "error sending command";
4589
4590                 if (retval < 0)
4591                         warn(warnstr);
4592                 else
4593                         warnx(warnstr);
4594
4595                 if (arglist & CAM_ARG_VERBOSE) {
4596                         cam_error_print(device, ccb, CAM_ESF_ALL,
4597                                         CAM_EPF_ALL, stderr);
4598                 }
4599                 error = 1;
4600                 goto bailout;
4601         }
4602
4603         /*
4604          * If the device supports the long response bit, try again and see
4605          * if we can get all of the data.
4606          */
4607         if ((response->long_response & SMP_RG_LONG_RESPONSE)
4608          && (long_response == 0)) {
4609                 ccb->ccb_h.status = CAM_REQ_INPROG;
4610                 bzero(&(&ccb->ccb_h)[1],
4611                       sizeof(union ccb) - sizeof(struct ccb_hdr));
4612                 long_response = 1;
4613                 goto try_long;
4614         }
4615
4616         /*
4617          * XXX KDM detect and decode SMP errors here.
4618          */
4619         sb = sbuf_new_auto();
4620         if (sb == NULL) {
4621                 warnx("%s: error allocating sbuf", __func__);
4622                 goto bailout;
4623         }
4624
4625         smp_report_general_sbuf(response, sizeof(*response), sb);
4626
4627         sbuf_finish(sb);
4628
4629         printf("%s", sbuf_data(sb));
4630
4631 bailout:
4632         if (ccb != NULL)
4633                 cam_freeccb(ccb);
4634
4635         if (request != NULL)
4636                 free(request);
4637
4638         if (response != NULL)
4639                 free(response);
4640
4641         if (sb != NULL)
4642                 sbuf_delete(sb);
4643
4644         return (error);
4645 }
4646
4647 struct camcontrol_opts phy_ops[] = {
4648         {"nop", SMP_PC_PHY_OP_NOP, CAM_ARG_NONE, NULL},
4649         {"linkreset", SMP_PC_PHY_OP_LINK_RESET, CAM_ARG_NONE, NULL},
4650         {"hardreset", SMP_PC_PHY_OP_HARD_RESET, CAM_ARG_NONE, NULL},
4651         {"disable", SMP_PC_PHY_OP_DISABLE, CAM_ARG_NONE, NULL},
4652         {"clearerrlog", SMP_PC_PHY_OP_CLEAR_ERR_LOG, CAM_ARG_NONE, NULL},
4653         {"clearaffiliation", SMP_PC_PHY_OP_CLEAR_AFFILIATON, CAM_ARG_NONE,NULL},
4654         {"sataportsel", SMP_PC_PHY_OP_TRANS_SATA_PSS, CAM_ARG_NONE, NULL},
4655         {"clearitnl", SMP_PC_PHY_OP_CLEAR_STP_ITN_LS, CAM_ARG_NONE, NULL},
4656         {"setdevname", SMP_PC_PHY_OP_SET_ATT_DEV_NAME, CAM_ARG_NONE, NULL},
4657         {NULL, 0, 0, NULL}
4658 };
4659
4660 static int
4661 smpphycontrol(struct cam_device *device, int argc, char **argv,
4662               char *combinedopt, int retry_count, int timeout)
4663 {
4664         union ccb *ccb;
4665         struct smp_phy_control_request *request = NULL;
4666         struct smp_phy_control_response *response = NULL;
4667         int long_response = 0;
4668         int retval = 0;
4669         int phy = -1;
4670         uint32_t phy_operation = SMP_PC_PHY_OP_NOP;
4671         int phy_op_set = 0;
4672         uint64_t attached_dev_name = 0;
4673         int dev_name_set = 0;
4674         uint32_t min_plr = 0, max_plr = 0;
4675         uint32_t pp_timeout_val = 0;
4676         int slumber_partial = 0;
4677         int set_pp_timeout_val = 0;
4678         int c;
4679
4680         /*
4681          * Note that at the moment we don't support sending SMP CCBs to
4682          * devices that aren't probed by CAM.
4683          */
4684         ccb = cam_getccb(device);
4685         if (ccb == NULL) {
4686                 warnx("%s: error allocating CCB", __func__);
4687                 return (1);
4688         }
4689
4690         bzero(&(&ccb->ccb_h)[1],
4691               sizeof(union ccb) - sizeof(struct ccb_hdr));
4692
4693         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4694                 switch (c) {
4695                 case 'a':
4696                 case 'A':
4697                 case 's':
4698                 case 'S': {
4699                         int enable = -1;
4700
4701                         if (strcasecmp(optarg, "enable") == 0)
4702                                 enable = 1;
4703                         else if (strcasecmp(optarg, "disable") == 0)
4704                                 enable = 2;
4705                         else {
4706                                 warnx("%s: Invalid argument %s", __func__,
4707                                       optarg);
4708                                 retval = 1;
4709                                 goto bailout;
4710                         }
4711                         switch (c) {
4712                         case 's':
4713                                 slumber_partial |= enable <<
4714                                                    SMP_PC_SAS_SLUMBER_SHIFT;
4715                                 break;
4716                         case 'S':
4717                                 slumber_partial |= enable <<
4718                                                    SMP_PC_SAS_PARTIAL_SHIFT;
4719                                 break;
4720                         case 'a':
4721                                 slumber_partial |= enable <<
4722                                                    SMP_PC_SATA_SLUMBER_SHIFT;
4723                                 break;
4724                         case 'A':
4725                                 slumber_partial |= enable <<
4726                                                    SMP_PC_SATA_PARTIAL_SHIFT;
4727                                 break;
4728                         default:
4729                                 warnx("%s: programmer error", __func__);
4730                                 retval = 1;
4731                                 goto bailout;
4732                                 break; /*NOTREACHED*/
4733                         }
4734                         break;
4735                 }
4736                 case 'd':
4737                         attached_dev_name = (uintmax_t)strtoumax(optarg,
4738                                                                  NULL,0);
4739                         dev_name_set = 1;
4740                         break;
4741                 case 'l':
4742                         long_response = 1;
4743                         break;
4744                 case 'm':
4745                         /*
4746                          * We don't do extensive checking here, so this
4747                          * will continue to work when new speeds come out.
4748                          */
4749                         min_plr = strtoul(optarg, NULL, 0);
4750                         if ((min_plr == 0)
4751                          || (min_plr > 0xf)) {
4752                                 warnx("%s: invalid link rate %x",
4753                                       __func__, min_plr);
4754                                 retval = 1;
4755                                 goto bailout;
4756                         }
4757                         break;
4758                 case 'M':
4759                         /*
4760                          * We don't do extensive checking here, so this
4761                          * will continue to work when new speeds come out.
4762                          */
4763                         max_plr = strtoul(optarg, NULL, 0);
4764                         if ((max_plr == 0)
4765                          || (max_plr > 0xf)) {
4766                                 warnx("%s: invalid link rate %x",
4767                                       __func__, max_plr);
4768                                 retval = 1;
4769                                 goto bailout;
4770                         }
4771                         break;
4772                 case 'o': {
4773                         camcontrol_optret optreturn;
4774                         cam_argmask argnums;
4775                         const char *subopt;
4776
4777                         if (phy_op_set != 0) {
4778                                 warnx("%s: only one phy operation argument "
4779                                       "(-o) allowed", __func__);
4780                                 retval = 1;
4781                                 goto bailout;
4782                         }
4783
4784                         phy_op_set = 1;
4785
4786                         /*
4787                          * Allow the user to specify the phy operation
4788                          * numerically, as well as with a name.  This will
4789                          * future-proof it a bit, so options that are added
4790                          * in future specs can be used.
4791                          */
4792                         if (isdigit(optarg[0])) {
4793                                 phy_operation = strtoul(optarg, NULL, 0);
4794                                 if ((phy_operation == 0)
4795                                  || (phy_operation > 0xff)) {
4796                                         warnx("%s: invalid phy operation %#x",
4797                                               __func__, phy_operation);
4798                                         retval = 1;
4799                                         goto bailout;
4800                                 }
4801                                 break;
4802                         }
4803                         optreturn = getoption(phy_ops, optarg, &phy_operation,
4804                                               &argnums, &subopt);
4805
4806                         if (optreturn == CC_OR_AMBIGUOUS) {
4807                                 warnx("%s: ambiguous option %s", __func__,
4808                                       optarg);
4809                                 usage(0);
4810                                 retval = 1;
4811                                 goto bailout;
4812                         } else if (optreturn == CC_OR_NOT_FOUND) {
4813                                 warnx("%s: option %s not found", __func__,
4814                                       optarg);
4815                                 usage(0);
4816                                 retval = 1;
4817                                 goto bailout;
4818                         }
4819                         break;
4820                 }
4821                 case 'p':
4822                         phy = atoi(optarg);
4823                         break;
4824                 case 'T':
4825                         pp_timeout_val = strtoul(optarg, NULL, 0);
4826                         if (pp_timeout_val > 15) {
4827                                 warnx("%s: invalid partial pathway timeout "
4828                                       "value %u, need a value less than 16",
4829                                       __func__, pp_timeout_val);
4830                                 retval = 1;
4831                                 goto bailout;
4832                         }
4833                         set_pp_timeout_val = 1;
4834                         break;
4835                 default:
4836                         break;
4837                 }
4838         }
4839
4840         if (phy == -1) {
4841                 warnx("%s: a PHY (-p phy) argument is required",__func__);
4842                 retval = 1;
4843                 goto bailout;
4844         }
4845
4846         if (((dev_name_set != 0)
4847           && (phy_operation != SMP_PC_PHY_OP_SET_ATT_DEV_NAME))
4848          || ((phy_operation == SMP_PC_PHY_OP_SET_ATT_DEV_NAME)
4849           && (dev_name_set == 0))) {
4850                 warnx("%s: -d name and -o setdevname arguments both "
4851                       "required to set device name", __func__);
4852                 retval = 1;
4853                 goto bailout;
4854         }
4855
4856         request = malloc(sizeof(*request));
4857         if (request == NULL) {
4858                 warn("%s: unable to allocate %zd bytes", __func__,
4859                      sizeof(*request));
4860                 retval = 1;
4861                 goto bailout;
4862         }
4863
4864         response = malloc(sizeof(*response));
4865         if (response == NULL) {
4866                 warn("%s: unable to allocate %zd bytes", __func__,
4867                      sizeof(*request));
4868                 retval = 1;
4869                 goto bailout;
4870         }
4871
4872         smp_phy_control(&ccb->smpio,
4873                         retry_count,
4874                         /*cbfcnp*/ NULL,
4875                         request,
4876                         sizeof(*request),
4877                         (uint8_t *)response,
4878                         sizeof(*response),
4879                         long_response,
4880                         /*expected_exp_change_count*/ 0,
4881                         phy,
4882                         phy_operation,
4883                         (set_pp_timeout_val != 0) ? 1 : 0,
4884                         attached_dev_name,
4885                         min_plr,
4886                         max_plr,
4887                         slumber_partial,
4888                         pp_timeout_val,
4889                         timeout);
4890
4891         if (((retval = cam_send_ccb(device, ccb)) < 0)
4892          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
4893                 const char warnstr[] = "error sending command";
4894
4895                 if (retval < 0)
4896                         warn(warnstr);
4897                 else
4898                         warnx(warnstr);
4899
4900                 if (arglist & CAM_ARG_VERBOSE) {
4901                         /*
4902                          * Use CAM_EPF_NORMAL so we only get one line of
4903                          * SMP command decoding.
4904                          */
4905                         cam_error_print(device, ccb, CAM_ESF_ALL,
4906                                         CAM_EPF_NORMAL, stderr);
4907                 }
4908                 retval = 1;
4909                 goto bailout;
4910         }
4911
4912         /* XXX KDM print out something here for success? */
4913 bailout:
4914         if (ccb != NULL)
4915                 cam_freeccb(ccb);
4916
4917         if (request != NULL)
4918                 free(request);
4919
4920         if (response != NULL)
4921                 free(response);
4922
4923         return (retval);
4924 }
4925
4926 static int
4927 smpmaninfo(struct cam_device *device, int argc, char **argv,
4928            char *combinedopt, int retry_count, int timeout)
4929 {
4930         union ccb *ccb;
4931         struct smp_report_manuf_info_request request;
4932         struct smp_report_manuf_info_response response;
4933         struct sbuf *sb = NULL;
4934         int long_response = 0;
4935         int retval = 0;
4936         int c;
4937
4938         /*
4939          * Note that at the moment we don't support sending SMP CCBs to
4940          * devices that aren't probed by CAM.
4941          */
4942         ccb = cam_getccb(device);
4943         if (ccb == NULL) {
4944                 warnx("%s: error allocating CCB", __func__);
4945                 return (1);
4946         }
4947
4948         bzero(&(&ccb->ccb_h)[1],
4949               sizeof(union ccb) - sizeof(struct ccb_hdr));
4950
4951         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4952                 switch (c) {
4953                 case 'l':
4954                         long_response = 1;
4955                         break;
4956                 default:
4957                         break;
4958                 }
4959         }
4960         bzero(&request, sizeof(request));
4961         bzero(&response, sizeof(response));
4962
4963         smp_report_manuf_info(&ccb->smpio,
4964                               retry_count,
4965                               /*cbfcnp*/ NULL,
4966                               &request,
4967                               sizeof(request),
4968                               (uint8_t *)&response,
4969                               sizeof(response),
4970                               long_response,
4971                               timeout);
4972
4973         if (((retval = cam_send_ccb(device, ccb)) < 0)
4974          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
4975                 const char warnstr[] = "error sending command";
4976
4977                 if (retval < 0)
4978                         warn(warnstr);
4979                 else
4980                         warnx(warnstr);
4981
4982                 if (arglist & CAM_ARG_VERBOSE) {
4983                         cam_error_print(device, ccb, CAM_ESF_ALL,
4984                                         CAM_EPF_ALL, stderr);
4985                 }
4986                 retval = 1;
4987                 goto bailout;
4988         }
4989
4990         sb = sbuf_new_auto();
4991         if (sb == NULL) {
4992                 warnx("%s: error allocating sbuf", __func__);
4993                 goto bailout;
4994         }
4995
4996         smp_report_manuf_info_sbuf(&response, sizeof(response), sb);
4997
4998         sbuf_finish(sb);
4999
5000         printf("%s", sbuf_data(sb));
5001
5002 bailout:
5003
5004         if (ccb != NULL)
5005                 cam_freeccb(ccb);
5006
5007         if (sb != NULL)
5008                 sbuf_delete(sb);
5009
5010         return (retval);
5011 }
5012
5013 static int
5014 getdevid(struct cam_devitem *item)
5015 {
5016         int retval = 0;
5017         union ccb *ccb = NULL;
5018
5019         struct cam_device *dev;
5020
5021         dev = cam_open_btl(item->dev_match.path_id,
5022                            item->dev_match.target_id,
5023                            item->dev_match.target_lun, O_RDWR, NULL);
5024
5025         if (dev == NULL) {
5026                 warnx("%s", cam_errbuf);
5027                 retval = 1;
5028                 goto bailout;
5029         }
5030
5031         item->device_id_len = 0;
5032
5033         ccb = cam_getccb(dev);
5034         if (ccb == NULL) {
5035                 warnx("%s: error allocating CCB", __func__);
5036                 retval = 1;
5037                 goto bailout;
5038         }
5039
5040         bzero(&(&ccb->ccb_h)[1],
5041               sizeof(union ccb) - sizeof(struct ccb_hdr));
5042
5043         /*
5044          * On the first try, we just probe for the size of the data, and
5045          * then allocate that much memory and try again.
5046          */
5047 retry:
5048         ccb->ccb_h.func_code = XPT_DEV_ADVINFO;
5049         ccb->ccb_h.flags = CAM_DIR_IN;
5050         ccb->cdai.flags = 0;
5051         ccb->cdai.buftype = CDAI_TYPE_SCSI_DEVID;
5052         ccb->cdai.bufsiz = item->device_id_len;
5053         if (item->device_id_len != 0)
5054                 ccb->cdai.buf = (uint8_t *)item->device_id;
5055
5056         if (cam_send_ccb(dev, ccb) < 0) {
5057                 warn("%s: error sending XPT_GDEV_ADVINFO CCB", __func__);
5058                 retval = 1;
5059                 goto bailout;
5060         }
5061
5062         if (ccb->ccb_h.status != CAM_REQ_CMP) {
5063                 warnx("%s: CAM status %#x", __func__, ccb->ccb_h.status);
5064                 retval = 1;
5065                 goto bailout;
5066         }
5067
5068         if (item->device_id_len == 0) {
5069                 /*
5070                  * This is our first time through.  Allocate the buffer,
5071                  * and then go back to get the data.
5072                  */
5073                 if (ccb->cdai.provsiz == 0) {
5074                         warnx("%s: invalid .provsiz field returned with "
5075                              "XPT_GDEV_ADVINFO CCB", __func__);
5076                         retval = 1;
5077                         goto bailout;
5078                 }
5079                 item->device_id_len = ccb->cdai.provsiz;
5080                 item->device_id = malloc(item->device_id_len);
5081                 if (item->device_id == NULL) {
5082                         warn("%s: unable to allocate %d bytes", __func__,
5083                              item->device_id_len);
5084                         retval = 1;
5085                         goto bailout;
5086                 }
5087                 ccb->ccb_h.status = CAM_REQ_INPROG;
5088                 goto retry;
5089         }
5090
5091 bailout:
5092         if (dev != NULL)
5093                 cam_close_device(dev);
5094
5095         if (ccb != NULL)
5096                 cam_freeccb(ccb);
5097
5098         return (retval);
5099 }
5100
5101 /*
5102  * XXX KDM merge this code with getdevtree()?
5103  */
5104 static int
5105 buildbusdevlist(struct cam_devlist *devlist)
5106 {
5107         union ccb ccb;
5108         int bufsize, fd = -1;
5109         struct dev_match_pattern *patterns;
5110         struct cam_devitem *item = NULL;
5111         int skip_device = 0;
5112         int retval = 0;
5113
5114         if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
5115                 warn("couldn't open %s", XPT_DEVICE);
5116                 return(1);
5117         }
5118
5119         bzero(&ccb, sizeof(union ccb));
5120
5121         ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
5122         ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
5123         ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
5124
5125         ccb.ccb_h.func_code = XPT_DEV_MATCH;
5126         bufsize = sizeof(struct dev_match_result) * 100;
5127         ccb.cdm.match_buf_len = bufsize;
5128         ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
5129         if (ccb.cdm.matches == NULL) {
5130                 warnx("can't malloc memory for matches");
5131                 close(fd);
5132                 return(1);
5133         }
5134         ccb.cdm.num_matches = 0;
5135         ccb.cdm.num_patterns = 2;
5136         ccb.cdm.pattern_buf_len = sizeof(struct dev_match_pattern) *
5137                 ccb.cdm.num_patterns;
5138
5139         patterns = (struct dev_match_pattern *)malloc(ccb.cdm.pattern_buf_len);
5140         if (patterns == NULL) {
5141                 warnx("can't malloc memory for patterns");
5142                 retval = 1;
5143                 goto bailout;
5144         }
5145
5146         ccb.cdm.patterns = patterns;
5147         bzero(patterns, ccb.cdm.pattern_buf_len);
5148
5149         patterns[0].type = DEV_MATCH_DEVICE;
5150         patterns[0].pattern.device_pattern.flags = DEV_MATCH_PATH;
5151         patterns[0].pattern.device_pattern.path_id = devlist->path_id;
5152         patterns[1].type = DEV_MATCH_PERIPH;
5153         patterns[1].pattern.periph_pattern.flags = PERIPH_MATCH_PATH;
5154         patterns[1].pattern.periph_pattern.path_id = devlist->path_id;
5155
5156         /*
5157          * We do the ioctl multiple times if necessary, in case there are
5158          * more than 100 nodes in the EDT.
5159          */
5160         do {
5161                 unsigned int i;
5162
5163                 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
5164                         warn("error sending CAMIOCOMMAND ioctl");
5165                         retval = 1;
5166                         goto bailout;
5167                 }
5168
5169                 if ((ccb.ccb_h.status != CAM_REQ_CMP)
5170                  || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
5171                     && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
5172                         warnx("got CAM error %#x, CDM error %d\n",
5173                               ccb.ccb_h.status, ccb.cdm.status);
5174                         retval = 1;
5175                         goto bailout;
5176                 }
5177
5178                 for (i = 0; i < ccb.cdm.num_matches; i++) {
5179                         switch (ccb.cdm.matches[i].type) {
5180                         case DEV_MATCH_DEVICE: {
5181                                 struct device_match_result *dev_result;
5182
5183                                 dev_result =
5184                                      &ccb.cdm.matches[i].result.device_result;
5185
5186                                 if (dev_result->flags &
5187                                     DEV_RESULT_UNCONFIGURED) {
5188                                         skip_device = 1;
5189                                         break;
5190                                 } else
5191                                         skip_device = 0;
5192
5193                                 item = malloc(sizeof(*item));
5194                                 if (item == NULL) {
5195                                         warn("%s: unable to allocate %zd bytes",
5196                                              __func__, sizeof(*item));
5197                                         retval = 1;
5198                                         goto bailout;
5199                                 }
5200                                 bzero(item, sizeof(*item));
5201                                 bcopy(dev_result, &item->dev_match,
5202                                       sizeof(*dev_result));
5203                                 STAILQ_INSERT_TAIL(&devlist->dev_queue, item,
5204                                                    links);
5205
5206                                 if (getdevid(item) != 0) {
5207                                         retval = 1;
5208                                         goto bailout;
5209                                 }
5210                                 break;
5211                         }
5212                         case DEV_MATCH_PERIPH: {
5213                                 struct periph_match_result *periph_result;
5214
5215                                 periph_result =
5216                                       &ccb.cdm.matches[i].result.periph_result;
5217
5218                                 if (skip_device != 0)
5219                                         break;
5220                                 item->num_periphs++;
5221                                 item->periph_matches = realloc(
5222                                         item->periph_matches,
5223                                         item->num_periphs *
5224                                         sizeof(struct periph_match_result));
5225                                 if (item->periph_matches == NULL) {
5226                                         warn("%s: error allocating periph "
5227                                              "list", __func__);
5228                                         retval = 1;
5229                                         goto bailout;
5230                                 }
5231                                 bcopy(periph_result, &item->periph_matches[
5232                                       item->num_periphs - 1],
5233                                       sizeof(*periph_result));
5234                                 break;
5235                         }
5236                         default:
5237                                 fprintf(stderr, "%s: unexpected match "
5238                                         "type %d\n", __func__,
5239                                         ccb.cdm.matches[i].type);
5240                                 retval = 1;
5241                                 goto bailout;
5242                                 break; /*NOTREACHED*/
5243                         }
5244                 }
5245         } while ((ccb.ccb_h.status == CAM_REQ_CMP)
5246                 && (ccb.cdm.status == CAM_DEV_MATCH_MORE));
5247 bailout:
5248
5249         if (fd != -1)
5250                 close(fd);
5251
5252         free(patterns);
5253
5254         free(ccb.cdm.matches);
5255
5256         if (retval != 0)
5257                 freebusdevlist(devlist);
5258
5259         return (retval);
5260 }
5261
5262 static void
5263 freebusdevlist(struct cam_devlist *devlist)
5264 {
5265         struct cam_devitem *item, *item2;
5266
5267         STAILQ_FOREACH_SAFE(item, &devlist->dev_queue, links, item2) {
5268                 STAILQ_REMOVE(&devlist->dev_queue, item, cam_devitem,
5269                               links);
5270                 free(item->device_id);
5271                 free(item->periph_matches);
5272                 free(item);
5273         }
5274 }
5275
5276 static struct cam_devitem *
5277 findsasdevice(struct cam_devlist *devlist, uint64_t sasaddr)
5278 {
5279         struct cam_devitem *item;
5280
5281         STAILQ_FOREACH(item, &devlist->dev_queue, links) {
5282                 uint8_t *item_addr;
5283
5284                 /*
5285                  * XXX KDM look for LUN IDs as well?
5286                  */
5287                 item_addr = scsi_get_devid(item->device_id,
5288                                            item->device_id_len,
5289                                            scsi_devid_is_sas_target);
5290                 if (item_addr == NULL)
5291                         continue;
5292
5293                 if (scsi_8btou64(item_addr) == sasaddr)
5294                         return (item);
5295         }
5296
5297         return (NULL);
5298 }
5299
5300 static int
5301 smpphylist(struct cam_device *device, int argc, char **argv,
5302            char *combinedopt, int retry_count, int timeout)
5303 {
5304         struct smp_report_general_request *rgrequest = NULL;
5305         struct smp_report_general_response *rgresponse = NULL;
5306         struct smp_discover_request *disrequest = NULL;
5307         struct smp_discover_response *disresponse = NULL;
5308         struct cam_devlist devlist;
5309         union ccb *ccb;
5310         int long_response = 0;
5311         int num_phys = 0;
5312         int quiet = 0;
5313         int retval;
5314         int i, c;
5315
5316         /*
5317          * Note that at the moment we don't support sending SMP CCBs to
5318          * devices that aren't probed by CAM.
5319          */
5320         ccb = cam_getccb(device);
5321         if (ccb == NULL) {
5322                 warnx("%s: error allocating CCB", __func__);
5323                 return (1);
5324         }
5325
5326         bzero(&(&ccb->ccb_h)[1],
5327               sizeof(union ccb) - sizeof(struct ccb_hdr));
5328
5329         rgrequest = malloc(sizeof(*rgrequest));
5330         if (rgrequest == NULL) {
5331                 warn("%s: unable to allocate %zd bytes", __func__,
5332                      sizeof(*rgrequest));
5333                 retval = 1;
5334                 goto bailout;
5335         }
5336
5337         rgresponse = malloc(sizeof(*rgresponse));
5338         if (rgresponse == NULL) {
5339                 warn("%s: unable to allocate %zd bytes", __func__,
5340                      sizeof(*rgresponse));
5341                 retval = 1;
5342                 goto bailout;
5343         }
5344
5345         while ((c = getopt(argc, argv, combinedopt)) != -1) {
5346                 switch (c) {
5347                 case 'l':
5348                         long_response = 1;
5349                         break;
5350                 case 'q':
5351                         quiet = 1;
5352                         break;
5353                 default:
5354                         break;
5355                 }
5356         }
5357
5358         smp_report_general(&ccb->smpio,
5359                            retry_count,
5360                            /*cbfcnp*/ NULL,
5361                            rgrequest,
5362                            /*request_len*/ sizeof(*rgrequest),
5363                            (uint8_t *)rgresponse,
5364                            /*response_len*/ sizeof(*rgresponse),
5365                            /*long_response*/ long_response,
5366                            timeout);
5367
5368         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
5369
5370         if (((retval = cam_send_ccb(device, ccb)) < 0)
5371          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
5372                 const char warnstr[] = "error sending command";
5373
5374                 if (retval < 0)
5375                         warn(warnstr);
5376                 else
5377                         warnx(warnstr);
5378
5379                 if (arglist & CAM_ARG_VERBOSE) {
5380                         cam_error_print(device, ccb, CAM_ESF_ALL,
5381                                         CAM_EPF_ALL, stderr);
5382                 }
5383                 retval = 1;
5384                 goto bailout;
5385         }
5386
5387         num_phys = rgresponse->num_phys;
5388
5389         if (num_phys == 0) {
5390                 if (quiet == 0)
5391                         fprintf(stdout, "%s: No Phys reported\n", __func__);
5392                 retval = 1;
5393                 goto bailout;
5394         }
5395
5396         STAILQ_INIT(&devlist.dev_queue);
5397         devlist.path_id = device->path_id;
5398
5399         retval = buildbusdevlist(&devlist);
5400         if (retval != 0)
5401                 goto bailout;
5402
5403         if (quiet == 0) {
5404                 fprintf(stdout, "%d PHYs:\n", num_phys);
5405                 fprintf(stdout, "PHY  Attached SAS Address\n");
5406         }
5407
5408         disrequest = malloc(sizeof(*disrequest));
5409         if (disrequest == NULL) {
5410                 warn("%s: unable to allocate %zd bytes", __func__,
5411                      sizeof(*disrequest));
5412                 retval = 1;
5413                 goto bailout;
5414         }
5415
5416         disresponse = malloc(sizeof(*disresponse));
5417         if (disresponse == NULL) {
5418                 warn("%s: unable to allocate %zd bytes", __func__,
5419                      sizeof(*disresponse));
5420                 retval = 1;
5421                 goto bailout;
5422         }
5423
5424         for (i = 0; i < num_phys; i++) {
5425                 struct cam_devitem *item;
5426                 struct device_match_result *dev_match;
5427                 char vendor[16], product[48], revision[16];
5428                 char tmpstr[256];
5429                 int j;
5430
5431                 bzero(&(&ccb->ccb_h)[1],
5432                       sizeof(union ccb) - sizeof(struct ccb_hdr));
5433
5434                 ccb->ccb_h.status = CAM_REQ_INPROG;
5435                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
5436
5437                 smp_discover(&ccb->smpio,
5438                              retry_count,
5439                              /*cbfcnp*/ NULL,
5440                              disrequest,
5441                              sizeof(*disrequest),
5442                              (uint8_t *)disresponse,
5443                              sizeof(*disresponse),
5444                              long_response,
5445                              /*ignore_zone_group*/ 0,
5446                              /*phy*/ i,
5447                              timeout);
5448
5449                 if (((retval = cam_send_ccb(device, ccb)) < 0)
5450                  || (((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)
5451                   && (disresponse->function_result != SMP_FR_PHY_VACANT))) {
5452                         const char warnstr[] = "error sending command";
5453
5454                         if (retval < 0)
5455                                 warn(warnstr);
5456                         else
5457                                 warnx(warnstr);
5458
5459                         if (arglist & CAM_ARG_VERBOSE) {
5460                                 cam_error_print(device, ccb, CAM_ESF_ALL,
5461                                                 CAM_EPF_ALL, stderr);
5462                         }
5463                         retval = 1;
5464                         goto bailout;
5465                 }
5466
5467                 if (disresponse->function_result == SMP_FR_PHY_VACANT) {
5468                         if (quiet == 0)
5469                                 fprintf(stdout, "%3d  <vacant>\n", i);
5470                         continue;
5471                 }
5472
5473                 item = findsasdevice(&devlist,
5474                         scsi_8btou64(disresponse->attached_sas_address));
5475
5476                 if ((quiet == 0)
5477                  || (item != NULL)) {
5478                         fprintf(stdout, "%3d  0x%016jx", i,
5479                                 (uintmax_t)scsi_8btou64(
5480                                 disresponse->attached_sas_address));
5481                         if (item == NULL) {
5482                                 fprintf(stdout, "\n");
5483                                 continue;
5484                         }
5485                 } else if (quiet != 0)
5486                         continue;
5487
5488                 dev_match = &item->dev_match;
5489
5490                 if (dev_match->protocol == PROTO_SCSI) {
5491                         cam_strvis(vendor, dev_match->inq_data.vendor,
5492                                    sizeof(dev_match->inq_data.vendor),
5493                                    sizeof(vendor));
5494                         cam_strvis(product, dev_match->inq_data.product,
5495                                    sizeof(dev_match->inq_data.product),
5496                                    sizeof(product));
5497                         cam_strvis(revision, dev_match->inq_data.revision,
5498                                    sizeof(dev_match->inq_data.revision),
5499                                    sizeof(revision));
5500                         sprintf(tmpstr, "<%s %s %s>", vendor, product,
5501                                 revision);
5502                 } else if ((dev_match->protocol == PROTO_ATA)
5503                         || (dev_match->protocol == PROTO_SATAPM)) {
5504                         cam_strvis(product, dev_match->ident_data.model,
5505                                    sizeof(dev_match->ident_data.model),
5506                                    sizeof(product));
5507                         cam_strvis(revision, dev_match->ident_data.revision,
5508                                    sizeof(dev_match->ident_data.revision),
5509                                    sizeof(revision));
5510                         sprintf(tmpstr, "<%s %s>", product, revision);
5511                 } else {
5512                         sprintf(tmpstr, "<>");
5513                 }
5514                 fprintf(stdout, "   %-33s ", tmpstr);
5515
5516                 /*
5517                  * If we have 0 periphs, that's a bug...
5518                  */
5519                 if (item->num_periphs == 0) {
5520                         fprintf(stdout, "\n");
5521                         continue;
5522                 }
5523
5524                 fprintf(stdout, "(");
5525                 for (j = 0; j < item->num_periphs; j++) {
5526                         if (j > 0)
5527                                 fprintf(stdout, ",");
5528
5529                         fprintf(stdout, "%s%d",
5530                                 item->periph_matches[j].periph_name,
5531                                 item->periph_matches[j].unit_number);
5532
5533                 }
5534                 fprintf(stdout, ")\n");
5535         }
5536 bailout:
5537         if (ccb != NULL)
5538                 cam_freeccb(ccb);
5539
5540         free(rgrequest);
5541
5542         free(rgresponse);
5543
5544         free(disrequest);
5545
5546         free(disresponse);
5547
5548         freebusdevlist(&devlist);
5549
5550         return (retval);
5551 }
5552
5553 static int
5554 atapm(struct cam_device *device, int argc, char **argv,
5555                  char *combinedopt, int retry_count, int timeout)
5556 {
5557         union ccb *ccb;
5558         int retval = 0;
5559         int t = -1;
5560         int c;
5561         u_char cmd, sc;
5562
5563         ccb = cam_getccb(device);
5564
5565         if (ccb == NULL) {
5566                 warnx("%s: error allocating ccb", __func__);
5567                 return (1);
5568         }
5569
5570         while ((c = getopt(argc, argv, combinedopt)) != -1) {
5571                 switch (c) {
5572                 case 't':
5573                         t = atoi(optarg);
5574                         break;
5575                 default:
5576                         break;
5577                 }
5578         }
5579         if (strcmp(argv[1], "idle") == 0) {
5580                 if (t == -1)
5581                         cmd = ATA_IDLE_IMMEDIATE;
5582                 else
5583                         cmd = ATA_IDLE_CMD;
5584         } else if (strcmp(argv[1], "standby") == 0) {
5585                 if (t == -1)
5586                         cmd = ATA_STANDBY_IMMEDIATE;
5587                 else
5588                         cmd = ATA_STANDBY_CMD;
5589         } else {
5590                 cmd = ATA_SLEEP;
5591                 t = -1;
5592         }
5593
5594         if (t < 0)
5595                 sc = 0;
5596         else if (t <= (240 * 5))
5597                 sc = (t + 4) / 5;
5598         else if (t <= (252 * 5))
5599                 /* special encoding for 21 minutes */
5600                 sc = 252;
5601         else if (t <= (11 * 30 * 60))
5602                 sc = (t - 1) / (30 * 60) + 241;
5603         else
5604                 sc = 253;
5605
5606         cam_fill_ataio(&ccb->ataio,
5607                       retry_count,
5608                       NULL,
5609                       /*flags*/CAM_DIR_NONE,
5610                       MSG_SIMPLE_Q_TAG,
5611                       /*data_ptr*/NULL,
5612                       /*dxfer_len*/0,
5613                       timeout ? timeout : 30 * 1000);
5614         ata_28bit_cmd(&ccb->ataio, cmd, 0, 0, sc);
5615
5616         /* Disable freezing the device queue */
5617         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
5618
5619         if (arglist & CAM_ARG_ERR_RECOVER)
5620                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
5621
5622         if (cam_send_ccb(device, ccb) < 0) {
5623                 warn("error sending command");
5624
5625                 if (arglist & CAM_ARG_VERBOSE)
5626                         cam_error_print(device, ccb, CAM_ESF_ALL,
5627                                         CAM_EPF_ALL, stderr);
5628
5629                 retval = 1;
5630                 goto bailout;
5631         }
5632
5633         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5634                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
5635                 retval = 1;
5636                 goto bailout;
5637         }
5638 bailout:
5639         cam_freeccb(ccb);
5640         return (retval);
5641 }
5642
5643 #endif /* MINIMALISTIC */
5644
5645 void
5646 usage(int verbose)
5647 {
5648         fprintf(verbose ? stdout : stderr,
5649 "usage:  camcontrol <command>  [device id][generic args][command args]\n"
5650 "        camcontrol devlist    [-v]\n"
5651 #ifndef MINIMALISTIC
5652 "        camcontrol periphlist [dev_id][-n dev_name] [-u unit]\n"
5653 "        camcontrol tur        [dev_id][generic args]\n"
5654 "        camcontrol inquiry    [dev_id][generic args] [-D] [-S] [-R]\n"
5655 "        camcontrol identify   [dev_id][generic args] [-v]\n"
5656 "        camcontrol reportluns [dev_id][generic args] [-c] [-l] [-r report]\n"
5657 "        camcontrol readcap    [dev_id][generic args] [-b] [-h] [-H] [-N]\n"
5658 "                              [-q] [-s]\n"
5659 "        camcontrol start      [dev_id][generic args]\n"
5660 "        camcontrol stop       [dev_id][generic args]\n"
5661 "        camcontrol load       [dev_id][generic args]\n"
5662 "        camcontrol eject      [dev_id][generic args]\n"
5663 #endif /* MINIMALISTIC */
5664 "        camcontrol rescan     <all | bus[:target:lun]>\n"
5665 "        camcontrol reset      <all | bus[:target:lun]>\n"
5666 #ifndef MINIMALISTIC
5667 "        camcontrol defects    [dev_id][generic args] <-f format> [-P][-G]\n"
5668 "        camcontrol modepage   [dev_id][generic args] <-m page | -l>\n"
5669 "                              [-P pagectl][-e | -b][-d]\n"
5670 "        camcontrol cmd        [dev_id][generic args]\n"
5671 "                              <-a cmd [args] | -c cmd [args]>\n"
5672 "                              [-d] [-f] [-i len fmt|-o len fmt [args]] [-r fmt]\n"
5673 "        camcontrol smpcmd     [dev_id][generic args]\n"
5674 "                              <-r len fmt [args]> <-R len fmt [args]>\n"
5675 "        camcontrol smprg      [dev_id][generic args][-l]\n"
5676 "        camcontrol smppc      [dev_id][generic args] <-p phy> [-l]\n"
5677 "                              [-o operation][-d name][-m rate][-M rate]\n"
5678 "                              [-T pp_timeout][-a enable|disable]\n"
5679 "                              [-A enable|disable][-s enable|disable]\n"
5680 "                              [-S enable|disable]\n"
5681 "        camcontrol smpphylist [dev_id][generic args][-l][-q]\n"
5682 "        camcontrol smpmaninfo [dev_id][generic args][-l]\n"
5683 "        camcontrol debug      [-I][-P][-T][-S][-X][-c]\n"
5684 "                              <all|bus[:target[:lun]]|off>\n"
5685 "        camcontrol tags       [dev_id][generic args] [-N tags] [-q] [-v]\n"
5686 "        camcontrol negotiate  [dev_id][generic args] [-a][-c]\n"
5687 "                              [-D <enable|disable>][-M mode][-O offset]\n"
5688 "                              [-q][-R syncrate][-v][-T <enable|disable>]\n"
5689 "                              [-U][-W bus_width]\n"
5690 "        camcontrol format     [dev_id][generic args][-q][-r][-w][-y]\n"
5691 "        camcontrol idle       [dev_id][generic args][-t time]\n"
5692 "        camcontrol standby    [dev_id][generic args][-t time]\n"
5693 "        camcontrol sleep      [dev_id][generic args]\n"
5694 #endif /* MINIMALISTIC */
5695 "        camcontrol help\n");
5696         if (!verbose)
5697                 return;
5698 #ifndef MINIMALISTIC
5699         fprintf(stdout,
5700 "Specify one of the following options:\n"
5701 "devlist     list all CAM devices\n"
5702 "periphlist  list all CAM peripheral drivers attached to a device\n"
5703 "tur         send a test unit ready to the named device\n"
5704 "inquiry     send a SCSI inquiry command to the named device\n"
5705 "identify    send a ATA identify command to the named device\n"
5706 "reportluns  send a SCSI report luns command to the device\n"
5707 "readcap     send a SCSI read capacity command to the device\n"
5708 "start       send a Start Unit command to the device\n"
5709 "stop        send a Stop Unit command to the device\n"
5710 "load        send a Start Unit command to the device with the load bit set\n"
5711 "eject       send a Stop Unit command to the device with the eject bit set\n"
5712 "rescan      rescan all busses, the given bus, or bus:target:lun\n"
5713 "reset       reset all busses, the given bus, or bus:target:lun\n"
5714 "defects     read the defect list of the specified device\n"
5715 "modepage    display or edit (-e) the given mode page\n"
5716 "cmd         send the given SCSI command, may need -i or -o as well\n"
5717 "smpcmd      send the given SMP command, requires -o and -i\n"
5718 "smprg       send the SMP Report General command\n"
5719 "smppc       send the SMP PHY Control command, requires -p\n"
5720 "smpphylist  display phys attached to a SAS expander\n"
5721 "smpmaninfo  send the SMP Report Manufacturer Info command\n"
5722 "debug       turn debugging on/off for a bus, target, or lun, or all devices\n"
5723 "tags        report or set the number of transaction slots for a device\n"
5724 "negotiate   report or set device negotiation parameters\n"
5725 "format      send the SCSI FORMAT UNIT command to the named device\n"
5726 "idle        send the ATA IDLE command to the named device\n"
5727 "standby     send the ATA STANDBY command to the named device\n"
5728 "sleep       send the ATA SLEEP command to the named device\n"
5729 "help        this message\n"
5730 "Device Identifiers:\n"
5731 "bus:target        specify the bus and target, lun defaults to 0\n"
5732 "bus:target:lun    specify the bus, target and lun\n"
5733 "deviceUNIT        specify the device name, like \"da4\" or \"cd2\"\n"
5734 "Generic arguments:\n"
5735 "-v                be verbose, print out sense information\n"
5736 "-t timeout        command timeout in seconds, overrides default timeout\n"
5737 "-n dev_name       specify device name, e.g. \"da\", \"cd\"\n"
5738 "-u unit           specify unit number, e.g. \"0\", \"5\"\n"
5739 "-E                have the kernel attempt to perform SCSI error recovery\n"
5740 "-C count          specify the SCSI command retry count (needs -E to work)\n"
5741 "modepage arguments:\n"
5742 "-l                list all available mode pages\n"
5743 "-m page           specify the mode page to view or edit\n"
5744 "-e                edit the specified mode page\n"
5745 "-b                force view to binary mode\n"
5746 "-d                disable block descriptors for mode sense\n"
5747 "-P pgctl          page control field 0-3\n"
5748 "defects arguments:\n"
5749 "-f format         specify defect list format (block, bfi or phys)\n"
5750 "-G                get the grown defect list\n"
5751 "-P                get the permanant defect list\n"
5752 "inquiry arguments:\n"
5753 "-D                get the standard inquiry data\n"
5754 "-S                get the serial number\n"
5755 "-R                get the transfer rate, etc.\n"
5756 "reportluns arguments:\n"
5757 "-c                only report a count of available LUNs\n"
5758 "-l                only print out luns, and not a count\n"
5759 "-r <reporttype>   specify \"default\", \"wellknown\" or \"all\"\n"
5760 "readcap arguments\n"
5761 "-b                only report the blocksize\n"
5762 "-h                human readable device size, base 2\n"
5763 "-H                human readable device size, base 10\n"
5764 "-N                print the number of blocks instead of last block\n"
5765 "-q                quiet, print numbers only\n"
5766 "-s                only report the last block/device size\n"
5767 "cmd arguments:\n"
5768 "-c cdb [args]     specify the SCSI CDB\n"
5769 "-i len fmt        specify input data and input data format\n"
5770 "-o len fmt [args] specify output data and output data fmt\n"
5771 "smpcmd arguments:\n"
5772 "-r len fmt [args] specify the SMP command to be sent\n"
5773 "-R len fmt [args] specify SMP response format\n"
5774 "smprg arguments:\n"
5775 "-l                specify the long response format\n"
5776 "smppc arguments:\n"
5777 "-p phy            specify the PHY to operate on\n"
5778 "-l                specify the long request/response format\n"
5779 "-o operation      specify the phy control operation\n"
5780 "-d name           set the attached device name\n"
5781 "-m rate           set the minimum physical link rate\n"
5782 "-M rate           set the maximum physical link rate\n"
5783 "-T pp_timeout     set the partial pathway timeout value\n"
5784 "-a enable|disable enable or disable SATA slumber\n"
5785 "-A enable|disable enable or disable SATA partial phy power\n"
5786 "-s enable|disable enable or disable SAS slumber\n"
5787 "-S enable|disable enable or disable SAS partial phy power\n"
5788 "smpphylist arguments:\n"
5789 "-l                specify the long response format\n"
5790 "-q                only print phys with attached devices\n"
5791 "smpmaninfo arguments:\n"
5792 "-l                specify the long response format\n"
5793 "debug arguments:\n"
5794 "-I                CAM_DEBUG_INFO -- scsi commands, errors, data\n"
5795 "-T                CAM_DEBUG_TRACE -- routine flow tracking\n"
5796 "-S                CAM_DEBUG_SUBTRACE -- internal routine command flow\n"
5797 "-c                CAM_DEBUG_CDB -- print out SCSI CDBs only\n"
5798 "tags arguments:\n"
5799 "-N tags           specify the number of tags to use for this device\n"
5800 "-q                be quiet, don't report the number of tags\n"
5801 "-v                report a number of tag-related parameters\n"
5802 "negotiate arguments:\n"
5803 "-a                send a test unit ready after negotiation\n"
5804 "-c                report/set current negotiation settings\n"
5805 "-D <arg>          \"enable\" or \"disable\" disconnection\n"
5806 "-M mode           set ATA mode\n"
5807 "-O offset         set command delay offset\n"
5808 "-q                be quiet, don't report anything\n"
5809 "-R syncrate       synchronization rate in MHz\n"
5810 "-T <arg>          \"enable\" or \"disable\" tagged queueing\n"
5811 "-U                report/set user negotiation settings\n"
5812 "-W bus_width      set the bus width in bits (8, 16 or 32)\n"
5813 "-v                also print a Path Inquiry CCB for the controller\n"
5814 "format arguments:\n"
5815 "-q                be quiet, don't print status messages\n"
5816 "-r                run in report only mode\n"
5817 "-w                don't send immediate format command\n"
5818 "-y                don't ask any questions\n"
5819 "idle/standby arguments:\n"
5820 "-t <arg>          number of seconds before respective state.\n");
5821 #endif /* MINIMALISTIC */
5822 }
5823
5824 int
5825 main(int argc, char **argv)
5826 {
5827         int c;
5828         char *device = NULL;
5829         int unit = 0;
5830         struct cam_device *cam_dev = NULL;
5831         int timeout = 0, retry_count = 1;
5832         camcontrol_optret optreturn;
5833         char *tstr;
5834         const char *mainopt = "C:En:t:u:v";
5835         const char *subopt = NULL;
5836         char combinedopt[256];
5837         int error = 0, optstart = 2;
5838         int devopen = 1;
5839 #ifndef MINIMALISTIC
5840         int bus, target, lun;
5841 #endif /* MINIMALISTIC */
5842
5843         cmdlist = CAM_CMD_NONE;
5844         arglist = CAM_ARG_NONE;
5845
5846         if (argc < 2) {
5847                 usage(0);
5848                 exit(1);
5849         }
5850
5851         /*
5852          * Get the base option.
5853          */
5854         optreturn = getoption(option_table,argv[1], &cmdlist, &arglist,&subopt);
5855
5856         if (optreturn == CC_OR_AMBIGUOUS) {
5857                 warnx("ambiguous option %s", argv[1]);
5858                 usage(0);
5859                 exit(1);
5860         } else if (optreturn == CC_OR_NOT_FOUND) {
5861                 warnx("option %s not found", argv[1]);
5862                 usage(0);
5863                 exit(1);
5864         }
5865
5866         /*
5867          * Ahh, getopt(3) is a pain.
5868          *
5869          * This is a gross hack.  There really aren't many other good
5870          * options (excuse the pun) for parsing options in a situation like
5871          * this.  getopt is kinda braindead, so you end up having to run
5872          * through the options twice, and give each invocation of getopt
5873          * the option string for the other invocation.
5874          *
5875          * You would think that you could just have two groups of options.
5876          * The first group would get parsed by the first invocation of
5877          * getopt, and the second group would get parsed by the second
5878          * invocation of getopt.  It doesn't quite work out that way.  When
5879          * the first invocation of getopt finishes, it leaves optind pointing
5880          * to the argument _after_ the first argument in the second group.
5881          * So when the second invocation of getopt comes around, it doesn't
5882          * recognize the first argument it gets and then bails out.
5883          *
5884          * A nice alternative would be to have a flag for getopt that says
5885          * "just keep parsing arguments even when you encounter an unknown
5886          * argument", but there isn't one.  So there's no real clean way to
5887          * easily parse two sets of arguments without having one invocation
5888          * of getopt know about the other.
5889          *
5890          * Without this hack, the first invocation of getopt would work as
5891          * long as the generic arguments are first, but the second invocation
5892          * (in the subfunction) would fail in one of two ways.  In the case
5893          * where you don't set optreset, it would fail because optind may be
5894          * pointing to the argument after the one it should be pointing at.
5895          * In the case where you do set optreset, and reset optind, it would
5896          * fail because getopt would run into the first set of options, which
5897          * it doesn't understand.
5898          *
5899          * All of this would "sort of" work if you could somehow figure out
5900          * whether optind had been incremented one option too far.  The
5901          * mechanics of that, however, are more daunting than just giving
5902          * both invocations all of the expect options for either invocation.
5903          *
5904          * Needless to say, I wouldn't mind if someone invented a better
5905          * (non-GPL!) command line parsing interface than getopt.  I
5906          * wouldn't mind if someone added more knobs to getopt to make it
5907          * work better.  Who knows, I may talk myself into doing it someday,
5908          * if the standards weenies let me.  As it is, it just leads to
5909          * hackery like this and causes people to avoid it in some cases.
5910          *
5911          * KDM, September 8th, 1998
5912          */
5913         if (subopt != NULL)
5914                 sprintf(combinedopt, "%s%s", mainopt, subopt);
5915         else
5916                 sprintf(combinedopt, "%s", mainopt);
5917
5918         /*
5919          * For these options we do not parse optional device arguments and
5920          * we do not open a passthrough device.
5921          */
5922         if ((cmdlist == CAM_CMD_RESCAN)
5923          || (cmdlist == CAM_CMD_RESET)
5924          || (cmdlist == CAM_CMD_DEVTREE)
5925          || (cmdlist == CAM_CMD_USAGE)
5926          || (cmdlist == CAM_CMD_DEBUG))
5927                 devopen = 0;
5928
5929 #ifndef MINIMALISTIC
5930         if ((devopen == 1)
5931          && (argc > 2 && argv[2][0] != '-')) {
5932                 char name[30];
5933                 int rv;
5934
5935                 if (isdigit(argv[2][0])) {
5936                         /* device specified as bus:target[:lun] */
5937                         rv = parse_btl(argv[2], &bus, &target, &lun, &arglist);
5938                         if (rv < 2)
5939                                 errx(1, "numeric device specification must "
5940                                      "be either bus:target, or "
5941                                      "bus:target:lun");
5942                         /* default to 0 if lun was not specified */
5943                         if ((arglist & CAM_ARG_LUN) == 0) {
5944                                 lun = 0;
5945                                 arglist |= CAM_ARG_LUN;
5946                         }
5947                         optstart++;
5948                 } else {
5949                         if (cam_get_device(argv[2], name, sizeof name, &unit)
5950                             == -1)
5951                                 errx(1, "%s", cam_errbuf);
5952                         device = strdup(name);
5953                         arglist |= CAM_ARG_DEVICE | CAM_ARG_UNIT;
5954                         optstart++;
5955                 }
5956         }
5957 #endif /* MINIMALISTIC */
5958         /*
5959          * Start getopt processing at argv[2/3], since we've already
5960          * accepted argv[1..2] as the command name, and as a possible
5961          * device name.
5962          */
5963         optind = optstart;
5964
5965         /*
5966          * Now we run through the argument list looking for generic
5967          * options, and ignoring options that possibly belong to
5968          * subfunctions.
5969          */
5970         while ((c = getopt(argc, argv, combinedopt))!= -1){
5971                 switch(c) {
5972                         case 'C':
5973                                 retry_count = strtol(optarg, NULL, 0);
5974                                 if (retry_count < 0)
5975                                         errx(1, "retry count %d is < 0",
5976                                              retry_count);
5977                                 arglist |= CAM_ARG_RETRIES;
5978                                 break;
5979                         case 'E':
5980                                 arglist |= CAM_ARG_ERR_RECOVER;
5981                                 break;
5982                         case 'n':
5983                                 arglist |= CAM_ARG_DEVICE;
5984                                 tstr = optarg;
5985                                 while (isspace(*tstr) && (*tstr != '\0'))
5986                                         tstr++;
5987                                 device = (char *)strdup(tstr);
5988                                 break;
5989                         case 't':
5990                                 timeout = strtol(optarg, NULL, 0);
5991                                 if (timeout < 0)
5992                                         errx(1, "invalid timeout %d", timeout);
5993                                 /* Convert the timeout from seconds to ms */
5994                                 timeout *= 1000;
5995                                 arglist |= CAM_ARG_TIMEOUT;
5996                                 break;
5997                         case 'u':
5998                                 arglist |= CAM_ARG_UNIT;
5999                                 unit = strtol(optarg, NULL, 0);
6000                                 break;
6001                         case 'v':
6002                                 arglist |= CAM_ARG_VERBOSE;
6003                                 break;
6004                         default:
6005                                 break;
6006                 }
6007         }
6008
6009 #ifndef MINIMALISTIC
6010         /*
6011          * For most commands we'll want to open the passthrough device
6012          * associated with the specified device.  In the case of the rescan
6013          * commands, we don't use a passthrough device at all, just the
6014          * transport layer device.
6015          */
6016         if (devopen == 1) {
6017                 if (((arglist & (CAM_ARG_BUS|CAM_ARG_TARGET)) == 0)
6018                  && (((arglist & CAM_ARG_DEVICE) == 0)
6019                   || ((arglist & CAM_ARG_UNIT) == 0))) {
6020                         errx(1, "subcommand \"%s\" requires a valid device "
6021                              "identifier", argv[1]);
6022                 }
6023
6024                 if ((cam_dev = ((arglist & (CAM_ARG_BUS | CAM_ARG_TARGET))?
6025                                 cam_open_btl(bus, target, lun, O_RDWR, NULL) :
6026                                 cam_open_spec_device(device,unit,O_RDWR,NULL)))
6027                      == NULL)
6028                         errx(1,"%s", cam_errbuf);
6029         }
6030 #endif /* MINIMALISTIC */
6031
6032         /*
6033          * Reset optind to 2, and reset getopt, so these routines can parse
6034          * the arguments again.
6035          */
6036         optind = optstart;
6037         optreset = 1;
6038
6039         switch(cmdlist) {
6040 #ifndef MINIMALISTIC
6041                 case CAM_CMD_DEVLIST:
6042                         error = getdevlist(cam_dev);
6043                         break;
6044 #endif /* MINIMALISTIC */
6045                 case CAM_CMD_DEVTREE:
6046                         error = getdevtree();
6047                         break;
6048 #ifndef MINIMALISTIC
6049                 case CAM_CMD_TUR:
6050                         error = testunitready(cam_dev, retry_count, timeout, 0);
6051                         break;
6052                 case CAM_CMD_INQUIRY:
6053                         error = scsidoinquiry(cam_dev, argc, argv, combinedopt,
6054                                               retry_count, timeout);
6055                         break;
6056                 case CAM_CMD_IDENTIFY:
6057                         error = ataidentify(cam_dev, retry_count, timeout);
6058                         break;
6059                 case CAM_CMD_STARTSTOP:
6060                         error = scsistart(cam_dev, arglist & CAM_ARG_START_UNIT,
6061                                           arglist & CAM_ARG_EJECT, retry_count,
6062                                           timeout);
6063                         break;
6064 #endif /* MINIMALISTIC */
6065                 case CAM_CMD_RESCAN:
6066                         error = dorescan_or_reset(argc, argv, 1);
6067                         break;
6068                 case CAM_CMD_RESET:
6069                         error = dorescan_or_reset(argc, argv, 0);
6070                         break;
6071 #ifndef MINIMALISTIC
6072                 case CAM_CMD_READ_DEFECTS:
6073                         error = readdefects(cam_dev, argc, argv, combinedopt,
6074                                             retry_count, timeout);
6075                         break;
6076                 case CAM_CMD_MODE_PAGE:
6077                         modepage(cam_dev, argc, argv, combinedopt,
6078                                  retry_count, timeout);
6079                         break;
6080                 case CAM_CMD_SCSI_CMD:
6081                         error = scsicmd(cam_dev, argc, argv, combinedopt,
6082                                         retry_count, timeout);
6083                         break;
6084                 case CAM_CMD_SMP_CMD:
6085                         error = smpcmd(cam_dev, argc, argv, combinedopt,
6086                                        retry_count, timeout);
6087                         break;
6088                 case CAM_CMD_SMP_RG:
6089                         error = smpreportgeneral(cam_dev, argc, argv,
6090                                                  combinedopt, retry_count,
6091                                                  timeout);
6092                         break;
6093                 case CAM_CMD_SMP_PC:
6094                         error = smpphycontrol(cam_dev, argc, argv, combinedopt,
6095                                               retry_count, timeout);
6096                         break;
6097                 case CAM_CMD_SMP_PHYLIST:
6098                         error = smpphylist(cam_dev, argc, argv, combinedopt,
6099                                            retry_count, timeout);
6100                         break;
6101                 case CAM_CMD_SMP_MANINFO:
6102                         error = smpmaninfo(cam_dev, argc, argv, combinedopt,
6103                                            retry_count, timeout);
6104                         break;
6105                 case CAM_CMD_DEBUG:
6106                         error = camdebug(argc, argv, combinedopt);
6107                         break;
6108                 case CAM_CMD_TAG:
6109                         error = tagcontrol(cam_dev, argc, argv, combinedopt);
6110                         break;
6111                 case CAM_CMD_RATE:
6112                         error = ratecontrol(cam_dev, retry_count, timeout,
6113                                             argc, argv, combinedopt);
6114                         break;
6115                 case CAM_CMD_FORMAT:
6116                         error = scsiformat(cam_dev, argc, argv,
6117                                            combinedopt, retry_count, timeout);
6118                         break;
6119                 case CAM_CMD_REPORTLUNS:
6120                         error = scsireportluns(cam_dev, argc, argv,
6121                                                combinedopt, retry_count,
6122                                                timeout);
6123                         break;
6124                 case CAM_CMD_READCAP:
6125                         error = scsireadcapacity(cam_dev, argc, argv,
6126                                                  combinedopt, retry_count,
6127                                                  timeout);
6128                         break;
6129                 case CAM_CMD_IDLE:
6130                 case CAM_CMD_STANDBY:
6131                 case CAM_CMD_SLEEP:
6132                         error = atapm(cam_dev, argc, argv,
6133                                                  combinedopt, retry_count,
6134                                                  timeout);
6135                         break;
6136 #endif /* MINIMALISTIC */
6137                 case CAM_CMD_USAGE:
6138                         usage(1);
6139                         break;
6140                 default:
6141                         usage(0);
6142                         error = 1;
6143                         break;
6144         }
6145
6146         if (cam_dev != NULL)
6147                 cam_close_device(cam_dev);
6148
6149         exit(error);
6150 }