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/stat.h>
  36 #include <sys/endian.h>
  37 #include <sys/sbuf.h>
  38
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <unistd.h>
  43 #include <inttypes.h>
  44 #include <limits.h>
  45 #include <fcntl.h>
  46 #include <ctype.h>
  47 #include <err.h>
  48 #include <libutil.h>
  49 #include <limits.h>
  50 #include <inttypes.h>
  51
  52 #include <cam/cam.h>
  53 #include <cam/cam_debug.h>
  54 #include <cam/cam_ccb.h>
  55 #include <cam/scsi/scsi_all.h>
  56 #include <cam/scsi/scsi_da.h>
  57 #include <cam/scsi/scsi_pass.h>
  58 #include <cam/scsi/scsi_message.h>
  59 #include <cam/scsi/smp_all.h>
  60 #include <cam/ata/ata_all.h>
  61 #include <cam/mmc/mmc_all.h>
  62 #include <camlib.h>
  63 #include "camcontrol.h"
  64 #ifdef WITH_NVME
  65 #include "nvmecontrol_ext.h"
  66 #endif
  67
  68 typedef enum {
  69         CAM_CMD_NONE,
  70         CAM_CMD_DEVLIST,
  71         CAM_CMD_TUR,
  72         CAM_CMD_INQUIRY,
  73         CAM_CMD_STARTSTOP,
  74         CAM_CMD_RESCAN,
  75         CAM_CMD_READ_DEFECTS,
  76         CAM_CMD_MODE_PAGE,
  77         CAM_CMD_SCSI_CMD,
  78         CAM_CMD_DEVTREE,
  79         CAM_CMD_USAGE,
  80         CAM_CMD_DEBUG,
  81         CAM_CMD_RESET,
  82         CAM_CMD_FORMAT,
  83         CAM_CMD_TAG,
  84         CAM_CMD_RATE,
  85         CAM_CMD_DETACH,
  86         CAM_CMD_REPORTLUNS,
  87         CAM_CMD_READCAP,
  88         CAM_CMD_IDENTIFY,
  89         CAM_CMD_IDLE,
  90         CAM_CMD_STANDBY,
  91         CAM_CMD_SLEEP,
  92         CAM_CMD_SMP_CMD,
  93         CAM_CMD_SMP_RG,
  94         CAM_CMD_SMP_PC,
  95         CAM_CMD_SMP_PHYLIST,
  96         CAM_CMD_SMP_MANINFO,
  97         CAM_CMD_DOWNLOAD_FW,
  98         CAM_CMD_SECURITY,
  99         CAM_CMD_HPA,
 100         CAM_CMD_SANITIZE,
 101         CAM_CMD_PERSIST,
 102         CAM_CMD_APM,
 103         CAM_CMD_AAM,
 104         CAM_CMD_ATTRIB,
 105         CAM_CMD_OPCODES,
 106         CAM_CMD_REPROBE,
 107         CAM_CMD_ZONE,
 108         CAM_CMD_EPC,
 109         CAM_CMD_TIMESTAMP,
 110         CAM_CMD_MMCSD_CMD,
 111         CAM_CMD_POWER_MODE,
 112         CAM_CMD_DEVTYPE,
 113         CAM_CMD_AMA,
 114 } cam_cmd;
 115
 116 typedef enum {
 117         CAM_ARG_NONE            = 0x00000000,
 118         CAM_ARG_VERBOSE         = 0x00000001,
 119         CAM_ARG_DEVICE          = 0x00000002,
 120         CAM_ARG_BUS             = 0x00000004,
 121         CAM_ARG_TARGET          = 0x00000008,
 122         CAM_ARG_LUN             = 0x00000010,
 123         CAM_ARG_EJECT           = 0x00000020,
 124         CAM_ARG_UNIT            = 0x00000040,
 125         CAM_ARG_FORMAT_BLOCK    = 0x00000080,
 126         CAM_ARG_FORMAT_BFI      = 0x00000100,
 127         CAM_ARG_FORMAT_PHYS     = 0x00000200,
 128         CAM_ARG_PLIST           = 0x00000400,
 129         CAM_ARG_GLIST           = 0x00000800,
 130         CAM_ARG_GET_SERIAL      = 0x00001000,
 131         CAM_ARG_GET_STDINQ      = 0x00002000,
 132         CAM_ARG_GET_XFERRATE    = 0x00004000,
 133         CAM_ARG_INQ_MASK        = 0x00007000,
 134         CAM_ARG_TIMEOUT         = 0x00020000,
 135         CAM_ARG_CMD_IN          = 0x00040000,
 136         CAM_ARG_CMD_OUT         = 0x00080000,
 137         CAM_ARG_ERR_RECOVER     = 0x00200000,
 138         CAM_ARG_RETRIES         = 0x00400000,
 139         CAM_ARG_START_UNIT      = 0x00800000,
 140         CAM_ARG_DEBUG_INFO      = 0x01000000,
 141         CAM_ARG_DEBUG_TRACE     = 0x02000000,
 142         CAM_ARG_DEBUG_SUBTRACE  = 0x04000000,
 143         CAM_ARG_DEBUG_CDB       = 0x08000000,
 144         CAM_ARG_DEBUG_XPT       = 0x10000000,
 145         CAM_ARG_DEBUG_PERIPH    = 0x20000000,
 146         CAM_ARG_DEBUG_PROBE     = 0x40000000,
 147 } cam_argmask;
 148
 149 struct camcontrol_opts {
 150         const char      *optname;
 151         uint32_t        cmdnum;
 152         cam_argmask     argnum;
 153         const char      *subopt;
 154 };
 155
 156 struct ata_set_max_pwd
 157 {
 158         u_int16_t reserved1;
 159         u_int8_t password[32];
 160         u_int16_t reserved2[239];
 161 };
 162
 163 static struct scsi_nv task_attrs[] = {
 164         { "simple", MSG_SIMPLE_Q_TAG },
 165         { "head", MSG_HEAD_OF_Q_TAG },
 166         { "ordered", MSG_ORDERED_Q_TAG },
 167         { "iwr", MSG_IGN_WIDE_RESIDUE },
 168         { "aca", MSG_ACA_TASK }
 169 };
 170
 171 static const char scsicmd_opts[] = "a:c:dfi:o:r";
 172 static const char readdefect_opts[] = "f:GPqsS:X";
 173 static const char negotiate_opts[] = "acD:M:O:qR:T:UW:";
 174 static const char smprg_opts[] = "l";
 175 static const char smppc_opts[] = "a:A:d:lm:M:o:p:s:S:T:";
 176 static const char smpphylist_opts[] = "lq";
 177 static char pwd_opt;
 178
 179 static struct camcontrol_opts option_table[] = {
 180         {"tur", CAM_CMD_TUR, CAM_ARG_NONE, NULL},
 181         {"inquiry", CAM_CMD_INQUIRY, CAM_ARG_NONE, "DSR"},
 182         {"identify", CAM_CMD_IDENTIFY, CAM_ARG_NONE, NULL},
 183         {"start", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT, NULL},
 184         {"stop", CAM_CMD_STARTSTOP, CAM_ARG_NONE, NULL},
 185         {"load", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT | CAM_ARG_EJECT, NULL},
 186         {"eject", CAM_CMD_STARTSTOP, CAM_ARG_EJECT, NULL},
 187         {"reportluns", CAM_CMD_REPORTLUNS, CAM_ARG_NONE, "clr:"},
 188         {"readcapacity", CAM_CMD_READCAP, CAM_ARG_NONE, "bhHlNqs"},
 189         {"reprobe", CAM_CMD_REPROBE, CAM_ARG_NONE, NULL},
 190         {"rescan", CAM_CMD_RESCAN, CAM_ARG_NONE, NULL},
 191         {"reset", CAM_CMD_RESET, CAM_ARG_NONE, NULL},
 192         {"cmd", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts},
 193         {"mmcsdcmd", CAM_CMD_MMCSD_CMD, CAM_ARG_NONE, "c:a:F:f:Wb:l:41S:I"},
 194         {"command", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts},
 195         {"smpcmd", CAM_CMD_SMP_CMD, CAM_ARG_NONE, "r:R:"},
 196         {"smprg", CAM_CMD_SMP_RG, CAM_ARG_NONE, smprg_opts},
 197         {"smpreportgeneral", CAM_CMD_SMP_RG, CAM_ARG_NONE, smprg_opts},
 198         {"smppc", CAM_CMD_SMP_PC, CAM_ARG_NONE, smppc_opts},
 199         {"smpphycontrol", CAM_CMD_SMP_PC, CAM_ARG_NONE, smppc_opts},
 200         {"smpplist", CAM_CMD_SMP_PHYLIST, CAM_ARG_NONE, smpphylist_opts},
 201         {"smpphylist", CAM_CMD_SMP_PHYLIST, CAM_ARG_NONE, smpphylist_opts},
 202         {"smpmaninfo", CAM_CMD_SMP_MANINFO, CAM_ARG_NONE, "l"},
 203         {"defects", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts},
 204         {"defectlist", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts},
 205         {"devlist", CAM_CMD_DEVTREE, CAM_ARG_NONE, "-b"},
 206         {"devtype", CAM_CMD_DEVTYPE, CAM_ARG_NONE, ""},
 207         {"periphlist", CAM_CMD_DEVLIST, CAM_ARG_NONE, NULL},
 208         {"modepage", CAM_CMD_MODE_PAGE, CAM_ARG_NONE, "6bdelm:DLP:"},
 209         {"tags", CAM_CMD_TAG, CAM_ARG_NONE, "N:q"},
 210         {"negotiate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts},
 211         {"rate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts},
 212         {"debug", CAM_CMD_DEBUG, CAM_ARG_NONE, "IPTSXcp"},
 213         {"format", CAM_CMD_FORMAT, CAM_ARG_NONE, "qrwy"},
 214         {"sanitize", CAM_CMD_SANITIZE, CAM_ARG_NONE, "a:c:IP:qrUwy"},
 215         {"idle", CAM_CMD_IDLE, CAM_ARG_NONE, "t:"},
 216         {"standby", CAM_CMD_STANDBY, CAM_ARG_NONE, "t:"},
 217         {"sleep", CAM_CMD_SLEEP, CAM_ARG_NONE, ""},
 218         {"powermode", CAM_CMD_POWER_MODE, CAM_ARG_NONE, ""},
 219         {"apm", CAM_CMD_APM, CAM_ARG_NONE, "l:"},
 220         {"aam", CAM_CMD_AAM, CAM_ARG_NONE, "l:"},
 221         {"fwdownload", CAM_CMD_DOWNLOAD_FW, CAM_ARG_NONE, "f:qsy"},
 222         {"security", CAM_CMD_SECURITY, CAM_ARG_NONE, "d:e:fh:k:l:qs:T:U:y"},
 223         {"hpa", CAM_CMD_HPA, CAM_ARG_NONE, "Pflp:qs:U:y"},
 224         {"ama", CAM_CMD_AMA, CAM_ARG_NONE, "fqs:"},
 225         {"persist", CAM_CMD_PERSIST, CAM_ARG_NONE, "ai:I:k:K:o:ps:ST:U"},
 226         {"attrib", CAM_CMD_ATTRIB, CAM_ARG_NONE, "a:ce:F:p:r:s:T:w:V:"},
 227         {"opcodes", CAM_CMD_OPCODES, CAM_ARG_NONE, "No:s:T"},
 228         {"zone", CAM_CMD_ZONE, CAM_ARG_NONE, "ac:l:No:P:"},
 229         {"epc", CAM_CMD_EPC, CAM_ARG_NONE, "c:dDeHp:Pr:sS:T:"},
 230         {"timestamp", CAM_CMD_TIMESTAMP, CAM_ARG_NONE, "f:mrsUT:"},
 231         {"help", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
 232         {"-?", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
 233         {"-h", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
 234         {NULL, 0, 0, NULL}
 235 };
 236
 237 struct cam_devitem {
 238         struct device_match_result dev_match;
 239         int num_periphs;
 240         struct periph_match_result *periph_matches;
 241         struct scsi_vpd_device_id *device_id;
 242         int device_id_len;
 243         STAILQ_ENTRY(cam_devitem) links;
 244 };
 245
 246 struct cam_devlist {
 247         STAILQ_HEAD(, cam_devitem) dev_queue;
 248         path_id_t path_id;
 249 };
 250
 251 static cam_argmask arglist;
 252
 253 static const char *devtype_names[] = {
 254         "none",
 255         "scsi",
 256         "satl",
 257         "ata",
 258         "nvme",
 259         "mmcsd",
 260         "unknown",
 261 };
 262
 263 camcontrol_optret getoption(struct camcontrol_opts *table, char *arg,
 264                             uint32_t *cmdnum, cam_argmask *argnum,
 265                             const char **subopt);
 266 static int getdevlist(struct cam_device *device);
 267 static int getdevtree(int argc, char **argv, char *combinedopt);
 268 static int getdevtype(struct cam_device *device);
 269 static int print_dev_scsi(struct device_match_result *dev_result, char *tmpstr);
 270 static int print_dev_ata(struct device_match_result *dev_result, char *tmpstr);
 271 static int print_dev_semb(struct device_match_result *dev_result, char *tmpstr);
 272 static int print_dev_mmcsd(struct device_match_result *dev_result,
 273     char *tmpstr);
 274 #ifdef WITH_NVME
 275 static int print_dev_nvme(struct device_match_result *dev_result, char *tmpstr);
 276 #endif
 277 static int testunitready(struct cam_device *device, int task_attr,
 278                          int retry_count, int timeout, int quiet);
 279 static int scsistart(struct cam_device *device, int startstop, int loadeject,
 280                      int task_attr, int retry_count, int timeout);
 281 static int scsiinquiry(struct cam_device *device, int task_attr,
 282                        int retry_count, int timeout);
 283 static int scsiserial(struct cam_device *device, int task_attr,
 284                       int retry_count, int timeout);
 285 static int parse_btl(char *tstr, path_id_t *bus, target_id_t *target,
 286                      lun_id_t *lun, cam_argmask *arglst);
 287 static int reprobe(struct cam_device *device);
 288 static int dorescan_or_reset(int argc, char **argv, int rescan);
 289 static int rescan_or_reset_bus(path_id_t bus, int rescan);
 290 static int scanlun_or_reset_dev(path_id_t bus, target_id_t target,
 291     lun_id_t lun, int scan);
 292 static int readdefects(struct cam_device *device, int argc, char **argv,
 293                        char *combinedopt, int task_attr, int retry_count,
 294                        int timeout);
 295 static void modepage(struct cam_device *device, int argc, char **argv,
 296                      char *combinedopt, int task_attr, int retry_count,
 297                      int timeout);
 298 static int scsicmd(struct cam_device *device, int argc, char **argv,
 299                    char *combinedopt, int task_attr, int retry_count,
 300                    int timeout);
 301 static int smpcmd(struct cam_device *device, int argc, char **argv,
 302                   char *combinedopt, int retry_count, int timeout);
 303 static int mmcsdcmd(struct cam_device *device, int argc, char **argv,
 304                   char *combinedopt, int retry_count, int timeout);
 305 static int smpreportgeneral(struct cam_device *device, int argc, char **argv,
 306                             char *combinedopt, int retry_count, int timeout);
 307 static int smpphycontrol(struct cam_device *device, int argc, char **argv,
 308                          char *combinedopt, int retry_count, int timeout);
 309 static int smpmaninfo(struct cam_device *device, int argc, char **argv,
 310                       char *combinedopt, int retry_count, int timeout);
 311 static int getdevid(struct cam_devitem *item);
 312 static int buildbusdevlist(struct cam_devlist *devlist);
 313 static void freebusdevlist(struct cam_devlist *devlist);
 314 static struct cam_devitem *findsasdevice(struct cam_devlist *devlist,
 315                                          uint64_t sasaddr);
 316 static int smpphylist(struct cam_device *device, int argc, char **argv,
 317                       char *combinedopt, int retry_count, int timeout);
 318 static int tagcontrol(struct cam_device *device, int argc, char **argv,
 319                       char *combinedopt);
 320 static void cts_print(struct cam_device *device,
 321                       struct ccb_trans_settings *cts);
 322 static void cpi_print(struct ccb_pathinq *cpi);
 323 static int get_cpi(struct cam_device *device, struct ccb_pathinq *cpi);
 324 static int get_cgd(struct cam_device *device, struct ccb_getdev *cgd);
 325 static int get_print_cts(struct cam_device *device, int user_settings,
 326                          int quiet, struct ccb_trans_settings *cts);
 327 static int ratecontrol(struct cam_device *device, int task_attr,
 328                        int retry_count, int timeout, int argc, char **argv,
 329                        char *combinedopt);
 330 static int scsiformat(struct cam_device *device, int argc, char **argv,
 331                       char *combinedopt, int task_attr, int retry_count,
 332                       int timeout);
 333 static int sanitize(struct cam_device *device, int argc, char **argv,
 334                         char *combinedopt, int task_attr, int retry_count,
 335                         int timeout);
 336 static int scsireportluns(struct cam_device *device, int argc, char **argv,
 337                           char *combinedopt, int task_attr, int retry_count,
 338                           int timeout);
 339 static int scsireadcapacity(struct cam_device *device, int argc, char **argv,
 340                             char *combinedopt, int task_attr, int retry_count,
 341                             int timeout);
 342 static int atapm(struct cam_device *device, int argc, char **argv,
 343                  char *combinedopt, int retry_count, int timeout);
 344 static int atasecurity(struct cam_device *device, int retry_count, int timeout,
 345                        int argc, char **argv, char *combinedopt);
 346 static int atahpa(struct cam_device *device, int retry_count, int timeout,
 347                   int argc, char **argv, char *combinedopt);
 348 static int ataama(struct cam_device *device, int retry_count, int timeout,
 349                   int argc, char **argv, char *combinedopt);
 350 static int scsiprintoneopcode(struct cam_device *device, int req_opcode,
 351                               int sa_set, int req_sa, uint8_t *buf,
 352                               uint32_t valid_len);
 353 static int scsiprintopcodes(struct cam_device *device, int td_req, uint8_t *buf,
 354                             uint32_t valid_len);
 355 static int scsiopcodes(struct cam_device *device, int argc, char **argv,
 356                        char *combinedopt, int task_attr, int retry_count,
 357                        int timeout, int verbose);
 358
 359 #ifndef min
 360 #define min(a,b) (((a)<(b))?(a):(b))
 361 #endif
 362 #ifndef max
 363 #define max(a,b) (((a)>(b))?(a):(b))
 364 #endif
 365
 366 camcontrol_optret
 367 getoption(struct camcontrol_opts *table, char *arg, uint32_t *cmdnum,
 368           cam_argmask *argnum, const char **subopt)
 369 {
 370         struct camcontrol_opts *opts;
 371         int num_matches = 0;
 372
 373         for (opts = table; (opts != NULL) && (opts->optname != NULL);
 374              opts++) {
 375                 if (strncmp(opts->optname, arg, strlen(arg)) == 0) {
 376                         *cmdnum = opts->cmdnum;
 377                         *argnum = opts->argnum;
 378                         *subopt = opts->subopt;
 379                         if (++num_matches > 1)
 380                                 return (CC_OR_AMBIGUOUS);
 381                 }
 382         }
 383
 384         if (num_matches > 0)
 385                 return (CC_OR_FOUND);
 386         else
 387                 return (CC_OR_NOT_FOUND);
 388 }
 389
 390 static int
 391 getdevlist(struct cam_device *device)
 392 {
 393         union ccb *ccb;
 394         char status[32];
 395         int error = 0;
 396
 397         ccb = cam_getccb(device);
 398
 399         ccb->ccb_h.func_code = XPT_GDEVLIST;
 400         ccb->ccb_h.flags = CAM_DIR_NONE;
 401         ccb->ccb_h.retry_count = 1;
 402         ccb->cgdl.index = 0;
 403         ccb->cgdl.status = CAM_GDEVLIST_MORE_DEVS;
 404         while (ccb->cgdl.status == CAM_GDEVLIST_MORE_DEVS) {
 405                 if (cam_send_ccb(device, ccb) < 0) {
 406                         warn("error getting device list");
 407                         cam_freeccb(ccb);
 408                         return (1);
 409                 }
 410
 411                 status[0] = '\0';
 412
 413                 switch (ccb->cgdl.status) {
 414                         case CAM_GDEVLIST_MORE_DEVS:
 415                                 strcpy(status, "MORE");
 416                                 break;
 417                         case CAM_GDEVLIST_LAST_DEVICE:
 418                                 strcpy(status, "LAST");
 419                                 break;
 420                         case CAM_GDEVLIST_LIST_CHANGED:
 421                                 strcpy(status, "CHANGED");
 422                                 break;
 423                         case CAM_GDEVLIST_ERROR:
 424                                 strcpy(status, "ERROR");
 425                                 error = 1;
 426                                 break;
 427                 }
 428
 429                 fprintf(stdout, "%s%d:  generation: %d index: %d status: %s\n",
 430                         ccb->cgdl.periph_name,
 431                         ccb->cgdl.unit_number,
 432                         ccb->cgdl.generation,
 433                         ccb->cgdl.index,
 434                         status);
 435
 436                 /*
 437                  * If the list has changed, we need to start over from the
 438                  * beginning.
 439                  */
 440                 if (ccb->cgdl.status == CAM_GDEVLIST_LIST_CHANGED)
 441                         ccb->cgdl.index = 0;
 442         }
 443
 444         cam_freeccb(ccb);
 445
 446         return (error);
 447 }
 448
 449 static int
 450 getdevtree(int argc, char **argv, char *combinedopt)
 451 {
 452         union ccb ccb;
 453         int bufsize, fd;
 454         unsigned int i;
 455         int need_close = 0;
 456         int error = 0;
 457         int skip_device = 0;
 458         int busonly = 0;
 459         int c;
 460
 461         while ((c = getopt(argc, argv, combinedopt)) != -1) {
 462                 switch(c) {
 463                 case 'b':
 464                         if ((arglist & CAM_ARG_VERBOSE) == 0)
 465                                 busonly = 1;
 466                         break;
 467                 default:
 468                         break;
 469                 }
 470         }
 471
 472         if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
 473                 warn("couldn't open %s", XPT_DEVICE);
 474                 return (1);
 475         }
 476
 477         bzero(&ccb, sizeof(union ccb));
 478
 479         ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
 480         ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
 481         ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
 482
 483         ccb.ccb_h.func_code = XPT_DEV_MATCH;
 484         bufsize = sizeof(struct dev_match_result) * 100;
 485         ccb.cdm.match_buf_len = bufsize;
 486         ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
 487         if (ccb.cdm.matches == NULL) {
 488                 warnx("can't malloc memory for matches");
 489                 close(fd);
 490                 return (1);
 491         }
 492         ccb.cdm.num_matches = 0;
 493
 494         /*
 495          * We fetch all nodes, since we display most of them in the default
 496          * case, and all in the verbose case.
 497          */
 498         ccb.cdm.num_patterns = 0;
 499         ccb.cdm.pattern_buf_len = 0;
 500
 501         /*
 502          * We do the ioctl multiple times if necessary, in case there are
 503          * more than 100 nodes in the EDT.
 504          */
 505         do {
 506                 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
 507                         warn("error sending CAMIOCOMMAND ioctl");
 508                         error = 1;
 509                         break;
 510                 }
 511
 512                 if ((ccb.ccb_h.status != CAM_REQ_CMP)
 513                  || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
 514                     && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
 515                         warnx("got CAM error %#x, CDM error %d\n",
 516                               ccb.ccb_h.status, ccb.cdm.status);
 517                         error = 1;
 518                         break;
 519                 }
 520
 521                 for (i = 0; i < ccb.cdm.num_matches; i++) {
 522                         switch (ccb.cdm.matches[i].type) {
 523                         case DEV_MATCH_BUS: {
 524                                 struct bus_match_result *bus_result;
 525
 526                                 /*
 527                                  * Only print the bus information if the
 528                                  * user turns on the verbose flag.
 529                                  */
 530                                 if ((busonly == 0) &&
 531                                     (arglist & CAM_ARG_VERBOSE) == 0)
 532                                         break;
 533
 534                                 bus_result =
 535                                         &ccb.cdm.matches[i].result.bus_result;
 536
 537                                 if (need_close) {
 538                                         fprintf(stdout, ")\n");
 539                                         need_close = 0;
 540                                 }
 541
 542                                 fprintf(stdout, "scbus%d on %s%d bus %d%s\n",
 543                                         bus_result->path_id,
 544                                         bus_result->dev_name,
 545                                         bus_result->unit_number,
 546                                         bus_result->bus_id,
 547                                         (busonly ? "" : ":"));
 548                                 break;
 549                         }
 550                         case DEV_MATCH_DEVICE: {
 551                                 struct device_match_result *dev_result;
 552                                 char tmpstr[256];
 553
 554                                 if (busonly == 1)
 555                                         break;
 556
 557                                 dev_result =
 558                                      &ccb.cdm.matches[i].result.device_result;
 559
 560                                 if ((dev_result->flags
 561                                      & DEV_RESULT_UNCONFIGURED)
 562                                  && ((arglist & CAM_ARG_VERBOSE) == 0)) {
 563                                         skip_device = 1;
 564                                         break;
 565                                 } else
 566                                         skip_device = 0;
 567
 568                                 if (dev_result->protocol == PROTO_SCSI) {
 569                                         if (print_dev_scsi(dev_result,
 570                                             &tmpstr[0]) != 0) {
 571                                                 skip_device = 1;
 572                                                 break;
 573                                         }
 574                                 } else if (dev_result->protocol == PROTO_ATA ||
 575                                     dev_result->protocol == PROTO_SATAPM) {
 576                                         if (print_dev_ata(dev_result,
 577                                             &tmpstr[0]) != 0) {
 578                                                 skip_device = 1;
 579                                                 break;
 580                                         }
 581                                 } else if (dev_result->protocol == PROTO_MMCSD){
 582                                         if (print_dev_mmcsd(dev_result,
 583                                             &tmpstr[0]) != 0) {
 584                                                 skip_device = 1;
 585                                                 break;
 586                                         }
 587                                 } else if (dev_result->protocol == PROTO_SEMB) {
 588                                         if (print_dev_semb(dev_result,
 589                                             &tmpstr[0]) != 0) {
 590                                                 skip_device = 1;
 591                                                 break;
 592                                         }
 593 #ifdef WITH_NVME
 594                                 } else if (dev_result->protocol == PROTO_NVME) {
 595                                         if (print_dev_nvme(dev_result,
 596                                             &tmpstr[0]) != 0) {
 597                                                 skip_device = 1;
 598                                                 break;
 599                                         }
 600 #endif
 601                                 } else {
 602                                     sprintf(tmpstr, "<>");
 603                                 }
 604                                 if (need_close) {
 605                                         fprintf(stdout, ")\n");
 606                                         need_close = 0;
 607                                 }
 608
 609                                 fprintf(stdout, "%-33s  at scbus%d "
 610                                         "target %d lun %jx (",
 611                                         tmpstr,
 612                                         dev_result->path_id,
 613                                         dev_result->target_id,
 614                                         (uintmax_t)dev_result->target_lun);
 615
 616                                 need_close = 1;
 617
 618                                 break;
 619                         }
 620                         case DEV_MATCH_PERIPH: {
 621                                 struct periph_match_result *periph_result;
 622
 623                                 periph_result =
 624                                       &ccb.cdm.matches[i].result.periph_result;
 625
 626                                 if (busonly || skip_device != 0)
 627                                         break;
 628
 629                                 if (need_close > 1)
 630                                         fprintf(stdout, ",");
 631
 632                                 fprintf(stdout, "%s%d",
 633                                         periph_result->periph_name,
 634                                         periph_result->unit_number);
 635
 636                                 need_close++;
 637                                 break;
 638                         }
 639                         default:
 640                                 fprintf(stdout, "unknown match type\n");
 641                                 break;
 642                         }
 643                 }
 644
 645         } while ((ccb.ccb_h.status == CAM_REQ_CMP)
 646                 && (ccb.cdm.status == CAM_DEV_MATCH_MORE));
 647
 648         if (need_close)
 649                 fprintf(stdout, ")\n");
 650
 651         close(fd);
 652
 653         return (error);
 654 }
 655
 656 static int
 657 getdevtype(struct cam_device *cam_dev)
 658 {
 659         camcontrol_devtype dt;
 660         int error;
 661
 662         /*
 663          * Get the device type and report it, request no I/O be done to do this.
 664          */
 665         error = get_device_type(cam_dev, -1, 0, 0, &dt);
 666         if (error != 0 || (unsigned)dt > CC_DT_UNKNOWN) {
 667                 fprintf(stdout, "illegal\n");
 668                 return (1);
 669         }
 670         fprintf(stdout, "%s\n", devtype_names[dt]);
 671         return (0);
 672 }
 673
 674 static int
 675 print_dev_scsi(struct device_match_result *dev_result, char *tmpstr)
 676 {
 677         char vendor[16], product[48], revision[16];
 678
 679         cam_strvis(vendor, dev_result->inq_data.vendor,
 680             sizeof(dev_result->inq_data.vendor), sizeof(vendor));
 681         cam_strvis(product, dev_result->inq_data.product,
 682             sizeof(dev_result->inq_data.product), sizeof(product));
 683         cam_strvis(revision, dev_result->inq_data.revision,
 684             sizeof(dev_result->inq_data.revision), sizeof(revision));
 685         sprintf(tmpstr, "<%s %s %s>", vendor, product, revision);
 686
 687         return (0);
 688 }
 689
 690 static int
 691 print_dev_ata(struct device_match_result *dev_result, char *tmpstr)
 692 {
 693         char product[48], revision[16];
 694
 695         cam_strvis(product, dev_result->ident_data.model,
 696             sizeof(dev_result->ident_data.model), sizeof(product));
 697         cam_strvis(revision, dev_result->ident_data.revision,
 698             sizeof(dev_result->ident_data.revision), sizeof(revision));
 699         sprintf(tmpstr, "<%s %s>", product, revision);
 700
 701         return (0);
 702 }
 703
 704 static int
 705 print_dev_semb(struct device_match_result *dev_result, char *tmpstr)
 706 {
 707         struct sep_identify_data *sid;
 708         char vendor[16], product[48], revision[16], fw[5];
 709
 710         sid = (struct sep_identify_data *)&dev_result->ident_data;
 711         cam_strvis(vendor, sid->vendor_id,
 712             sizeof(sid->vendor_id), sizeof(vendor));
 713         cam_strvis(product, sid->product_id,
 714             sizeof(sid->product_id), sizeof(product));
 715         cam_strvis(revision, sid->product_rev,
 716             sizeof(sid->product_rev), sizeof(revision));
 717         cam_strvis(fw, sid->firmware_rev,
 718             sizeof(sid->firmware_rev), sizeof(fw));
 719         sprintf(tmpstr, "<%s %s %s %s>", vendor, product, revision, fw);
 720
 721         return (0);
 722 }
 723
 724 static int
 725 print_dev_mmcsd(struct device_match_result *dev_result, char *tmpstr)
 726 {
 727         union ccb *ccb;
 728         struct ccb_dev_advinfo *advi;
 729         struct cam_device *dev;
 730         struct mmc_params mmc_ident_data;
 731
 732         dev = cam_open_btl(dev_result->path_id, dev_result->target_id,
 733             dev_result->target_lun, O_RDWR, NULL);
 734         if (dev == NULL) {
 735                 warnx("%s", cam_errbuf);
 736                 return (1);
 737         }
 738
 739         ccb = cam_getccb(dev);
 740         if (ccb == NULL) {
 741                 warnx("couldn't allocate CCB");
 742                 cam_close_device(dev);
 743                 return (1);
 744         }
 745
 746         advi = &ccb->cdai;
 747         advi->ccb_h.flags = CAM_DIR_IN;
 748         advi->ccb_h.func_code = XPT_DEV_ADVINFO;
 749         advi->flags = CDAI_FLAG_NONE;
 750         advi->buftype = CDAI_TYPE_MMC_PARAMS;
 751         advi->bufsiz = sizeof(struct mmc_params);
 752         advi->buf = (uint8_t *)&mmc_ident_data;
 753
 754         if (cam_send_ccb(dev, ccb) < 0) {
 755                 warn("error sending XPT_DEV_ADVINFO CCB");
 756                 cam_freeccb(ccb);
 757                 cam_close_device(dev);
 758                 return (1);
 759         }
 760
 761         if (strlen(mmc_ident_data.model) > 0) {
 762                 sprintf(tmpstr, "<%s>", mmc_ident_data.model);
 763         } else {
 764                 sprintf(tmpstr, "<%s card>",
 765                     mmc_ident_data.card_features &
 766                     CARD_FEATURE_SDIO ? "SDIO" : "unknown");
 767         }
 768
 769         cam_freeccb(ccb);
 770         cam_close_device(dev);
 771         return (0);
 772 }
 773
 774 #ifdef WITH_NVME
 775 static int
 776 nvme_get_cdata(struct cam_device *dev, struct nvme_controller_data *cdata)
 777 {
 778         union ccb *ccb;
 779         struct ccb_dev_advinfo *advi;
 780
 781         ccb = cam_getccb(dev);
 782         if (ccb == NULL) {
 783                 warnx("couldn't allocate CCB");
 784                 cam_close_device(dev);
 785                 return (1);
 786         }
 787
 788         advi = &ccb->cdai;
 789         advi->ccb_h.flags = CAM_DIR_IN;
 790         advi->ccb_h.func_code = XPT_DEV_ADVINFO;
 791         advi->flags = CDAI_FLAG_NONE;
 792         advi->buftype = CDAI_TYPE_NVME_CNTRL;
 793         advi->bufsiz = sizeof(struct nvme_controller_data);
 794         advi->buf = (uint8_t *)cdata;
 795
 796         if (cam_send_ccb(dev, ccb) < 0) {
 797                 warn("error sending XPT_DEV_ADVINFO CCB");
 798                 cam_freeccb(ccb);
 799                 cam_close_device(dev);
 800                 return(1);
 801         }
 802         if (advi->ccb_h.status != CAM_REQ_CMP) {
 803                 warnx("got CAM error %#x", advi->ccb_h.status);
 804                 cam_freeccb(ccb);
 805                 cam_close_device(dev);
 806                 return(1);
 807         }
 808         cam_freeccb(ccb);
 809         return 0;
 810 }
 811
 812 static int
 813 print_dev_nvme(struct device_match_result *dev_result, char *tmpstr)
 814 {
 815         struct cam_device *dev;
 816         struct nvme_controller_data cdata;
 817         char vendor[64], product[64];
 818
 819         dev = cam_open_btl(dev_result->path_id, dev_result->target_id,
 820             dev_result->target_lun, O_RDWR, NULL);
 821         if (dev == NULL) {
 822                 warnx("%s", cam_errbuf);
 823                 return (1);
 824         }
 825
 826         if (nvme_get_cdata(dev, &cdata))
 827                 return (1);
 828
 829         cam_strvis(vendor, cdata.mn, sizeof(cdata.mn), sizeof(vendor));
 830         cam_strvis(product, cdata.fr, sizeof(cdata.fr), sizeof(product));
 831         sprintf(tmpstr, "<%s %s>", vendor, product);
 832
 833         cam_close_device(dev);
 834         return (0);
 835 }
 836 #endif
 837
 838 static int
 839 testunitready(struct cam_device *device, int task_attr, int retry_count,
 840               int timeout, int quiet)
 841 {
 842         int error = 0;
 843         union ccb *ccb;
 844
 845         ccb = cam_getccb(device);
 846
 847         scsi_test_unit_ready(&ccb->csio,
 848                              /* retries */ retry_count,
 849                              /* cbfcnp */ NULL,
 850                              /* tag_action */ task_attr,
 851                              /* sense_len */ SSD_FULL_SIZE,
 852                              /* timeout */ timeout ? timeout : 5000);
 853
 854         /* Disable freezing the device queue */
 855         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
 856
 857         if (arglist & CAM_ARG_ERR_RECOVER)
 858                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
 859
 860         if (cam_send_ccb(device, ccb) < 0) {
 861                 if (quiet == 0)
 862                         warn("error sending TEST UNIT READY command");
 863                 cam_freeccb(ccb);
 864                 return (1);
 865         }
 866
 867         if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
 868                 if (quiet == 0)
 869                         fprintf(stdout, "Unit is ready\n");
 870         } else {
 871                 if (quiet == 0)
 872                         fprintf(stdout, "Unit is not ready\n");
 873                 error = 1;
 874
 875                 if (arglist & CAM_ARG_VERBOSE) {
 876                         cam_error_print(device, ccb, CAM_ESF_ALL,
 877                                         CAM_EPF_ALL, stderr);
 878                 }
 879         }
 880
 881         cam_freeccb(ccb);
 882
 883         return (error);
 884 }
 885
 886 static int
 887 scsistart(struct cam_device *device, int startstop, int loadeject,
 888           int task_attr, int retry_count, int timeout)
 889 {
 890         union ccb *ccb;
 891         int error = 0;
 892
 893         ccb = cam_getccb(device);
 894
 895         /*
 896          * If we're stopping, send an ordered tag so the drive in question
 897          * will finish any previously queued writes before stopping.  If
 898          * the device isn't capable of tagged queueing, or if tagged
 899          * queueing is turned off, the tag action is a no-op.  We override
 900          * the default simple tag, although this also has the effect of
 901          * overriding the user's wishes if he wanted to specify a simple
 902          * tag.
 903          */
 904         if ((startstop == 0)
 905          && (task_attr == MSG_SIMPLE_Q_TAG))
 906                 task_attr = MSG_ORDERED_Q_TAG;
 907
 908         scsi_start_stop(&ccb->csio,
 909                         /* retries */ retry_count,
 910                         /* cbfcnp */ NULL,
 911                         /* tag_action */ task_attr,
 912                         /* start/stop */ startstop,
 913                         /* load_eject */ loadeject,
 914                         /* immediate */ 0,
 915                         /* sense_len */ SSD_FULL_SIZE,
 916                         /* timeout */ timeout ? timeout : 120000);
 917
 918         /* Disable freezing the device queue */
 919         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
 920
 921         if (arglist & CAM_ARG_ERR_RECOVER)
 922                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
 923
 924         if (cam_send_ccb(device, ccb) < 0) {
 925                 warn("error sending START STOP UNIT command");
 926                 cam_freeccb(ccb);
 927                 return (1);
 928         }
 929
 930         if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
 931                 if (startstop) {
 932                         fprintf(stdout, "Unit started successfully");
 933                         if (loadeject)
 934                                 fprintf(stdout,", Media loaded\n");
 935                         else
 936                                 fprintf(stdout,"\n");
 937                 } else {
 938                         fprintf(stdout, "Unit stopped successfully");
 939                         if (loadeject)
 940                                 fprintf(stdout, ", Media ejected\n");
 941                         else
 942                                 fprintf(stdout, "\n");
 943                 }
 944         else {
 945                 error = 1;
 946                 if (startstop)
 947                         fprintf(stdout,
 948                                 "Error received from start unit command\n");
 949                 else
 950                         fprintf(stdout,
 951                                 "Error received from stop unit command\n");
 952
 953                 if (arglist & CAM_ARG_VERBOSE) {
 954                         cam_error_print(device, ccb, CAM_ESF_ALL,
 955                                         CAM_EPF_ALL, stderr);
 956                 }
 957         }
 958
 959         cam_freeccb(ccb);
 960
 961         return (error);
 962 }
 963
 964 int
 965 scsidoinquiry(struct cam_device *device, int argc, char **argv,
 966               char *combinedopt, int task_attr, int retry_count, int timeout)
 967 {
 968         int c;
 969         int error = 0;
 970
 971         while ((c = getopt(argc, argv, combinedopt)) != -1) {
 972                 switch(c) {
 973                 case 'D':
 974                         arglist |= CAM_ARG_GET_STDINQ;
 975                         break;
 976                 case 'R':
 977                         arglist |= CAM_ARG_GET_XFERRATE;
 978                         break;
 979                 case 'S':
 980                         arglist |= CAM_ARG_GET_SERIAL;
 981                         break;
 982                 default:
 983                         break;
 984                 }
 985         }
 986
 987         /*
 988          * If the user didn't specify any inquiry options, he wants all of
 989          * them.
 990          */
 991         if ((arglist & CAM_ARG_INQ_MASK) == 0)
 992                 arglist |= CAM_ARG_INQ_MASK;
 993
 994         if (arglist & CAM_ARG_GET_STDINQ)
 995                 error = scsiinquiry(device, task_attr, retry_count, timeout);
 996
 997         if (error != 0)
 998                 return (error);
 999
1000         if (arglist & CAM_ARG_GET_SERIAL)
1001                 scsiserial(device, task_attr, retry_count, timeout);
1002
1003         if (arglist & CAM_ARG_GET_XFERRATE)
1004                 error = camxferrate(device);
1005
1006         return (error);
1007 }
1008
1009 static int
1010 scsiinquiry(struct cam_device *device, int task_attr, int retry_count,
1011             int timeout)
1012 {
1013         union ccb *ccb;
1014         struct scsi_inquiry_data *inq_buf;
1015         int error = 0;
1016
1017         ccb = cam_getccb(device);
1018
1019         if (ccb == NULL) {
1020                 warnx("couldn't allocate CCB");
1021                 return (1);
1022         }
1023
1024         inq_buf = (struct scsi_inquiry_data *)malloc(
1025                 sizeof(struct scsi_inquiry_data));
1026
1027         if (inq_buf == NULL) {
1028                 cam_freeccb(ccb);
1029                 warnx("can't malloc memory for inquiry\n");
1030                 return (1);
1031         }
1032         bzero(inq_buf, sizeof(*inq_buf));
1033
1034         /*
1035          * Note that although the size of the inquiry buffer is the full
1036          * 256 bytes specified in the SCSI spec, we only tell the device
1037          * that we have allocated SHORT_INQUIRY_LENGTH bytes.  There are
1038          * two reasons for this:
1039          *
1040          *  - The SCSI spec says that when a length field is only 1 byte,
1041          *    a value of 0 will be interpreted as 256.  Therefore
1042          *    scsi_inquiry() will convert an inq_len (which is passed in as
1043          *    a u_int32_t, but the field in the CDB is only 1 byte) of 256
1044          *    to 0.  Evidently, very few devices meet the spec in that
1045          *    regard.  Some devices, like many Seagate disks, take the 0 as
1046          *    0, and don't return any data.  One Pioneer DVD-R drive
1047          *    returns more data than the command asked for.
1048          *
1049          *    So, since there are numerous devices that just don't work
1050          *    right with the full inquiry size, we don't send the full size.
1051          *
1052          *  - The second reason not to use the full inquiry data length is
1053          *    that we don't need it here.  The only reason we issue a
1054          *    standard inquiry is to get the vendor name, device name,
1055          *    and revision so scsi_print_inquiry() can print them.
1056          *
1057          * If, at some point in the future, more inquiry data is needed for
1058          * some reason, this code should use a procedure similar to the
1059          * probe code.  i.e., issue a short inquiry, and determine from
1060          * the additional length passed back from the device how much
1061          * inquiry data the device supports.  Once the amount the device
1062          * supports is determined, issue an inquiry for that amount and no
1063          * more.
1064          *
1065          * KDM, 2/18/2000
1066          */
1067         scsi_inquiry(&ccb->csio,
1068                      /* retries */ retry_count,
1069                      /* cbfcnp */ NULL,
1070                      /* tag_action */ task_attr,
1071                      /* inq_buf */ (u_int8_t *)inq_buf,
1072                      /* inq_len */ SHORT_INQUIRY_LENGTH,
1073                      /* evpd */ 0,
1074                      /* page_code */ 0,
1075                      /* sense_len */ SSD_FULL_SIZE,
1076                      /* timeout */ timeout ? timeout : 5000);
1077
1078         /* Disable freezing the device queue */
1079         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1080
1081         if (arglist & CAM_ARG_ERR_RECOVER)
1082                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
1083
1084         if (cam_send_ccb(device, ccb) < 0) {
1085                 warn("error sending INQUIRY command");
1086                 cam_freeccb(ccb);
1087                 return (1);
1088         }
1089
1090         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1091                 error = 1;
1092
1093                 if (arglist & CAM_ARG_VERBOSE) {
1094                         cam_error_print(device, ccb, CAM_ESF_ALL,
1095                                         CAM_EPF_ALL, stderr);
1096                 }
1097         }
1098
1099         cam_freeccb(ccb);
1100
1101         if (error != 0) {
1102                 free(inq_buf);
1103                 return (error);
1104         }
1105
1106         fprintf(stdout, "%s%d: ", device->device_name,
1107                 device->dev_unit_num);
1108         scsi_print_inquiry(inq_buf);
1109
1110         free(inq_buf);
1111
1112         return (0);
1113 }
1114
1115 static int
1116 scsiserial(struct cam_device *device, int task_attr, int retry_count,
1117            int timeout)
1118 {
1119         union ccb *ccb;
1120         struct scsi_vpd_unit_serial_number *serial_buf;
1121         char serial_num[SVPD_SERIAL_NUM_SIZE + 1];
1122         int error = 0;
1123
1124         ccb = cam_getccb(device);
1125
1126         if (ccb == NULL) {
1127                 warnx("couldn't allocate CCB");
1128                 return (1);
1129         }
1130
1131         serial_buf = (struct scsi_vpd_unit_serial_number *)
1132                 malloc(sizeof(*serial_buf));
1133
1134         if (serial_buf == NULL) {
1135                 cam_freeccb(ccb);
1136                 warnx("can't malloc memory for serial number");
1137                 return (1);
1138         }
1139
1140         scsi_inquiry(&ccb->csio,
1141                      /*retries*/ retry_count,
1142                      /*cbfcnp*/ NULL,
1143                      /* tag_action */ task_attr,
1144                      /* inq_buf */ (u_int8_t *)serial_buf,
1145                      /* inq_len */ sizeof(*serial_buf),
1146                      /* evpd */ 1,
1147                      /* page_code */ SVPD_UNIT_SERIAL_NUMBER,
1148                      /* sense_len */ SSD_FULL_SIZE,
1149                      /* timeout */ timeout ? timeout : 5000);
1150
1151         /* Disable freezing the device queue */
1152         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1153
1154         if (arglist & CAM_ARG_ERR_RECOVER)
1155                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
1156
1157         if (cam_send_ccb(device, ccb) < 0) {
1158                 warn("error sending INQUIRY command");
1159                 cam_freeccb(ccb);
1160                 free(serial_buf);
1161                 return (1);
1162         }
1163
1164         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1165                 error = 1;
1166
1167                 if (arglist & CAM_ARG_VERBOSE) {
1168                         cam_error_print(device, ccb, CAM_ESF_ALL,
1169                                         CAM_EPF_ALL, stderr);
1170                 }
1171         }
1172
1173         cam_freeccb(ccb);
1174
1175         if (error != 0) {
1176                 free(serial_buf);
1177                 return (error);
1178         }
1179
1180         bcopy(serial_buf->serial_num, serial_num, serial_buf->length);
1181         serial_num[serial_buf->length] = '\0';
1182
1183         if ((arglist & CAM_ARG_GET_STDINQ)
1184          || (arglist & CAM_ARG_GET_XFERRATE))
1185                 fprintf(stdout, "%s%d: Serial Number ",
1186                         device->device_name, device->dev_unit_num);
1187
1188         fprintf(stdout, "%.60s\n", serial_num);
1189
1190         free(serial_buf);
1191
1192         return (0);
1193 }
1194
1195 int
1196 camxferrate(struct cam_device *device)
1197 {
1198         struct ccb_pathinq cpi;
1199         u_int32_t freq = 0;
1200         u_int32_t speed = 0;
1201         union ccb *ccb;
1202         u_int mb;
1203         int retval = 0;
1204
1205         if ((retval = get_cpi(device, &cpi)) != 0)
1206                 return (1);
1207
1208         ccb = cam_getccb(device);
1209
1210         if (ccb == NULL) {
1211                 warnx("couldn't allocate CCB");
1212                 return (1);
1213         }
1214
1215         ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
1216         ccb->cts.type = CTS_TYPE_CURRENT_SETTINGS;
1217
1218         if (((retval = cam_send_ccb(device, ccb)) < 0)
1219          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
1220                 const char error_string[] = "error getting transfer settings";
1221
1222                 if (retval < 0)
1223                         warn(error_string);
1224                 else
1225                         warnx(error_string);
1226
1227                 if (arglist & CAM_ARG_VERBOSE)
1228                         cam_error_print(device, ccb, CAM_ESF_ALL,
1229                                         CAM_EPF_ALL, stderr);
1230
1231                 retval = 1;
1232
1233                 goto xferrate_bailout;
1234
1235         }
1236
1237         speed = cpi.base_transfer_speed;
1238         freq = 0;
1239         if (ccb->cts.transport == XPORT_SPI) {
1240                 struct ccb_trans_settings_spi *spi =
1241                     &ccb->cts.xport_specific.spi;
1242
1243                 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) {
1244                         freq = scsi_calc_syncsrate(spi->sync_period);
1245                         speed = freq;
1246                 }
1247                 if ((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0) {
1248                         speed *= (0x01 << spi->bus_width);
1249                 }
1250         } else if (ccb->cts.transport == XPORT_FC) {
1251                 struct ccb_trans_settings_fc *fc =
1252                     &ccb->cts.xport_specific.fc;
1253
1254                 if (fc->valid & CTS_FC_VALID_SPEED)
1255                         speed = fc->bitrate;
1256         } else if (ccb->cts.transport == XPORT_SAS) {
1257                 struct ccb_trans_settings_sas *sas =
1258                     &ccb->cts.xport_specific.sas;
1259
1260                 if (sas->valid & CTS_SAS_VALID_SPEED)
1261                         speed = sas->bitrate;
1262         } else if (ccb->cts.transport == XPORT_ATA) {
1263                 struct ccb_trans_settings_pata *pata =
1264                     &ccb->cts.xport_specific.ata;
1265
1266                 if (pata->valid & CTS_ATA_VALID_MODE)
1267                         speed = ata_mode2speed(pata->mode);
1268         } else if (ccb->cts.transport == XPORT_SATA) {
1269                 struct  ccb_trans_settings_sata *sata =
1270                     &ccb->cts.xport_specific.sata;
1271
1272                 if (sata->valid & CTS_SATA_VALID_REVISION)
1273                         speed = ata_revision2speed(sata->revision);
1274         }
1275
1276         mb = speed / 1000;
1277         if (mb > 0) {
1278                 fprintf(stdout, "%s%d: %d.%03dMB/s transfers",
1279                         device->device_name, device->dev_unit_num,
1280                         mb, speed % 1000);
1281         } else {
1282                 fprintf(stdout, "%s%d: %dKB/s transfers",
1283                         device->device_name, device->dev_unit_num,
1284                         speed);
1285         }
1286
1287         if (ccb->cts.transport == XPORT_SPI) {
1288                 struct ccb_trans_settings_spi *spi =
1289                     &ccb->cts.xport_specific.spi;
1290
1291                 if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0)
1292                  && (spi->sync_offset != 0))
1293                         fprintf(stdout, " (%d.%03dMHz, offset %d", freq / 1000,
1294                                 freq % 1000, spi->sync_offset);
1295
1296                 if (((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0)
1297                  && (spi->bus_width > 0)) {
1298                         if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0)
1299                          && (spi->sync_offset != 0)) {
1300                                 fprintf(stdout, ", ");
1301                         } else {
1302                                 fprintf(stdout, " (");
1303                         }
1304                         fprintf(stdout, "%dbit)", 8 * (0x01 << spi->bus_width));
1305                 } else if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0)
1306                  && (spi->sync_offset != 0)) {
1307                         fprintf(stdout, ")");
1308                 }
1309         } else if (ccb->cts.transport == XPORT_ATA) {
1310                 struct ccb_trans_settings_pata *pata =
1311                     &ccb->cts.xport_specific.ata;
1312
1313                 printf(" (");
1314                 if (pata->valid & CTS_ATA_VALID_MODE)
1315                         printf("%s, ", ata_mode2string(pata->mode));
1316                 if ((pata->valid & CTS_ATA_VALID_ATAPI) && pata->atapi != 0)
1317                         printf("ATAPI %dbytes, ", pata->atapi);
1318                 if (pata->valid & CTS_ATA_VALID_BYTECOUNT)
1319                         printf("PIO %dbytes", pata->bytecount);
1320                 printf(")");
1321         } else if (ccb->cts.transport == XPORT_SATA) {
1322                 struct ccb_trans_settings_sata *sata =
1323                     &ccb->cts.xport_specific.sata;
1324
1325                 printf(" (");
1326                 if (sata->valid & CTS_SATA_VALID_REVISION)
1327                         printf("SATA %d.x, ", sata->revision);
1328                 else
1329                         printf("SATA, ");
1330                 if (sata->valid & CTS_SATA_VALID_MODE)
1331                         printf("%s, ", ata_mode2string(sata->mode));
1332                 if ((sata->valid & CTS_SATA_VALID_ATAPI) && sata->atapi != 0)
1333                         printf("ATAPI %dbytes, ", sata->atapi);
1334                 if (sata->valid & CTS_SATA_VALID_BYTECOUNT)
1335                         printf("PIO %dbytes", sata->bytecount);
1336                 printf(")");
1337         }
1338
1339         if (ccb->cts.protocol == PROTO_SCSI) {
1340                 struct ccb_trans_settings_scsi *scsi =
1341                     &ccb->cts.proto_specific.scsi;
1342                 if (scsi->valid & CTS_SCSI_VALID_TQ) {
1343                         if (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) {
1344                                 fprintf(stdout, ", Command Queueing Enabled");
1345                         }
1346                 }
1347         }
1348
1349         fprintf(stdout, "\n");
1350
1351 xferrate_bailout:
1352
1353         cam_freeccb(ccb);
1354
1355         return (retval);
1356 }
1357
1358 static void
1359 atahpa_print(struct ata_params *parm, u_int64_t hpasize, int header)
1360 {
1361         u_int32_t lbasize = (u_int32_t)parm->lba_size_1 |
1362                                 ((u_int32_t)parm->lba_size_2 << 16);
1363
1364         u_int64_t lbasize48 = ((u_int64_t)parm->lba_size48_1) |
1365                                 ((u_int64_t)parm->lba_size48_2 << 16) |
1366                                 ((u_int64_t)parm->lba_size48_3 << 32) |
1367                                 ((u_int64_t)parm->lba_size48_4 << 48);
1368
1369         if (header) {
1370                 printf("\nFeature                      "
1371                        "Support  Enabled   Value\n");
1372         }
1373
1374         printf("Host Protected Area (HPA)      ");
1375         if (parm->support.command1 & ATA_SUPPORT_PROTECTED) {
1376                 u_int64_t lba = lbasize48 ? lbasize48 : lbasize;
1377                 printf("yes      %s     %ju/%ju\n", (hpasize > lba) ? "yes" : "no ",
1378                         lba, hpasize);
1379
1380                 printf("HPA - Security                 ");
1381                 if (parm->support.command2 & ATA_SUPPORT_MAXSECURITY)
1382                         printf("yes      %s\n", (parm->enabled.command2 &
1383                             ATA_SUPPORT_MAXSECURITY) ? "yes" : "no ");
1384                 else
1385                         printf("no\n");
1386         } else {
1387                 printf("no\n");
1388         }
1389 }
1390
1391 static void
1392 ataama_print(struct ata_params *parm, u_int64_t nativesize, int header)
1393 {
1394         u_int32_t lbasize = (u_int32_t)parm->lba_size_1 |
1395                                 ((u_int32_t)parm->lba_size_2 << 16);
1396
1397         u_int64_t lbasize48 = ((u_int64_t)parm->lba_size48_1) |
1398                                 ((u_int64_t)parm->lba_size48_2 << 16) |
1399                                 ((u_int64_t)parm->lba_size48_3 << 32) |
1400                                 ((u_int64_t)parm->lba_size48_4 << 48);
1401
1402         if (header) {
1403                 printf("\nFeature                      "
1404                        "Support  Enabled   Value\n");
1405         }
1406
1407         printf("Accessible Max Address Config  ");
1408         if (parm->support2 & ATA_SUPPORT_AMAX_ADDR) {
1409                 u_int64_t lba = lbasize48 ? lbasize48 : lbasize;
1410                 printf("yes      %s     %ju/%ju\n",
1411                     (nativesize > lba) ? "yes" : "no ", lba, nativesize);
1412         } else {
1413                 printf("no\n");
1414         }
1415 }
1416
1417 static int
1418 atasata(struct ata_params *parm)
1419 {
1420
1421
1422         if (parm->satacapabilities != 0xffff &&
1423             parm->satacapabilities != 0x0000)
1424                 return 1;
1425
1426         return 0;
1427 }
1428
1429 static void
1430 atacapprint(struct ata_params *parm)
1431 {
1432         const char *proto;
1433         u_int32_t lbasize = (u_int32_t)parm->lba_size_1 |
1434                                 ((u_int32_t)parm->lba_size_2 << 16);
1435
1436         u_int64_t lbasize48 = ((u_int64_t)parm->lba_size48_1) |
1437                                 ((u_int64_t)parm->lba_size48_2 << 16) |
1438                                 ((u_int64_t)parm->lba_size48_3 << 32) |
1439                                 ((u_int64_t)parm->lba_size48_4 << 48);
1440
1441         printf("\n");
1442         printf("protocol              ");
1443         proto = (parm->config == ATA_PROTO_CFA) ? "CFA" :
1444                 (parm->config & ATA_PROTO_ATAPI) ? "ATAPI" : "ATA";
1445         if (ata_version(parm->version_major) == 0) {
1446                 printf("%s", proto);
1447         } else if (ata_version(parm->version_major) <= 7) {
1448                 printf("%s-%d", proto,
1449                     ata_version(parm->version_major));
1450         } else if (ata_version(parm->version_major) == 8) {
1451                 printf("%s8-ACS", proto);
1452         } else {
1453                 printf("ACS-%d %s",
1454                     ata_version(parm->version_major) - 7, proto);
1455         }
1456         if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
1457                 if (parm->satacapabilities & ATA_SATA_GEN3)
1458                         printf(" SATA 3.x\n");
1459                 else if (parm->satacapabilities & ATA_SATA_GEN2)
1460                         printf(" SATA 2.x\n");
1461                 else if (parm->satacapabilities & ATA_SATA_GEN1)
1462                         printf(" SATA 1.x\n");
1463                 else
1464                         printf(" SATA\n");
1465         }
1466         else
1467                 printf("\n");
1468         printf("device model          %.40s\n", parm->model);
1469         printf("firmware revision     %.8s\n", parm->revision);
1470         printf("serial number         %.20s\n", parm->serial);
1471         if (parm->enabled.extension & ATA_SUPPORT_64BITWWN) {
1472                 printf("WWN                   %04x%04x%04x%04x\n",
1473                     parm->wwn[0], parm->wwn[1], parm->wwn[2], parm->wwn[3]);
1474         }
1475         printf("additional product id %.8s\n", parm->product_id);
1476         if (parm->enabled.extension & ATA_SUPPORT_MEDIASN) {
1477                 printf("media serial number   %.30s\n",
1478                     parm->media_serial);
1479         }
1480
1481         printf("cylinders             %d\n", parm->cylinders);
1482         printf("heads                 %d\n", parm->heads);
1483         printf("sectors/track         %d\n", parm->sectors);
1484         printf("sector size           logical %u, physical %lu, offset %lu\n",
1485             ata_logical_sector_size(parm),
1486             (unsigned long)ata_physical_sector_size(parm),
1487             (unsigned long)ata_logical_sector_offset(parm));
1488
1489         if (parm->config == ATA_PROTO_CFA ||
1490             (parm->support.command2 & ATA_SUPPORT_CFA))
1491                 printf("CFA supported\n");
1492
1493         printf("LBA%ssupported         ",
1494                 parm->capabilities1 & ATA_SUPPORT_LBA ? " " : " not ");
1495         if (lbasize)
1496                 printf("%d sectors\n", lbasize);
1497         else
1498                 printf("\n");
1499
1500         printf("LBA48%ssupported       ",
1501                 parm->support.command2 & ATA_SUPPORT_ADDRESS48 ? " " : " not ");
1502         if (lbasize48)
1503                 printf("%ju sectors\n", (uintmax_t)lbasize48);
1504         else
1505                 printf("\n");
1506
1507         printf("PIO supported         PIO");
1508         switch (ata_max_pmode(parm)) {
1509         case ATA_PIO4:
1510                 printf("4");
1511                 break;
1512         case ATA_PIO3:
1513                 printf("3");
1514                 break;
1515         case ATA_PIO2:
1516                 printf("2");
1517                 break;
1518         case ATA_PIO1:
1519                 printf("1");
1520                 break;
1521         default:
1522                 printf("0");
1523         }
1524         if ((parm->capabilities1 & ATA_SUPPORT_IORDY) == 0)
1525                 printf(" w/o IORDY");
1526         printf("\n");
1527
1528         printf("DMA%ssupported         ",
1529                 parm->capabilities1 & ATA_SUPPORT_DMA ? " " : " not ");
1530         if (parm->capabilities1 & ATA_SUPPORT_DMA) {
1531                 if (parm->mwdmamodes & 0xff) {
1532                         printf("WDMA");
1533                         if (parm->mwdmamodes & 0x04)
1534                                 printf("2");
1535                         else if (parm->mwdmamodes & 0x02)
1536                                 printf("1");
1537                         else if (parm->mwdmamodes & 0x01)
1538                                 printf("0");
1539                         printf(" ");
1540                 }
1541                 if ((parm->atavalid & ATA_FLAG_88) &&
1542                     (parm->udmamodes & 0xff)) {
1543                         printf("UDMA");
1544                         if (parm->udmamodes & 0x40)
1545                                 printf("6");
1546                         else if (parm->udmamodes & 0x20)
1547                                 printf("5");
1548                         else if (parm->udmamodes & 0x10)
1549                                 printf("4");
1550                         else if (parm->udmamodes & 0x08)
1551                                 printf("3");
1552                         else if (parm->udmamodes & 0x04)
1553                                 printf("2");
1554                         else if (parm->udmamodes & 0x02)
1555                                 printf("1");
1556                         else if (parm->udmamodes & 0x01)
1557                                 printf("0");
1558                         printf(" ");
1559                 }
1560         }
1561         printf("\n");
1562
1563         if (parm->media_rotation_rate == 1) {
1564                 printf("media RPM             non-rotating\n");
1565         } else if (parm->media_rotation_rate >= 0x0401 &&
1566             parm->media_rotation_rate <= 0xFFFE) {
1567                 printf("media RPM             %d\n",
1568                         parm->media_rotation_rate);
1569         }
1570
1571         printf("Zoned-Device Commands ");
1572         switch (parm->support3 & ATA_SUPPORT_ZONE_MASK) {
1573                 case ATA_SUPPORT_ZONE_DEV_MANAGED:
1574                         printf("device managed\n");
1575                         break;
1576                 case ATA_SUPPORT_ZONE_HOST_AWARE:
1577                         printf("host aware\n");
1578                         break;
1579                 default:
1580                         printf("no\n");
1581         }
1582
1583         printf("\nFeature                      "
1584                 "Support  Enabled   Value           Vendor\n");
1585         printf("read ahead                     %s       %s\n",
1586                 parm->support.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no",
1587                 parm->enabled.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no");
1588         printf("write cache                    %s       %s\n",
1589                 parm->support.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no",
1590                 parm->enabled.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no");
1591         printf("flush cache                    %s       %s\n",
1592                 parm->support.command2 & ATA_SUPPORT_FLUSHCACHE ? "yes" : "no",
1593                 parm->enabled.command2 & ATA_SUPPORT_FLUSHCACHE ? "yes" : "no");
1594         printf("Native Command Queuing (NCQ)   ");
1595         if (atasata(parm) && (parm->satacapabilities & ATA_SUPPORT_NCQ)) {
1596                 printf("yes             %d tags\n",
1597                     ATA_QUEUE_LEN(parm->queue) + 1);
1598                 printf("NCQ Priority Information       %s\n",
1599                     parm->satacapabilities & ATA_SUPPORT_NCQ_PRIO ?
1600                     "yes" : "no");
1601                 printf("NCQ Non-Data Command           %s\n",
1602                     parm->satacapabilities2 & ATA_SUPPORT_NCQ_NON_DATA ?
1603                     "yes" : "no");
1604                 printf("NCQ Streaming                  %s\n",
1605                     parm->satacapabilities2 & ATA_SUPPORT_NCQ_STREAM ?
1606                     "yes" : "no");
1607                 printf("Receive & Send FPDMA Queued    %s\n",
1608                     parm->satacapabilities2 & ATA_SUPPORT_RCVSND_FPDMA_QUEUED ?
1609                     "yes" : "no");
1610                 printf("NCQ Autosense                  %s\n",
1611                     parm->satasupport & ATA_SUPPORT_NCQ_AUTOSENSE ?
1612                     "yes" : "no");
1613         } else
1614                 printf("no\n");
1615
1616         printf("SMART                          %s       %s\n",
1617                 parm->support.command1 & ATA_SUPPORT_SMART ? "yes" : "no",
1618                 parm->enabled.command1 & ATA_SUPPORT_SMART ? "yes" : "no");
1619         printf("security                       %s       %s\n",
1620                 parm->support.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no",
1621                 parm->enabled.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no");
1622         printf("power management               %s       %s\n",
1623                 parm->support.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no",
1624                 parm->enabled.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no");
1625         printf("microcode download             %s       %s\n",
1626                 parm->support.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no",
1627                 parm->enabled.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no");
1628         printf("advanced power management      %s       %s",
1629                 parm->support.command2 & ATA_SUPPORT_APM ? "yes" : "no",
1630                 parm->enabled.command2 & ATA_SUPPORT_APM ? "yes" : "no");
1631                 if (parm->support.command2 & ATA_SUPPORT_APM) {
1632                         printf("        %d/0x%02X\n",
1633                             parm->apm_value & 0xff, parm->apm_value & 0xff);
1634                 } else
1635                         printf("\n");
1636         printf("automatic acoustic management  %s       %s",
1637                 parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no",
1638                 parm->enabled.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no");
1639                 if (parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC) {
1640                         printf("        %d/0x%02X       %d/0x%02X\n",
1641                             ATA_ACOUSTIC_CURRENT(parm->acoustic),
1642                             ATA_ACOUSTIC_CURRENT(parm->acoustic),
1643                             ATA_ACOUSTIC_VENDOR(parm->acoustic),
1644                             ATA_ACOUSTIC_VENDOR(parm->acoustic));
1645                 } else
1646                         printf("\n");
1647         printf("media status notification      %s       %s\n",
1648                 parm->support.command2 & ATA_SUPPORT_NOTIFY ? "yes" : "no",
1649                 parm->enabled.command2 & ATA_SUPPORT_NOTIFY ? "yes" : "no");
1650         printf("power-up in Standby            %s       %s\n",
1651                 parm->support.command2 & ATA_SUPPORT_STANDBY ? "yes" : "no",
1652                 parm->enabled.command2 & ATA_SUPPORT_STANDBY ? "yes" : "no");
1653         printf("write-read-verify              %s       %s",
1654                 parm->support2 & ATA_SUPPORT_WRITEREADVERIFY ? "yes" : "no",
1655                 parm->enabled2 & ATA_SUPPORT_WRITEREADVERIFY ? "yes" : "no");
1656                 if (parm->support2 & ATA_SUPPORT_WRITEREADVERIFY) {
1657                         printf("        %d/0x%x\n",
1658                             parm->wrv_mode, parm->wrv_mode);
1659                 } else
1660                         printf("\n");
1661         printf("unload                         %s       %s\n",
1662                 parm->support.extension & ATA_SUPPORT_UNLOAD ? "yes" : "no",
1663                 parm->enabled.extension & ATA_SUPPORT_UNLOAD ? "yes" : "no");
1664         printf("general purpose logging        %s       %s\n",
1665                 parm->support.extension & ATA_SUPPORT_GENLOG ? "yes" : "no",
1666                 parm->enabled.extension & ATA_SUPPORT_GENLOG ? "yes" : "no");
1667         printf("free-fall                      %s       %s\n",
1668                 parm->support2 & ATA_SUPPORT_FREEFALL ? "yes" : "no",
1669                 parm->enabled2 & ATA_SUPPORT_FREEFALL ? "yes" : "no");
1670         printf("sense data reporting           %s       %s\n",
1671                 parm->support2 & ATA_SUPPORT_SENSE_REPORT ? "yes" : "no",
1672                 parm->enabled2 & ATA_SUPPORT_SENSE_REPORT ? "yes" : "no");
1673         printf("extended power conditions      %s       %s\n",
1674                 parm->support2 & ATA_SUPPORT_EPC ? "yes" : "no",
1675                 parm->enabled2 & ATA_SUPPORT_EPC ? "yes" : "no");
1676         printf("device statistics notification %s       %s\n",
1677                 parm->support2 & ATA_SUPPORT_DSN ? "yes" : "no",
1678                 parm->enabled2 & ATA_SUPPORT_DSN ? "yes" : "no");
1679         printf("Data Set Management (DSM/TRIM) ");
1680         if (parm->support_dsm & ATA_SUPPORT_DSM_TRIM) {
1681                 printf("yes\n");
1682                 printf("DSM - max 512byte blocks       ");
1683                 if (parm->max_dsm_blocks == 0x00)
1684                         printf("yes              not specified\n");
1685                 else
1686                         printf("yes              %d\n",
1687                                 parm->max_dsm_blocks);
1688
1689                 printf("DSM - deterministic read       ");
1690                 if (parm->support3 & ATA_SUPPORT_DRAT) {
1691                         if (parm->support3 & ATA_SUPPORT_RZAT)
1692                                 printf("yes              zeroed\n");
1693                         else
1694                                 printf("yes              any value\n");
1695                 } else {
1696                         printf("no\n");
1697                 }
1698         } else {
1699                 printf("no\n");
1700         }
1701         printf("Trusted Computing              %s\n",
1702             ((parm->tcg & 0xc000) == 0x4000) && (parm->tcg & ATA_SUPPORT_TCG) ?
1703             "yes" : "no");
1704         printf("encrypts all user data         %s\n",
1705                 parm->support3 & ATA_ENCRYPTS_ALL_USER_DATA ? "yes" : "no");
1706         printf("Sanitize                       ");
1707         if (parm->multi & ATA_SUPPORT_SANITIZE) {
1708                 printf("yes\t\t%s%s%s\n",
1709                     parm->multi & ATA_SUPPORT_BLOCK_ERASE_EXT ? "block, " : "",
1710                     parm->multi & ATA_SUPPORT_OVERWRITE_EXT ? "overwrite, " : "",
1711                     parm->multi & ATA_SUPPORT_CRYPTO_SCRAMBLE_EXT ? "crypto" : "");
1712                 printf("Sanitize - commands allowed    %s\n",
1713                     parm->multi & ATA_SUPPORT_SANITIZE_ALLOWED ? "yes" : "no");
1714                 printf("Sanitize - antifreeze lock     %s\n",
1715                     parm->multi & ATA_SUPPORT_ANTIFREEZE_LOCK_EXT ? "yes" : "no");
1716         } else {
1717                 printf("no\n");
1718         }
1719 }
1720
1721 static int
1722 scsi_cam_pass_16_send(struct cam_device *device, union ccb *ccb)
1723 {
1724         struct ata_pass_16 *ata_pass_16;
1725         struct ata_cmd ata_cmd;
1726
1727         ata_pass_16 = (struct ata_pass_16 *)ccb->csio.cdb_io.cdb_bytes;
1728         ata_cmd.command = ata_pass_16->command;
1729         ata_cmd.control = ata_pass_16->control;
1730         ata_cmd.features = ata_pass_16->features;
1731
1732         if (arglist & CAM_ARG_VERBOSE) {
1733                 warnx("sending ATA %s via pass_16 with timeout of %u msecs",
1734                       ata_op_string(&ata_cmd),
1735                       ccb->csio.ccb_h.timeout);
1736         }
1737
1738         /* Disable freezing the device queue */
1739         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1740
1741         if (arglist & CAM_ARG_ERR_RECOVER)
1742                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
1743
1744         if (cam_send_ccb(device, ccb) < 0) {
1745                 warn("error sending ATA %s via pass_16", ata_op_string(&ata_cmd));
1746                 return (1);
1747         }
1748
1749         /*
1750          * Consider any non-CAM_REQ_CMP status as error and report it here,
1751          * unless caller set AP_FLAG_CHK_COND, in which case it is reponsible.
1752          */
1753         if (!(ata_pass_16->flags & AP_FLAG_CHK_COND) &&
1754             (ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1755                 warnx("ATA %s via pass_16 failed", ata_op_string(&ata_cmd));
1756                 if (arglist & CAM_ARG_VERBOSE) {
1757                         cam_error_print(device, ccb, CAM_ESF_ALL,
1758                                         CAM_EPF_ALL, stderr);
1759                 }
1760                 return (1);
1761         }
1762
1763         return (0);
1764 }
1765
1766
1767 static int
1768 ata_cam_send(struct cam_device *device, union ccb *ccb)
1769 {
1770         if (arglist & CAM_ARG_VERBOSE) {
1771                 warnx("sending ATA %s with timeout of %u msecs",
1772                       ata_op_string(&(ccb->ataio.cmd)),
1773                       ccb->ataio.ccb_h.timeout);
1774         }
1775
1776         /* Disable freezing the device queue */
1777         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1778
1779         if (arglist & CAM_ARG_ERR_RECOVER)
1780                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
1781
1782         if (cam_send_ccb(device, ccb) < 0) {
1783                 warn("error sending ATA %s", ata_op_string(&(ccb->ataio.cmd)));
1784                 return (1);
1785         }
1786
1787         /*
1788          * Consider any non-CAM_REQ_CMP status as error and report it here,
1789          * unless caller set AP_FLAG_CHK_COND, in which case it is reponsible.
1790          */
1791         if (!(ccb->ataio.cmd.flags & CAM_ATAIO_NEEDRESULT) &&
1792             (ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1793                 warnx("ATA %s failed", ata_op_string(&(ccb->ataio.cmd)));
1794                 if (arglist & CAM_ARG_VERBOSE) {
1795                         cam_error_print(device, ccb, CAM_ESF_ALL,
1796                                         CAM_EPF_ALL, stderr);
1797                 }
1798                 return (1);
1799         }
1800
1801         return (0);
1802 }
1803
1804 static int
1805 ata_do_pass_16(struct cam_device *device, union ccb *ccb, int retries,
1806                u_int32_t flags, u_int8_t protocol, u_int8_t ata_flags,
1807                u_int8_t tag_action, u_int8_t command, u_int16_t features,
1808                u_int64_t lba, u_int16_t sector_count, u_int8_t *data_ptr,
1809                u_int16_t dxfer_len, int timeout)
1810 {
1811         if (data_ptr != NULL) {
1812                 if (flags & CAM_DIR_OUT)
1813                         ata_flags |= AP_FLAG_TDIR_TO_DEV;
1814                 else
1815                         ata_flags |= AP_FLAG_TDIR_FROM_DEV;
1816         } else {
1817                 ata_flags |= AP_FLAG_TLEN_NO_DATA;
1818         }
1819
1820         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
1821
1822         scsi_ata_pass_16(&ccb->csio,
1823                          retries,
1824                          NULL,
1825                          flags,
1826                          tag_action,
1827                          protocol,
1828                          ata_flags,
1829                          features,
1830                          sector_count,
1831                          lba,
1832                          command,
1833                          /*control*/0,
1834                          data_ptr,
1835                          dxfer_len,
1836                          /*sense_len*/SSD_FULL_SIZE,
1837                          timeout);
1838
1839         return scsi_cam_pass_16_send(device, ccb);
1840 }
1841
1842 static int
1843 ata_try_pass_16(struct cam_device *device)
1844 {
1845         struct ccb_pathinq cpi;
1846
1847         if (get_cpi(device, &cpi) != 0) {
1848                 warnx("couldn't get CPI");
1849                 return (-1);
1850         }
1851
1852         if (cpi.protocol == PROTO_SCSI) {
1853                 /* possibly compatible with pass_16 */
1854                 return (1);
1855         }
1856
1857         /* likely not compatible with pass_16 */
1858         return (0);
1859 }
1860
1861 static int
1862 ata_do_cmd(struct cam_device *device, union ccb *ccb, int retries,
1863            u_int32_t flags, u_int8_t protocol, u_int8_t ata_flags,
1864            u_int8_t tag_action, u_int8_t command, u_int16_t features,
1865            u_int64_t lba, u_int16_t sector_count, u_int8_t *data_ptr,
1866            u_int16_t dxfer_len, int timeout, int force48bit)
1867 {
1868         int retval;
1869
1870         retval = ata_try_pass_16(device);
1871         if (retval == -1)
1872                 return (1);
1873
1874         if (retval == 1) {
1875                 return (ata_do_pass_16(device, ccb, retries, flags, protocol,
1876                                       ata_flags, tag_action, command, features,
1877                                       lba, sector_count, data_ptr, dxfer_len,
1878                                       timeout));
1879         }
1880
1881         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->ataio);
1882         cam_fill_ataio(&ccb->ataio,
1883                        retries,
1884                        NULL,
1885                        flags,
1886                        tag_action,
1887                        data_ptr,
1888                        dxfer_len,
1889                        timeout);
1890
1891         if (force48bit || lba > ATA_MAX_28BIT_LBA)
1892                 ata_48bit_cmd(&ccb->ataio, command, features, lba, sector_count);
1893         else
1894                 ata_28bit_cmd(&ccb->ataio, command, features, lba, sector_count);
1895
1896         if (ata_flags & AP_FLAG_CHK_COND)
1897                 ccb->ataio.cmd.flags |= CAM_ATAIO_NEEDRESULT;
1898
1899         return ata_cam_send(device, ccb);
1900 }
1901
1902 static void
1903 dump_data(uint16_t *ptr, uint32_t len)
1904 {
1905         u_int i;
1906
1907         for (i = 0; i < len / 2; i++) {
1908                 if ((i % 8) == 0)
1909                         printf(" %3d: ", i);
1910                 printf("%04hx ", ptr[i]);
1911                 if ((i % 8) == 7)
1912                         printf("\n");
1913         }
1914         if ((i % 8) != 7)
1915                 printf("\n");
1916 }
1917
1918 static int
1919 atahpa_proc_resp(struct cam_device *device, union ccb *ccb, u_int64_t *hpasize)
1920 {
1921         uint8_t error = 0, ata_device = 0, status = 0;
1922         uint16_t count = 0;
1923         uint64_t lba = 0;
1924         int retval;
1925
1926         retval = get_ata_status(device, ccb, &error, &count, &lba, &ata_device,
1927             &status);
1928         if (retval == 1) {
1929                 if (arglist & CAM_ARG_VERBOSE) {
1930                         cam_error_print(device, ccb, CAM_ESF_ALL,
1931                                         CAM_EPF_ALL, stderr);
1932                 }
1933                 warnx("Can't get ATA command status");
1934                 return (retval);
1935         }
1936
1937         if (status & ATA_STATUS_ERROR) {
1938                 if (arglist & CAM_ARG_VERBOSE) {
1939                         cam_error_print(device, ccb, CAM_ESF_ALL,
1940                                         CAM_EPF_ALL, stderr);
1941                 }
1942
1943                 if (error & ATA_ERROR_ID_NOT_FOUND) {
1944                         warnx("Max address has already been set since "
1945                               "last power-on or hardware reset");
1946                 } else if (hpasize == NULL)
1947                         warnx("Command failed with ATA error");
1948
1949                 return (1);
1950         }
1951
1952         if (hpasize != NULL) {
1953                 if (retval == 2 || retval == 6)
1954                         return (1);
1955                 *hpasize = lba + 1;
1956         }
1957
1958         return (0);
1959 }
1960
1961 static int
1962 ata_read_native_max(struct cam_device *device, int retry_count,
1963                       u_int32_t timeout, union ccb *ccb,
1964                       struct ata_params *parm, u_int64_t *hpasize)
1965 {
1966         int error;
1967         u_int cmd, is48bit;
1968         u_int8_t protocol;
1969
1970         is48bit = parm->support.command2 & ATA_SUPPORT_ADDRESS48;
1971         protocol = AP_PROTO_NON_DATA;
1972
1973         if (is48bit) {
1974                 cmd = ATA_READ_NATIVE_MAX_ADDRESS48;
1975                 protocol |= AP_EXTEND;
1976         } else {
1977                 cmd = ATA_READ_NATIVE_MAX_ADDRESS;
1978         }
1979
1980         error = ata_do_cmd(device,
1981                            ccb,
1982                            retry_count,
1983                            /*flags*/CAM_DIR_NONE,
1984                            /*protocol*/protocol,
1985                            /*ata_flags*/AP_FLAG_CHK_COND,
1986                            /*tag_action*/MSG_SIMPLE_Q_TAG,
1987                            /*command*/cmd,
1988                            /*features*/0,
1989                            /*lba*/0,
1990                            /*sector_count*/0,
1991                            /*data_ptr*/NULL,
1992                            /*dxfer_len*/0,
1993                            timeout ? timeout : 5000,
1994                            is48bit);
1995
1996         if (error)
1997                 return (error);
1998
1999         return atahpa_proc_resp(device, ccb, hpasize);
2000 }
2001
2002 static int
2003 atahpa_set_max(struct cam_device *device, int retry_count,
2004               u_int32_t timeout, union ccb *ccb,
2005               int is48bit, u_int64_t maxsize, int persist)
2006 {
2007         int error;
2008         u_int cmd;
2009         u_int8_t protocol;
2010
2011         protocol = AP_PROTO_NON_DATA;
2012
2013         if (is48bit) {
2014                 cmd = ATA_SET_MAX_ADDRESS48;
2015                 protocol |= AP_EXTEND;
2016         } else {
2017                 cmd = ATA_SET_MAX_ADDRESS;
2018         }
2019
2020         /* lba's are zero indexed so the max lba is requested max - 1 */
2021         if (maxsize)
2022                 maxsize--;
2023
2024         error = ata_do_cmd(device,
2025                            ccb,
2026                            retry_count,
2027                            /*flags*/CAM_DIR_NONE,
2028                            /*protocol*/protocol,
2029                            /*ata_flags*/AP_FLAG_CHK_COND,
2030                            /*tag_action*/MSG_SIMPLE_Q_TAG,
2031                            /*command*/cmd,
2032                            /*features*/ATA_HPA_FEAT_MAX_ADDR,
2033                            /*lba*/maxsize,
2034                            /*sector_count*/persist,
2035                            /*data_ptr*/NULL,
2036                            /*dxfer_len*/0,
2037                            timeout ? timeout : 1000,
2038                            is48bit);
2039
2040         if (error)
2041                 return (error);
2042
2043         return atahpa_proc_resp(device, ccb, NULL);
2044 }
2045
2046 static int
2047 atahpa_password(struct cam_device *device, int retry_count,
2048                 u_int32_t timeout, union ccb *ccb,
2049                 int is48bit, struct ata_set_max_pwd *pwd)
2050 {
2051         u_int cmd;
2052         u_int8_t protocol;
2053
2054         protocol = AP_PROTO_PIO_OUT;
2055         cmd = (is48bit) ? ATA_SET_MAX_ADDRESS48 : ATA_SET_MAX_ADDRESS;
2056
2057         return (ata_do_cmd(device,
2058                            ccb,
2059                            retry_count,
2060                            /*flags*/CAM_DIR_OUT,
2061                            /*protocol*/protocol,
2062                            /*ata_flags*/AP_FLAG_BYT_BLOK_BLOCKS |
2063                             AP_FLAG_TLEN_SECT_CNT,
2064                            /*tag_action*/MSG_SIMPLE_Q_TAG,
2065                            /*command*/cmd,
2066                            /*features*/ATA_HPA_FEAT_SET_PWD,
2067                            /*lba*/0,
2068                            /*sector_count*/sizeof(*pwd) / 512,
2069                            /*data_ptr*/(u_int8_t*)pwd,
2070                            /*dxfer_len*/sizeof(*pwd),
2071                            timeout ? timeout : 1000,
2072                            is48bit));
2073 }
2074
2075 static int
2076 atahpa_lock(struct cam_device *device, int retry_count,
2077             u_int32_t timeout, union ccb *ccb, int is48bit)
2078 {
2079         u_int cmd;
2080         u_int8_t protocol;
2081
2082         protocol = AP_PROTO_NON_DATA;
2083         cmd = (is48bit) ? ATA_SET_MAX_ADDRESS48 : ATA_SET_MAX_ADDRESS;
2084
2085         return (ata_do_cmd(device,
2086                            ccb,
2087                            retry_count,
2088                            /*flags*/CAM_DIR_NONE,
2089                            /*protocol*/protocol,
2090                            /*ata_flags*/0,
2091                            /*tag_action*/MSG_SIMPLE_Q_TAG,
2092                            /*command*/cmd,
2093                            /*features*/ATA_HPA_FEAT_LOCK,
2094                            /*lba*/0,
2095                            /*sector_count*/0,
2096                            /*data_ptr*/NULL,
2097                            /*dxfer_len*/0,
2098                            timeout ? timeout : 1000,
2099                            is48bit));
2100 }
2101
2102 static int
2103 atahpa_unlock(struct cam_device *device, int retry_count,
2104               u_int32_t timeout, union ccb *ccb,
2105               int is48bit, struct ata_set_max_pwd *pwd)
2106 {
2107         u_int cmd;
2108         u_int8_t protocol;
2109
2110         protocol = AP_PROTO_PIO_OUT;
2111         cmd = (is48bit) ? ATA_SET_MAX_ADDRESS48 : ATA_SET_MAX_ADDRESS;
2112
2113         return (ata_do_cmd(device,
2114                            ccb,
2115                            retry_count,
2116                            /*flags*/CAM_DIR_OUT,
2117                            /*protocol*/protocol,
2118                            /*ata_flags*/AP_FLAG_BYT_BLOK_BLOCKS |
2119                             AP_FLAG_TLEN_SECT_CNT,
2120                            /*tag_action*/MSG_SIMPLE_Q_TAG,
2121                            /*command*/cmd,
2122                            /*features*/ATA_HPA_FEAT_UNLOCK,
2123                            /*lba*/0,
2124                            /*sector_count*/sizeof(*pwd) / 512,
2125                            /*data_ptr*/(u_int8_t*)pwd,
2126                            /*dxfer_len*/sizeof(*pwd),
2127                            timeout ? timeout : 1000,
2128                            is48bit));
2129 }
2130
2131 static int
2132 atahpa_freeze_lock(struct cam_device *device, int retry_count,
2133                    u_int32_t timeout, union ccb *ccb, int is48bit)
2134 {
2135         u_int cmd;
2136         u_int8_t protocol;
2137
2138         protocol = AP_PROTO_NON_DATA;
2139         cmd = (is48bit) ? ATA_SET_MAX_ADDRESS48 : ATA_SET_MAX_ADDRESS;
2140
2141         return (ata_do_cmd(device,
2142                            ccb,
2143                            retry_count,
2144                            /*flags*/CAM_DIR_NONE,
2145                            /*protocol*/protocol,
2146                            /*ata_flags*/0,
2147                            /*tag_action*/MSG_SIMPLE_Q_TAG,
2148                            /*command*/cmd,
2149                            /*features*/ATA_HPA_FEAT_FREEZE,
2150                            /*lba*/0,
2151                            /*sector_count*/0,
2152                            /*data_ptr*/NULL,
2153                            /*dxfer_len*/0,
2154                            timeout ? timeout : 1000,
2155                            is48bit));
2156 }
2157
2158 static int
2159 ata_get_native_max(struct cam_device *device, int retry_count,
2160                       u_int32_t timeout, union ccb *ccb,
2161                       u_int64_t *nativesize)
2162 {
2163         int error;
2164
2165         error = ata_do_cmd(device,
2166                            ccb,
2167                            retry_count,
2168                            /*flags*/CAM_DIR_NONE,
2169                            /*protocol*/AP_PROTO_NON_DATA | AP_EXTEND,
2170                            /*ata_flags*/AP_FLAG_CHK_COND,
2171                            /*tag_action*/MSG_SIMPLE_Q_TAG,
2172                            /*command*/ATA_AMAX_ADDR,
2173                            /*features*/ATA_AMAX_ADDR_GET,
2174                            /*lba*/0,
2175                            /*sector_count*/0,
2176                            /*data_ptr*/NULL,
2177                            /*dxfer_len*/0,
2178                            timeout ? timeout : 30 * 1000,
2179                            /*force48bit*/1);
2180
2181         if (error)
2182                 return (error);
2183
2184         return atahpa_proc_resp(device, ccb, nativesize);
2185 }
2186
2187 static int
2188 ataama_set(struct cam_device *device, int retry_count,
2189               u_int32_t timeout, union ccb *ccb, u_int64_t maxsize)
2190 {
2191         int error;
2192
2193         /* lba's are zero indexed so the max lba is requested max - 1 */
2194         if (maxsize)
2195                 maxsize--;
2196
2197         error = ata_do_cmd(device,
2198                            ccb,
2199                            retry_count,
2200                            /*flags*/CAM_DIR_NONE,
2201                            /*protocol*/AP_PROTO_NON_DATA | AP_EXTEND,
2202                            /*ata_flags*/AP_FLAG_CHK_COND,
2203                            /*tag_action*/MSG_SIMPLE_Q_TAG,
2204                            /*command*/ATA_AMAX_ADDR,
2205                            /*features*/ATA_AMAX_ADDR_SET,
2206                            /*lba*/maxsize,
2207                            /*sector_count*/0,
2208                            /*data_ptr*/NULL,
2209                            /*dxfer_len*/0,
2210                            timeout ? timeout : 30 * 1000,
2211                            /*force48bit*/1);
2212
2213         if (error)
2214                 return (error);
2215
2216         return atahpa_proc_resp(device, ccb, NULL);
2217 }
2218
2219 static int
2220 ataama_freeze(struct cam_device *device, int retry_count,
2221                    u_int32_t timeout, union ccb *ccb)
2222 {
2223
2224         return (ata_do_cmd(device,
2225                            ccb,
2226                            retry_count,
2227                            /*flags*/CAM_DIR_NONE,
2228                            /*protocol*/AP_PROTO_NON_DATA | AP_EXTEND,
2229                            /*ata_flags*/0,
2230                            /*tag_action*/MSG_SIMPLE_Q_TAG,
2231                            /*command*/ATA_AMAX_ADDR,
2232                            /*features*/ATA_AMAX_ADDR_FREEZE,
2233                            /*lba*/0,
2234                            /*sector_count*/0,
2235                            /*data_ptr*/NULL,
2236                            /*dxfer_len*/0,
2237                            timeout ? timeout : 30 * 1000,
2238                            /*force48bit*/1));
2239 }
2240
2241 int
2242 ata_do_identify(struct cam_device *device, int retry_count, int timeout,
2243                 union ccb *ccb, struct ata_params** ident_bufp)
2244 {
2245         struct ata_params *ident_buf;
2246         struct ccb_pathinq cpi;
2247         struct ccb_getdev cgd;
2248         u_int i, error;
2249         int16_t *ptr;
2250         u_int8_t command, retry_command;
2251
2252         if (get_cpi(device, &cpi) != 0) {
2253                 warnx("couldn't get CPI");
2254                 return (-1);
2255         }
2256
2257         /* Neither PROTO_ATAPI or PROTO_SATAPM are used in cpi.protocol */
2258         if (cpi.protocol == PROTO_ATA) {
2259                 if (get_cgd(device, &cgd) != 0) {
2260                         warnx("couldn't get CGD");
2261                         return (-1);
2262                 }
2263
2264                 command = (cgd.protocol == PROTO_ATA) ?
2265                     ATA_ATA_IDENTIFY : ATA_ATAPI_IDENTIFY;
2266                 retry_command = 0;
2267         } else {
2268                 /* We don't know which for sure so try both */
2269                 command = ATA_ATA_IDENTIFY;
2270                 retry_command = ATA_ATAPI_IDENTIFY;
2271         }
2272
2273         ptr = (uint16_t *)calloc(1, sizeof(struct ata_params));
2274         if (ptr == NULL) {
2275                 warnx("can't calloc memory for identify\n");
2276                 return (1);
2277         }
2278
2279 retry:
2280         error = ata_do_cmd(device,
2281                            ccb,
2282                            /*retries*/retry_count,
2283                            /*flags*/CAM_DIR_IN,
2284                            /*protocol*/AP_PROTO_PIO_IN,
2285                            /*ata_flags*/AP_FLAG_BYT_BLOK_BLOCKS |
2286                             AP_FLAG_TLEN_SECT_CNT,
2287                            /*tag_action*/MSG_SIMPLE_Q_TAG,
2288                            /*command*/command,
2289                            /*features*/0,
2290                            /*lba*/0,
2291                            /*sector_count*/sizeof(struct ata_params) / 512,
2292                            /*data_ptr*/(u_int8_t *)ptr,
2293                            /*dxfer_len*/sizeof(struct ata_params),
2294                            /*timeout*/timeout ? timeout : 30 * 1000,
2295                            /*force48bit*/0);
2296
2297         if (error != 0) {
2298                 if (retry_command != 0) {
2299                         command = retry_command;
2300                         retry_command = 0;
2301                         goto retry;
2302                 }
2303                 free(ptr);
2304                 return (1);
2305         }
2306
2307         ident_buf = (struct ata_params *)ptr;
2308         ata_param_fixup(ident_buf);
2309
2310         error = 1;
2311         for (i = 0; i < sizeof(struct ata_params) / 2; i++) {
2312                 if (ptr[i] != 0)
2313                         error = 0;
2314         }
2315
2316         /* check for invalid (all zero) response */
2317         if (error != 0) {
2318                 warnx("Invalid identify response detected");
2319                 free(ptr);
2320                 return (error);
2321         }
2322
2323         *ident_bufp = ident_buf;
2324
2325         return (0);
2326 }
2327
2328
2329 static int
2330 ataidentify(struct cam_device *device, int retry_count, int timeout)
2331 {
2332         union ccb *ccb;
2333         struct ata_params *ident_buf;
2334         u_int64_t hpasize = 0, nativesize = 0;
2335
2336         if ((ccb = cam_getccb(device)) == NULL) {
2337                 warnx("couldn't allocate CCB");
2338                 return (1);
2339         }
2340
2341         if (ata_do_identify(device, retry_count, timeout, ccb, &ident_buf) != 0) {
2342                 cam_freeccb(ccb);
2343                 return (1);
2344         }
2345
2346         if (arglist & CAM_ARG_VERBOSE) {
2347                 printf("%s%d: Raw identify data:\n",
2348                     device->device_name, device->dev_unit_num);
2349                 dump_data((uint16_t *)ident_buf, sizeof(struct ata_params));
2350         }
2351
2352         if (ident_buf->support.command1 & ATA_SUPPORT_PROTECTED) {
2353                 ata_read_native_max(device, retry_count, timeout, ccb,
2354                                     ident_buf, &hpasize);
2355         }
2356         if (ident_buf->support2 & ATA_SUPPORT_AMAX_ADDR) {
2357                 ata_get_native_max(device, retry_count, timeout, ccb,
2358                                    &nativesize);
2359         }
2360
2361         printf("%s%d: ", device->device_name, device->dev_unit_num);
2362         ata_print_ident(ident_buf);
2363         camxferrate(device);
2364         atacapprint(ident_buf);
2365         atahpa_print(ident_buf, hpasize, 0);
2366         ataama_print(ident_buf, nativesize, 0);
2367
2368         free(ident_buf);
2369         cam_freeccb(ccb);
2370
2371         return (0);
2372 }
2373
2374 #ifdef WITH_NVME
2375 static int
2376 nvmeidentify(struct cam_device *device, int retry_count __unused, int timeout __unused)
2377 {
2378         struct nvme_controller_data cdata;
2379
2380         if (nvme_get_cdata(device, &cdata))
2381                 return (1);
2382         nvme_print_controller(&cdata);
2383
2384         return (0);
2385 }
2386 #endif
2387
2388 static int
2389 identify(struct cam_device *device, int retry_count, int timeout)
2390 {
2391 #ifdef WITH_NVME
2392         struct ccb_pathinq cpi;
2393
2394         if (get_cpi(device, &cpi) != 0) {
2395                 warnx("couldn't get CPI");
2396                 return (-1);
2397         }
2398
2399         if (cpi.protocol == PROTO_NVME) {
2400                 return (nvmeidentify(device, retry_count, timeout));
2401         }
2402 #endif
2403         return (ataidentify(device, retry_count, timeout));
2404 }
2405
2406
2407 enum {
2408         ATA_SECURITY_ACTION_PRINT,
2409         ATA_SECURITY_ACTION_FREEZE,
2410         ATA_SECURITY_ACTION_UNLOCK,
2411         ATA_SECURITY_ACTION_DISABLE,
2412         ATA_SECURITY_ACTION_ERASE,
2413         ATA_SECURITY_ACTION_ERASE_ENHANCED,
2414         ATA_SECURITY_ACTION_SET_PASSWORD
2415 };
2416
2417 static void
2418 atasecurity_print_time(u_int16_t tw)
2419 {
2420
2421         if (tw == 0)
2422                 printf("unspecified");
2423         else if (tw >= 255)
2424                 printf("> 508 min");
2425         else
2426                 printf("%i min", 2 * tw);
2427 }
2428
2429 static u_int32_t
2430 atasecurity_erase_timeout_msecs(u_int16_t timeout)
2431 {
2432
2433         if (timeout == 0)
2434                 return 2 * 3600 * 1000; /* default: two hours */
2435         else if (timeout > 255)
2436                 return (508 + 60) * 60 * 1000; /* spec says > 508 minutes */
2437
2438         return ((2 * timeout) + 5) * 60 * 1000; /* add a 5min margin */
2439 }
2440
2441
2442 static void
2443 atasecurity_notify(u_int8_t command, struct ata_security_password *pwd)
2444 {
2445         struct ata_cmd cmd;
2446
2447         bzero(&cmd, sizeof(cmd));
2448         cmd.command = command;
2449         printf("Issuing %s", ata_op_string(&cmd));
2450
2451         if (pwd != NULL) {
2452                 /* pwd->password may not be null terminated */
2453                 char pass[sizeof(pwd->password)+1];
2454
2455                 strlcpy(pass, pwd->password, sizeof(pass));
2456                 printf(" password='%s', user='%s'",
2457                         pass,
2458                         (pwd->ctrl & ATA_SECURITY_PASSWORD_MASTER) ?
2459                         "master" : "user");
2460
2461                 if (command == ATA_SECURITY_SET_PASSWORD) {
2462                         printf(", mode='%s'",
2463                                (pwd->ctrl & ATA_SECURITY_LEVEL_MAXIMUM) ?
2464                                "maximum" : "high");
2465                 }
2466         }
2467
2468         printf("\n");
2469 }
2470
2471 static int
2472 atasecurity_freeze(struct cam_device *device, union ccb *ccb,
2473                    int retry_count, u_int32_t timeout, int quiet)
2474 {
2475
2476         if (quiet == 0)
2477                 atasecurity_notify(ATA_SECURITY_FREEZE_LOCK, NULL);
2478
2479         return ata_do_cmd(device,
2480                           ccb,
2481                           retry_count,
2482                           /*flags*/CAM_DIR_NONE,
2483                           /*protocol*/AP_PROTO_NON_DATA,
2484                           /*ata_flags*/0,
2485                           /*tag_action*/MSG_SIMPLE_Q_TAG,
2486                           /*command*/ATA_SECURITY_FREEZE_LOCK,
2487                           /*features*/0,
2488                           /*lba*/0,
2489                           /*sector_count*/0,
2490                           /*data_ptr*/NULL,
2491                           /*dxfer_len*/0,
2492                           /*timeout*/timeout,
2493                           /*force48bit*/0);
2494 }
2495
2496 static int
2497 atasecurity_unlock(struct cam_device *device, union ccb *ccb,
2498                    int retry_count, u_int32_t timeout,
2499                    struct ata_security_password *pwd, int quiet)
2500 {
2501
2502         if (quiet == 0)
2503                 atasecurity_notify(ATA_SECURITY_UNLOCK, pwd);
2504
2505         return ata_do_cmd(device,
2506                           ccb,
2507                           retry_count,
2508                           /*flags*/CAM_DIR_OUT,
2509                           /*protocol*/AP_PROTO_PIO_OUT,
2510                           /*ata_flags*/AP_FLAG_BYT_BLOK_BLOCKS |
2511                             AP_FLAG_TLEN_SECT_CNT,
2512                           /*tag_action*/MSG_SIMPLE_Q_TAG,
2513                           /*command*/ATA_SECURITY_UNLOCK,
2514                           /*features*/0,
2515                           /*lba*/0,
2516                           /*sector_count*/sizeof(*pwd) / 512,
2517                           /*data_ptr*/(u_int8_t *)pwd,
2518                           /*dxfer_len*/sizeof(*pwd),
2519                           /*timeout*/timeout,
2520                           /*force48bit*/0);
2521 }
2522
2523 static int
2524 atasecurity_disable(struct cam_device *device, union ccb *ccb,
2525                     int retry_count, u_int32_t timeout,
2526                     struct ata_security_password *pwd, int quiet)
2527 {
2528
2529         if (quiet == 0)
2530                 atasecurity_notify(ATA_SECURITY_DISABLE_PASSWORD, pwd);
2531         return ata_do_cmd(device,
2532                           ccb,
2533                           retry_count,
2534                           /*flags*/CAM_DIR_OUT,
2535                           /*protocol*/AP_PROTO_PIO_OUT,
2536                           /*ata_flags*/AP_FLAG_BYT_BLOK_BLOCKS |
2537                             AP_FLAG_TLEN_SECT_CNT,
2538                           /*tag_action*/MSG_SIMPLE_Q_TAG,
2539                           /*command*/ATA_SECURITY_DISABLE_PASSWORD,
2540                           /*features*/0,
2541                           /*lba*/0,
2542                           /*sector_count*/sizeof(*pwd) / 512,
2543                           /*data_ptr*/(u_int8_t *)pwd,
2544                           /*dxfer_len*/sizeof(*pwd),
2545                           /*timeout*/timeout,
2546                           /*force48bit*/0);
2547 }
2548
2549
2550 static int
2551 atasecurity_erase_confirm(struct cam_device *device,
2552                           struct ata_params* ident_buf)
2553 {
2554
2555         printf("\nYou are about to ERASE ALL DATA from the following"
2556                " device:\n%s%d,%s%d: ", device->device_name,
2557                device->dev_unit_num, device->given_dev_name,
2558                device->given_unit_number);
2559         ata_print_ident(ident_buf);
2560
2561         for(;;) {
2562                 char str[50];
2563                 printf("\nAre you SURE you want to ERASE ALL DATA? (yes/no) ");
2564
2565                 if (fgets(str, sizeof(str), stdin) != NULL) {
2566                         if (strncasecmp(str, "yes", 3) == 0) {
2567                                 return (1);
2568                         } else if (strncasecmp(str, "no", 2) == 0) {
2569                                 return (0);
2570                         } else {
2571                                 printf("Please answer \"yes\" or "
2572                                        "\"no\"\n");
2573                         }
2574                 }
2575         }
2576
2577         /* NOTREACHED */
2578         return (0);
2579 }
2580
2581 static int
2582 atasecurity_erase(struct cam_device *device, union ccb *ccb,
2583                   int retry_count, u_int32_t timeout,
2584                   u_int32_t erase_timeout,
2585                   struct ata_security_password *pwd, int quiet)
2586 {
2587         int error;
2588
2589         if (quiet == 0)
2590                 atasecurity_notify(ATA_SECURITY_ERASE_PREPARE, NULL);
2591
2592         error = ata_do_cmd(device,
2593                            ccb,
2594                            retry_count,
2595                            /*flags*/CAM_DIR_NONE,
2596                            /*protocol*/AP_PROTO_NON_DATA,
2597                            /*ata_flags*/0,
2598                            /*tag_action*/MSG_SIMPLE_Q_TAG,
2599                            /*command*/ATA_SECURITY_ERASE_PREPARE,
2600                            /*features*/0,
2601                            /*lba*/0,
2602                            /*sector_count*/0,
2603                            /*data_ptr*/NULL,
2604                            /*dxfer_len*/0,
2605                            /*timeout*/timeout,
2606                            /*force48bit*/0);
2607
2608         if (error != 0)
2609                 return error;
2610
2611         if (quiet == 0)
2612                 atasecurity_notify(ATA_SECURITY_ERASE_UNIT, pwd);
2613
2614         error = ata_do_cmd(device,
2615                            ccb,
2616                            retry_count,
2617                            /*flags*/CAM_DIR_OUT,
2618                            /*protocol*/AP_PROTO_PIO_OUT,
2619                            /*ata_flags*/AP_FLAG_BYT_BLOK_BLOCKS |
2620                             AP_FLAG_TLEN_SECT_CNT,
2621                            /*tag_action*/MSG_SIMPLE_Q_TAG,
2622                            /*command*/ATA_SECURITY_ERASE_UNIT,
2623                            /*features*/0,
2624                            /*lba*/0,
2625                            /*sector_count*/sizeof(*pwd) / 512,
2626                            /*data_ptr*/(u_int8_t *)pwd,
2627                            /*dxfer_len*/sizeof(*pwd),
2628                            /*timeout*/erase_timeout,
2629                            /*force48bit*/0);
2630
2631         if (error == 0 && quiet == 0)
2632                 printf("\nErase Complete\n");
2633
2634         return error;
2635 }
2636
2637 static int
2638 atasecurity_set_password(struct cam_device *device, union ccb *ccb,
2639                          int retry_count, u_int32_t timeout,
2640                          struct ata_security_password *pwd, int quiet)
2641 {
2642
2643         if (quiet == 0)
2644                 atasecurity_notify(ATA_SECURITY_SET_PASSWORD, pwd);
2645
2646         return ata_do_cmd(device,
2647                           ccb,
2648                           retry_count,
2649                           /*flags*/CAM_DIR_OUT,
2650                           /*protocol*/AP_PROTO_PIO_OUT,
2651                           /*ata_flags*/AP_FLAG_BYT_BLOK_BLOCKS |
2652                            AP_FLAG_TLEN_SECT_CNT,
2653                           /*tag_action*/MSG_SIMPLE_Q_TAG,
2654                           /*command*/ATA_SECURITY_SET_PASSWORD,
2655                           /*features*/0,
2656                           /*lba*/0,
2657                           /*sector_count*/sizeof(*pwd) / 512,
2658                           /*data_ptr*/(u_int8_t *)pwd,
2659                           /*dxfer_len*/sizeof(*pwd),
2660                           /*timeout*/timeout,
2661                           /*force48bit*/0);
2662 }
2663
2664 static void
2665 atasecurity_print(struct ata_params *parm)
2666 {
2667
2668         printf("\nSecurity Option           Value\n");
2669         if (arglist & CAM_ARG_VERBOSE) {
2670                 printf("status                    %04x\n",
2671                        parm->security_status);
2672         }
2673         printf("supported                 %s\n",
2674                 parm->security_status & ATA_SECURITY_SUPPORTED ? "yes" : "no");
2675         if (!(parm->security_status & ATA_SECURITY_SUPPORTED))
2676                 return;
2677         printf("enabled                   %s\n",
2678                 parm->security_status & ATA_SECURITY_ENABLED ? "yes" : "no");
2679         printf("drive locked              %s\n",
2680                 parm->security_status & ATA_SECURITY_LOCKED ? "yes" : "no");
2681         printf("security config frozen    %s\n",
2682                 parm->security_status & ATA_SECURITY_FROZEN ? "yes" : "no");
2683         printf("count expired             %s\n",
2684                 parm->security_status & ATA_SECURITY_COUNT_EXP ? "yes" : "no");
2685         printf("security level            %s\n",
2686                 parm->security_status & ATA_SECURITY_LEVEL ? "maximum" : "high");
2687         printf("enhanced erase supported  %s\n",
2688                 parm->security_status & ATA_SECURITY_ENH_SUPP ? "yes" : "no");
2689         printf("erase time                ");
2690         atasecurity_print_time(parm->erase_time);
2691         printf("\n");
2692         printf("enhanced erase time       ");
2693         atasecurity_print_time(parm->enhanced_erase_time);
2694         printf("\n");
2695         printf("master password rev       %04x%s\n",
2696                 parm->master_passwd_revision,
2697                 parm->master_passwd_revision == 0x0000 ||
2698                 parm->master_passwd_revision == 0xFFFF ?  " (unsupported)" : "");
2699 }
2700
2701 /*
2702  * Validates and copies the password in optarg to the passed buffer.
2703  * If the password in optarg is the same length as the buffer then
2704  * the data will still be copied but no null termination will occur.
2705  */
2706 static int
2707 ata_getpwd(u_int8_t *passwd, int max, char opt)
2708 {
2709         int len;
2710
2711         len = strlen(optarg);
2712         if (len > max) {
2713                 warnx("-%c password is too long", opt);
2714                 return (1);
2715         } else if (len == 0) {
2716                 warnx("-%c password is missing", opt);
2717                 return (1);
2718         } else if (optarg[0] == '-'){
2719                 warnx("-%c password starts with '-' (generic arg?)", opt);
2720                 return (1);
2721         } else if (strlen(passwd) != 0 && strcmp(passwd, optarg) != 0) {
2722                 warnx("-%c password conflicts with existing password from -%c",
2723                       opt, pwd_opt);
2724                 return (1);
2725         }
2726
2727         /* Callers pass in a buffer which does NOT need to be terminated */
2728         strncpy(passwd, optarg, max);
2729         pwd_opt = opt;
2730
2731         return (0);
2732 }
2733
2734 enum {
2735         ATA_HPA_ACTION_PRINT,
2736         ATA_HPA_ACTION_SET_MAX,
2737         ATA_HPA_ACTION_SET_PWD,
2738         ATA_HPA_ACTION_LOCK,
2739         ATA_HPA_ACTION_UNLOCK,
2740         ATA_HPA_ACTION_FREEZE_LOCK
2741 };
2742
2743 static int
2744 atahpa_set_confirm(struct cam_device *device, struct ata_params* ident_buf,
2745                    u_int64_t maxsize, int persist)
2746 {
2747         printf("\nYou are about to configure HPA to limit the user accessible\n"
2748                "sectors to %ju %s on the device:\n%s%d,%s%d: ", maxsize,
2749                persist ? "persistently" : "temporarily",
2750                device->device_name, device->dev_unit_num,
2751                device->given_dev_name, device->given_unit_number);
2752         ata_print_ident(ident_buf);
2753
2754         for(;;) {
2755                 char str[50];
2756                 printf("\nAre you SURE you want to configure HPA? (yes/no) ");
2757
2758                 if (NULL != fgets(str, sizeof(str), stdin)) {
2759                         if (0 == strncasecmp(str, "yes", 3)) {
2760                                 return (1);
2761                         } else if (0 == strncasecmp(str, "no", 2)) {
2762                                 return (0);
2763                         } else {
2764                                 printf("Please answer \"yes\" or "
2765                                        "\"no\"\n");
2766                         }
2767                 }
2768         }
2769
2770         /* NOTREACHED */
2771         return (0);
2772 }
2773
2774 static int
2775 atahpa(struct cam_device *device, int retry_count, int timeout,
2776        int argc, char **argv, char *combinedopt)
2777 {
2778         union ccb *ccb;
2779         struct ata_params *ident_buf;
2780         struct ccb_getdev cgd;
2781         struct ata_set_max_pwd pwd;
2782         int error, confirm, quiet, c, action, actions, persist;
2783         int security, is48bit, pwdsize;
2784         u_int64_t hpasize, maxsize;
2785
2786         actions = 0;
2787         confirm = 0;
2788         quiet = 0;
2789         maxsize = 0;
2790         persist = 0;
2791         security = 0;
2792
2793         memset(&pwd, 0, sizeof(pwd));
2794
2795         /* default action is to print hpa information */
2796         action = ATA_HPA_ACTION_PRINT;
2797         pwdsize = sizeof(pwd.password);
2798
2799         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2800                 switch(c){
2801                 case 's':
2802                         action = ATA_HPA_ACTION_SET_MAX;
2803                         maxsize = strtoumax(optarg, NULL, 0);
2804                         actions++;
2805                         break;
2806
2807                 case 'p':
2808                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
2809                                 return (1);
2810                         action = ATA_HPA_ACTION_SET_PWD;
2811                         security = 1;
2812                         actions++;
2813                         break;
2814
2815                 case 'l':
2816                         action = ATA_HPA_ACTION_LOCK;
2817                         security = 1;
2818                         actions++;
2819                         break;
2820
2821                 case 'U':
2822                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
2823                                 return (1);
2824                         action = ATA_HPA_ACTION_UNLOCK;
2825                         security = 1;
2826                         actions++;
2827                         break;
2828
2829                 case 'f':
2830                         action = ATA_HPA_ACTION_FREEZE_LOCK;
2831                         security = 1;
2832                         actions++;
2833                         break;
2834
2835                 case 'P':
2836                         persist = 1;
2837                         break;
2838
2839                 case 'y':
2840                         confirm++;
2841                         break;
2842
2843                 case 'q':
2844                         quiet++;
2845                         break;
2846                 }
2847         }
2848
2849         if (actions > 1) {
2850                 warnx("too many hpa actions specified");
2851                 return (1);
2852         }
2853
2854         if (get_cgd(device, &cgd) != 0) {
2855                 warnx("couldn't get CGD");
2856                 return (1);
2857         }
2858
2859         ccb = cam_getccb(device);
2860         if (ccb == NULL) {
2861                 warnx("couldn't allocate CCB");
2862                 return (1);
2863         }
2864
2865         error = ata_do_identify(device, retry_count, timeout, ccb, &ident_buf);
2866         if (error != 0) {
2867                 cam_freeccb(ccb);
2868                 return (1);
2869         }
2870
2871         if (quiet == 0) {
2872                 printf("%s%d: ", device->device_name, device->dev_unit_num);
2873                 ata_print_ident(ident_buf);
2874                 camxferrate(device);
2875         }
2876
2877         if (action == ATA_HPA_ACTION_PRINT) {
2878                 hpasize = 0;
2879                 if (ident_buf->support.command1 & ATA_SUPPORT_PROTECTED)
2880                         ata_read_native_max(device, retry_count, timeout, ccb,
2881                                     ident_buf, &hpasize);
2882                 atahpa_print(ident_buf, hpasize, 1);
2883
2884                 cam_freeccb(ccb);
2885                 free(ident_buf);
2886                 return (error);
2887         }
2888
2889         if (!(ident_buf->support.command1 & ATA_SUPPORT_PROTECTED)) {
2890                 warnx("HPA is not supported by this device");
2891                 cam_freeccb(ccb);
2892                 free(ident_buf);
2893                 return (1);
2894         }
2895
2896         if (security && !(ident_buf->support.command2 & ATA_SUPPORT_MAXSECURITY)) {
2897                 warnx("HPA Security is not supported by this device");
2898                 cam_freeccb(ccb);
2899                 free(ident_buf);
2900                 return (1);
2901         }
2902
2903         is48bit = ident_buf->support.command2 & ATA_SUPPORT_ADDRESS48;
2904
2905         /*
2906          * The ATA spec requires:
2907          * 1. Read native max addr is called directly before set max addr
2908          * 2. Read native max addr is NOT called before any other set max call
2909          */
2910         switch(action) {
2911         case ATA_HPA_ACTION_SET_MAX:
2912                 if (confirm == 0 &&
2913                     atahpa_set_confirm(device, ident_buf, maxsize,
2914                     persist) == 0) {
2915                         cam_freeccb(ccb);
2916                         free(ident_buf);
2917                         return (1);
2918                 }
2919
2920                 error = ata_read_native_max(device, retry_count, timeout,
2921                                             ccb, ident_buf, &hpasize);
2922                 if (error == 0) {
2923                         error = atahpa_set_max(device, retry_count, timeout,
2924                                                ccb, is48bit, maxsize, persist);
2925                         if (error == 0) {
2926                                 if (quiet == 0) {
2927                                         /* redo identify to get new values */
2928                                         error = ata_do_identify(device,
2929                                             retry_count, timeout, ccb,
2930                                             &ident_buf);
2931                                         atahpa_print(ident_buf, hpasize, 1);
2932                                 }
2933                                 /* Hint CAM to reprobe the device. */
2934                                 reprobe(device);
2935                         }
2936                 }
2937                 break;
2938
2939         case ATA_HPA_ACTION_SET_PWD:
2940                 error = atahpa_password(device, retry_count, timeout,
2941                                         ccb, is48bit, &pwd);
2942                 if (error == 0 && quiet == 0)
2943                         printf("HPA password has been set\n");
2944                 break;
2945
2946         case ATA_HPA_ACTION_LOCK:
2947                 error = atahpa_lock(device, retry_count, timeout,
2948                                     ccb, is48bit);
2949                 if (error == 0 && quiet == 0)
2950                         printf("HPA has been locked\n");
2951                 break;
2952
2953         case ATA_HPA_ACTION_UNLOCK:
2954                 error = atahpa_unlock(device, retry_count, timeout,
2955                                       ccb, is48bit, &pwd);
2956                 if (error == 0 && quiet == 0)
2957                         printf("HPA has been unlocked\n");
2958                 break;
2959
2960         case ATA_HPA_ACTION_FREEZE_LOCK:
2961                 error = atahpa_freeze_lock(device, retry_count, timeout,
2962                                            ccb, is48bit);
2963                 if (error == 0 && quiet == 0)
2964                         printf("HPA has been frozen\n");
2965                 break;
2966
2967         default:
2968                 errx(1, "Option currently not supported");
2969         }
2970
2971         cam_freeccb(ccb);
2972         free(ident_buf);
2973
2974         return (error);
2975 }
2976
2977 enum {
2978         ATA_AMA_ACTION_PRINT,
2979         ATA_AMA_ACTION_SET_MAX,
2980         ATA_AMA_ACTION_FREEZE_LOCK
2981 };
2982
2983 static int
2984 ataama(struct cam_device *device, int retry_count, int timeout,
2985        int argc, char **argv, char *combinedopt)
2986 {
2987         union ccb *ccb;
2988         struct ata_params *ident_buf;
2989         struct ccb_getdev cgd;
2990         int error, quiet, c, action, actions;
2991         u_int64_t nativesize, maxsize;
2992
2993         actions = 0;
2994         quiet = 0;
2995         maxsize = 0;
2996
2997         /* default action is to print AMA information */
2998         action = ATA_AMA_ACTION_PRINT;
2999
3000         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3001                 switch(c){
3002                 case 's':
3003                         action = ATA_AMA_ACTION_SET_MAX;
3004                         maxsize = strtoumax(optarg, NULL, 0);
3005                         actions++;
3006                         break;
3007
3008                 case 'f':
3009                         action = ATA_AMA_ACTION_FREEZE_LOCK;
3010                         actions++;
3011                         break;
3012
3013                 case 'q':
3014                         quiet++;
3015                         break;
3016                 }
3017         }
3018
3019         if (actions > 1) {
3020                 warnx("too many AMA actions specified");
3021                 return (1);
3022         }
3023
3024         if (get_cgd(device, &cgd) != 0) {
3025                 warnx("couldn't get CGD");
3026                 return (1);
3027         }
3028
3029         ccb = cam_getccb(device);
3030         if (ccb == NULL) {
3031                 warnx("couldn't allocate CCB");
3032                 return (1);
3033         }
3034
3035         error = ata_do_identify(device, retry_count, timeout, ccb, &ident_buf);
3036         if (error != 0) {
3037                 cam_freeccb(ccb);
3038                 return (1);
3039         }
3040
3041         if (quiet == 0) {
3042                 printf("%s%d: ", device->device_name, device->dev_unit_num);
3043                 ata_print_ident(ident_buf);
3044                 camxferrate(device);
3045         }
3046
3047         if (action == ATA_AMA_ACTION_PRINT) {
3048                 nativesize = 0;
3049                 if (ident_buf->support2 & ATA_SUPPORT_AMAX_ADDR)
3050                         ata_get_native_max(device, retry_count, timeout, ccb,
3051                                            &nativesize);
3052                 ataama_print(ident_buf, nativesize, 1);
3053
3054                 cam_freeccb(ccb);
3055                 free(ident_buf);
3056                 return (error);
3057         }
3058
3059         if (!(ident_buf->support2 & ATA_SUPPORT_AMAX_ADDR)) {
3060                 warnx("Accessible Max Address is not supported by this device");
3061                 cam_freeccb(ccb);
3062                 free(ident_buf);
3063                 return (1);
3064         }
3065
3066         switch(action) {
3067         case ATA_AMA_ACTION_SET_MAX:
3068                 error = ata_get_native_max(device, retry_count, timeout, ccb,
3069                                            &nativesize);
3070                 if (error == 0) {
3071                         error = ataama_set(device, retry_count, timeout,
3072                                        ccb, maxsize);
3073                         if (error == 0) {
3074                                 if (quiet == 0) {
3075                                         /* redo identify to get new values */
3076                                         error = ata_do_identify(device,
3077                                             retry_count, timeout, ccb,
3078                                             &ident_buf);
3079                                         ataama_print(ident_buf, nativesize, 1);
3080                                 }
3081                                 /* Hint CAM to reprobe the device. */
3082                                 reprobe(device);
3083                         }
3084                 }
3085                 break;
3086
3087         case ATA_AMA_ACTION_FREEZE_LOCK:
3088                 error = ataama_freeze(device, retry_count, timeout,
3089                                            ccb);
3090                 if (error == 0 && quiet == 0)
3091                         printf("Accessible Max Address has been frozen\n");
3092                 break;
3093
3094         default:
3095                 errx(1, "Option currently not supported");
3096         }
3097
3098         cam_freeccb(ccb);
3099         free(ident_buf);
3100
3101         return (error);
3102 }
3103
3104 static int
3105 atasecurity(struct cam_device *device, int retry_count, int timeout,
3106             int argc, char **argv, char *combinedopt)
3107 {
3108         union ccb *ccb;
3109         struct ata_params *ident_buf;
3110         int error, confirm, quiet, c, action, actions, setpwd;
3111         int security_enabled, erase_timeout, pwdsize;
3112         struct ata_security_password pwd;
3113
3114         actions = 0;
3115         setpwd = 0;
3116         erase_timeout = 0;
3117         confirm = 0;
3118         quiet = 0;
3119
3120         memset(&pwd, 0, sizeof(pwd));
3121
3122         /* default action is to print security information */
3123         action = ATA_SECURITY_ACTION_PRINT;
3124
3125         /* user is master by default as its safer that way */
3126         pwd.ctrl |= ATA_SECURITY_PASSWORD_MASTER;
3127         pwdsize = sizeof(pwd.password);
3128
3129         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3130                 switch(c){
3131                 case 'f':
3132                         action = ATA_SECURITY_ACTION_FREEZE;
3133                         actions++;
3134                         break;
3135
3136                 case 'U':
3137                         if (strcasecmp(optarg, "user") == 0) {
3138                                 pwd.ctrl |= ATA_SECURITY_PASSWORD_USER;
3139                                 pwd.ctrl &= ~ATA_SECURITY_PASSWORD_MASTER;
3140                         } else if (strcasecmp(optarg, "master") == 0) {
3141                                 pwd.ctrl |= ATA_SECURITY_PASSWORD_MASTER;
3142                                 pwd.ctrl &= ~ATA_SECURITY_PASSWORD_USER;
3143                         } else {
3144                                 warnx("-U argument '%s' is invalid (must be "
3145                                       "'user' or 'master')", optarg);
3146                                 return (1);
3147                         }
3148                         break;
3149
3150                 case 'l':
3151                         if (strcasecmp(optarg, "high") == 0) {
3152                                 pwd.ctrl |= ATA_SECURITY_LEVEL_HIGH;
3153                                 pwd.ctrl &= ~ATA_SECURITY_LEVEL_MAXIMUM;
3154                         } else if (strcasecmp(optarg, "maximum") == 0) {
3155                                 pwd.ctrl |= ATA_SECURITY_LEVEL_MAXIMUM;
3156                                 pwd.ctrl &= ~ATA_SECURITY_LEVEL_HIGH;
3157                         } else {
3158                                 warnx("-l argument '%s' is unknown (must be "
3159                                       "'high' or 'maximum')", optarg);
3160                                 return (1);
3161                         }
3162                         break;
3163
3164                 case 'k':
3165                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
3166                                 return (1);
3167                         action = ATA_SECURITY_ACTION_UNLOCK;
3168                         actions++;
3169                         break;
3170
3171                 case 'd':
3172                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
3173                                 return (1);
3174                         action = ATA_SECURITY_ACTION_DISABLE;
3175                         actions++;
3176                         break;
3177
3178                 case 'e':
3179                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
3180                                 return (1);
3181                         action = ATA_SECURITY_ACTION_ERASE;
3182                         actions++;
3183                         break;
3184
3185                 case 'h':
3186                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
3187                                 return (1);
3188                         pwd.ctrl |= ATA_SECURITY_ERASE_ENHANCED;
3189                         action = ATA_SECURITY_ACTION_ERASE_ENHANCED;
3190                         actions++;
3191                         break;
3192
3193                 case 's':
3194                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
3195                                 return (1);
3196                         setpwd = 1;
3197                         if (action == ATA_SECURITY_ACTION_PRINT)
3198                                 action = ATA_SECURITY_ACTION_SET_PASSWORD;
3199                         /*
3200                          * Don't increment action as this can be combined
3201                          * with other actions.
3202                          */
3203                         break;
3204
3205                 case 'y':
3206                         confirm++;
3207                         break;
3208
3209                 case 'q':
3210                         quiet++;
3211                         break;
3212
3213                 case 'T':
3214                         erase_timeout = atoi(optarg) * 1000;
3215                         break;
3216                 }
3217         }
3218
3219         if (actions > 1) {
3220                 warnx("too many security actions specified");
3221                 return (1);
3222         }
3223
3224         if ((ccb = cam_getccb(device)) == NULL) {
3225                 warnx("couldn't allocate CCB");
3226                 return (1);
3227         }
3228
3229         error = ata_do_identify(device, retry_count, timeout, ccb, &ident_buf);
3230         if (error != 0) {
3231                 cam_freeccb(ccb);
3232                 return (1);
3233         }
3234
3235         if (quiet == 0) {
3236                 printf("%s%d: ", device->device_name, device->dev_unit_num);
3237                 ata_print_ident(ident_buf);
3238                 camxferrate(device);
3239         }
3240
3241         if (action == ATA_SECURITY_ACTION_PRINT) {
3242                 atasecurity_print(ident_buf);
3243                 free(ident_buf);
3244                 cam_freeccb(ccb);
3245                 return (0);
3246         }
3247
3248         if ((ident_buf->support.command1 & ATA_SUPPORT_SECURITY) == 0) {
3249                 warnx("Security not supported");
3250                 free(ident_buf);
3251                 cam_freeccb(ccb);
3252                 return (1);
3253         }
3254
3255         /* default timeout 15 seconds the same as linux hdparm */
3256         timeout = timeout ? timeout : 15 * 1000;
3257
3258         security_enabled = ident_buf->security_status & ATA_SECURITY_ENABLED;
3259
3260         /* first set the password if requested */
3261         if (setpwd == 1) {
3262                 /* confirm we can erase before setting the password if erasing */
3263                 if (confirm == 0 &&
3264                     (action == ATA_SECURITY_ACTION_ERASE_ENHANCED ||
3265                     action == ATA_SECURITY_ACTION_ERASE) &&
3266                     atasecurity_erase_confirm(device, ident_buf) == 0) {
3267                         cam_freeccb(ccb);
3268                         free(ident_buf);
3269                         return (error);
3270                 }
3271
3272                 if (pwd.ctrl & ATA_SECURITY_PASSWORD_MASTER) {
3273                         pwd.revision = ident_buf->master_passwd_revision;
3274                         if (pwd.revision != 0 && pwd.revision != 0xfff &&
3275                             --pwd.revision == 0) {
3276                                 pwd.revision = 0xfffe;
3277                         }
3278                 }
3279                 error = atasecurity_set_password(device, ccb, retry_count,
3280                                                  timeout, &pwd, quiet);
3281                 if (error != 0) {
3282                         cam_freeccb(ccb);
3283                         free(ident_buf);
3284                         return (error);
3285                 }
3286                 security_enabled = 1;
3287         }
3288
3289         switch(action) {
3290         case ATA_SECURITY_ACTION_FREEZE:
3291                 error = atasecurity_freeze(device, ccb, retry_count,
3292                                            timeout, quiet);
3293                 break;
3294
3295         case ATA_SECURITY_ACTION_UNLOCK:
3296                 if (security_enabled) {
3297                         if (ident_buf->security_status & ATA_SECURITY_LOCKED) {
3298                                 error = atasecurity_unlock(device, ccb,
3299                                         retry_count, timeout, &pwd, quiet);
3300                         } else {
3301                                 warnx("Can't unlock, drive is not locked");
3302                                 error = 1;
3303                         }
3304                 } else {
3305                         warnx("Can't unlock, security is disabled");
3306                         error = 1;
3307                 }
3308                 break;
3309
3310         case ATA_SECURITY_ACTION_DISABLE:
3311                 if (security_enabled) {
3312                         /* First unlock the drive if its locked */
3313                         if (ident_buf->security_status & ATA_SECURITY_LOCKED) {
3314                                 error = atasecurity_unlock(device, ccb,
3315                                                            retry_count,
3316                                                            timeout,
3317                                                            &pwd,
3318                                                            quiet);
3319                         }
3320
3321                         if (error == 0) {
3322                                 error = atasecurity_disable(device,
3323                                                             ccb,
3324                                                             retry_count,
3325                                                             timeout,
3326                                                             &pwd,
3327                                                             quiet);
3328                         }
3329                 } else {
3330                         warnx("Can't disable security (already disabled)");
3331                         error = 1;
3332                 }
3333                 break;
3334
3335         case ATA_SECURITY_ACTION_ERASE:
3336                 if (security_enabled) {
3337                         if (erase_timeout == 0) {
3338                                 erase_timeout = atasecurity_erase_timeout_msecs(
3339                                     ident_buf->erase_time);
3340                         }
3341
3342                         error = atasecurity_erase(device, ccb, retry_count,
3343                             timeout, erase_timeout, &pwd, quiet);
3344                 } else {
3345                         warnx("Can't secure erase (security is disabled)");
3346                         error = 1;
3347                 }
3348                 break;
3349
3350         case ATA_SECURITY_ACTION_ERASE_ENHANCED:
3351                 if (security_enabled) {
3352                         if (ident_buf->security_status & ATA_SECURITY_ENH_SUPP) {
3353                                 if (erase_timeout == 0) {
3354                                         erase_timeout =
3355                                             atasecurity_erase_timeout_msecs(
3356                                                 ident_buf->enhanced_erase_time);
3357                                 }
3358
3359                                 error = atasecurity_erase(device, ccb,
3360                                                           retry_count, timeout,
3361                                                           erase_timeout, &pwd,
3362                                                           quiet);
3363                         } else {
3364                                 warnx("Enhanced erase is not supported");
3365                                 error = 1;
3366                         }
3367                 } else {
3368                         warnx("Can't secure erase (enhanced), "
3369                               "(security is disabled)");
3370                         error = 1;
3371                 }
3372                 break;
3373         }
3374
3375         cam_freeccb(ccb);
3376         free(ident_buf);
3377
3378         return (error);
3379 }
3380
3381 /*
3382  * Convert periph name into a bus, target and lun.
3383  *
3384  * Returns the number of parsed components, or 0.
3385  */
3386 static int
3387 parse_btl_name(char *tstr, path_id_t *bus, target_id_t *target, lun_id_t *lun,
3388     cam_argmask *arglst)
3389 {
3390         int fd;
3391         union ccb ccb;
3392
3393         bzero(&ccb, sizeof(ccb));
3394         ccb.ccb_h.func_code = XPT_GDEVLIST;
3395         if (cam_get_device(tstr, ccb.cgdl.periph_name,
3396             sizeof(ccb.cgdl.periph_name), &ccb.cgdl.unit_number) == -1) {
3397                 warnx("%s", cam_errbuf);
3398                 return (0);
3399         }
3400
3401         /*
3402          * Attempt to get the passthrough device.  This ioctl will
3403          * fail if the device name is null, if the device doesn't
3404          * exist, or if the passthrough driver isn't in the kernel.
3405          */
3406         if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
3407                 warn("Unable to open %s", XPT_DEVICE);
3408                 return (0);
3409         }
3410         if (ioctl(fd, CAMGETPASSTHRU, &ccb) == -1) {
3411                 warn("Unable to find bus:target:lun for device %s%d",
3412                     ccb.cgdl.periph_name, ccb.cgdl.unit_number);
3413                 close(fd);
3414                 return (0);
3415         }
3416         close(fd);
3417         if ((ccb.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3418                 const struct cam_status_entry *entry;
3419
3420                 entry = cam_fetch_status_entry(ccb.ccb_h.status);
3421                 warnx("Unable to find bus:target_lun for device %s%d, "
3422                     "CAM status: %s (%#x)",
3423                     ccb.cgdl.periph_name, ccb.cgdl.unit_number,
3424                     entry ? entry->status_text : "Unknown",
3425                     ccb.ccb_h.status);
3426                 return (0);
3427         }
3428
3429         /*
3430          * The kernel fills in the bus/target/lun.  We don't
3431          * need the passthrough device name and unit number since
3432          * we aren't going to open it.
3433          */
3434         *bus = ccb.ccb_h.path_id;
3435         *target = ccb.ccb_h.target_id;
3436         *lun = ccb.ccb_h.target_lun;
3437         *arglst |= CAM_ARG_BUS | CAM_ARG_TARGET | CAM_ARG_LUN;
3438         return (3);
3439 }
3440
3441 /*
3442  * Parse out a bus, or a bus, target and lun in the following
3443  * format:
3444  * bus
3445  * bus:target
3446  * bus:target:lun
3447  *
3448  * Returns the number of parsed components, or 0.
3449  */
3450 static int
3451 parse_btl(char *tstr, path_id_t *bus, target_id_t *target, lun_id_t *lun,
3452     cam_argmask *arglst)
3453 {
3454         char *tmpstr, *end;
3455         int convs = 0;
3456
3457         *bus = CAM_BUS_WILDCARD;
3458         *target = CAM_TARGET_WILDCARD;
3459         *lun = CAM_LUN_WILDCARD;
3460
3461         while (isspace(*tstr) && (*tstr != '\0'))
3462                 tstr++;
3463
3464         if (strncasecmp(tstr, "all", strlen("all")) == 0) {
3465                 arglist |= CAM_ARG_BUS;
3466                 return (1);
3467         }
3468
3469         if (!isdigit(*tstr))
3470                 return (parse_btl_name(tstr, bus, target, lun, arglst));
3471
3472         tmpstr = strsep(&tstr, ":");
3473         if ((tmpstr != NULL) && (*tmpstr != '\0')) {
3474                 *bus = strtol(tmpstr, &end, 0);
3475                 if (*end != '\0')
3476                         return (0);
3477                 *arglst |= CAM_ARG_BUS;
3478                 convs++;
3479                 tmpstr = strsep(&tstr, ":");
3480                 if ((tmpstr != NULL) && (*tmpstr != '\0')) {
3481                         *target = strtol(tmpstr, &end, 0);
3482                         if (*end != '\0')
3483                                 return (0);
3484                         *arglst |= CAM_ARG_TARGET;
3485                         convs++;
3486                         tmpstr = strsep(&tstr, ":");
3487                         if ((tmpstr != NULL) && (*tmpstr != '\0')) {
3488                                 *lun = strtoll(tmpstr, &end, 0);
3489                                 if (*end != '\0')
3490                                         return (0);
3491                                 *arglst |= CAM_ARG_LUN;
3492                                 convs++;
3493                         }
3494                 }
3495         }
3496
3497         return convs;
3498 }
3499
3500 static int
3501 dorescan_or_reset(int argc, char **argv, int rescan)
3502 {
3503         static const char must[] =
3504             "you must specify \"all\", a bus, a bus:target:lun or periph to %s";
3505         int rv, error = 0;
3506         path_id_t bus = CAM_BUS_WILDCARD;
3507         target_id_t target = CAM_TARGET_WILDCARD;
3508         lun_id_t lun = CAM_LUN_WILDCARD;
3509         char *tstr;
3510
3511         if (argc < 3) {
3512                 warnx(must, rescan? "rescan" : "reset");
3513                 return (1);
3514         }
3515
3516         tstr = argv[optind];
3517         while (isspace(*tstr) && (*tstr != '\0'))
3518                 tstr++;
3519         if (strncasecmp(tstr, "all", strlen("all")) == 0)
3520                 arglist |= CAM_ARG_BUS;
3521         else {
3522                 rv = parse_btl(argv[optind], &bus, &target, &lun, &arglist);
3523                 if (rv != 1 && rv != 3) {
3524                         warnx(must, rescan ? "rescan" : "reset");
3525                         return (1);
3526                 }
3527         }
3528
3529         if (arglist & CAM_ARG_LUN)
3530                 error = scanlun_or_reset_dev(bus, target, lun, rescan);
3531         else
3532                 error = rescan_or_reset_bus(bus, rescan);
3533
3534         return (error);
3535 }
3536
3537 static int
3538 rescan_or_reset_bus(path_id_t bus, int rescan)
3539 {
3540         union ccb *ccb = NULL, *matchccb = NULL;
3541         int fd = -1, retval;
3542         int bufsize;
3543
3544         retval = 0;
3545
3546         if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
3547                 warnx("error opening transport layer device %s", XPT_DEVICE);
3548                 warn("%s", XPT_DEVICE);
3549                 return (1);
3550         }
3551
3552         ccb = malloc(sizeof(*ccb));
3553         if (ccb == NULL) {
3554                 warn("failed to allocate CCB");
3555                 retval = 1;
3556                 goto bailout;
3557         }
3558         bzero(ccb, sizeof(*ccb));
3559
3560         if (bus != CAM_BUS_WILDCARD) {
3561                 ccb->ccb_h.func_code = rescan ? XPT_SCAN_BUS : XPT_RESET_BUS;
3562                 ccb->ccb_h.path_id = bus;
3563                 ccb->ccb_h.target_id = CAM_TARGET_WILDCARD;
3564                 ccb->ccb_h.target_lun = CAM_LUN_WILDCARD;
3565                 ccb->crcn.flags = CAM_FLAG_NONE;
3566
3567                 /* run this at a low priority */
3568                 ccb->ccb_h.pinfo.priority = 5;
3569
3570                 if (ioctl(fd, CAMIOCOMMAND, ccb) == -1) {
3571                         warn("CAMIOCOMMAND ioctl failed");
3572                         retval = 1;
3573                         goto bailout;
3574                 }
3575
3576                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
3577                         fprintf(stdout, "%s of bus %d was successful\n",
3578                             rescan ? "Re-scan" : "Reset", bus);
3579                 } else {
3580                         fprintf(stdout, "%s of bus %d returned error %#x\n",
3581                                 rescan ? "Re-scan" : "Reset", bus,
3582                                 ccb->ccb_h.status & CAM_STATUS_MASK);
3583                         retval = 1;
3584                 }
3585
3586                 goto bailout;
3587         }
3588
3589
3590         /*
3591          * The right way to handle this is to modify the xpt so that it can
3592          * handle a wildcarded bus in a rescan or reset CCB.  At the moment
3593          * that isn't implemented, so instead we enumerate the buses and
3594          * send the rescan or reset to those buses in the case where the
3595          * given bus is -1 (wildcard).  We don't send a rescan or reset
3596          * to the xpt bus; sending a rescan to the xpt bus is effectively a
3597          * no-op, sending a rescan to the xpt bus would result in a status of
3598          * CAM_REQ_INVALID.
3599          */
3600         matchccb = malloc(sizeof(*matchccb));
3601         if (matchccb == NULL) {
3602                 warn("failed to allocate CCB");
3603                 retval = 1;
3604                 goto bailout;
3605         }
3606         bzero(matchccb, sizeof(*matchccb));
3607         matchccb->ccb_h.func_code = XPT_DEV_MATCH;
3608         matchccb->ccb_h.path_id = CAM_BUS_WILDCARD;
3609         bufsize = sizeof(struct dev_match_result) * 20;
3610         matchccb->cdm.match_buf_len = bufsize;
3611         matchccb->cdm.matches=(struct dev_match_result *)malloc(bufsize);
3612         if (matchccb->cdm.matches == NULL) {
3613                 warnx("can't malloc memory for matches");
3614                 retval = 1;
3615                 goto bailout;
3616         }
3617         matchccb->cdm.num_matches = 0;
3618
3619         matchccb->cdm.num_patterns = 1;
3620         matchccb->cdm.pattern_buf_len = sizeof(struct dev_match_pattern);
3621
3622         matchccb->cdm.patterns = (struct dev_match_pattern *)malloc(
3623                 matchccb->cdm.pattern_buf_len);
3624         if (matchccb->cdm.patterns == NULL) {
3625                 warnx("can't malloc memory for patterns");
3626                 retval = 1;
3627                 goto bailout;
3628         }
3629         matchccb->cdm.patterns[0].type = DEV_MATCH_BUS;
3630         matchccb->cdm.patterns[0].pattern.bus_pattern.flags = BUS_MATCH_ANY;
3631
3632         do {
3633                 unsigned int i;
3634
3635                 if (ioctl(fd, CAMIOCOMMAND, matchccb) == -1) {
3636                         warn("CAMIOCOMMAND ioctl failed");
3637                         retval = 1;
3638                         goto bailout;
3639                 }
3640
3641                 if ((matchccb->ccb_h.status != CAM_REQ_CMP)
3642                  || ((matchccb->cdm.status != CAM_DEV_MATCH_LAST)
3643                    && (matchccb->cdm.status != CAM_DEV_MATCH_MORE))) {
3644                         warnx("got CAM error %#x, CDM error %d\n",
3645                               matchccb->ccb_h.status, matchccb->cdm.status);
3646                         retval = 1;
3647                         goto bailout;
3648                 }
3649
3650                 for (i = 0; i < matchccb->cdm.num_matches; i++) {
3651                         struct bus_match_result *bus_result;
3652
3653                         /* This shouldn't happen. */
3654                         if (matchccb->cdm.matches[i].type != DEV_MATCH_BUS)
3655                                 continue;
3656
3657                         bus_result =&matchccb->cdm.matches[i].result.bus_result;
3658
3659                         /*
3660                          * We don't want to rescan or reset the xpt bus.
3661                          * See above.
3662                          */
3663                         if (bus_result->path_id == CAM_XPT_PATH_ID)
3664                                 continue;
3665
3666                         ccb->ccb_h.func_code = rescan ? XPT_SCAN_BUS :
3667                                                        XPT_RESET_BUS;
3668                         ccb->ccb_h.path_id = bus_result->path_id;
3669                         ccb->ccb_h.target_id = CAM_TARGET_WILDCARD;
3670                         ccb->ccb_h.target_lun = CAM_LUN_WILDCARD;
3671                         ccb->crcn.flags = CAM_FLAG_NONE;
3672
3673                         /* run this at a low priority */
3674                         ccb->ccb_h.pinfo.priority = 5;
3675
3676                         if (ioctl(fd, CAMIOCOMMAND, ccb) == -1) {
3677                                 warn("CAMIOCOMMAND ioctl failed");
3678                                 retval = 1;
3679                                 goto bailout;
3680                         }
3681
3682                         if ((ccb->ccb_h.status & CAM_STATUS_MASK)==CAM_REQ_CMP){
3683                                 fprintf(stdout, "%s of bus %d was successful\n",
3684                                         rescan? "Re-scan" : "Reset",
3685                                         bus_result->path_id);
3686                         } else {
3687                                 /*
3688                                  * Don't bail out just yet, maybe the other
3689                                  * rescan or reset commands will complete
3690                                  * successfully.
3691                                  */
3692                                 fprintf(stderr, "%s of bus %d returned error "
3693                                         "%#x\n", rescan? "Re-scan" : "Reset",
3694                                         bus_result->path_id,
3695                                         ccb->ccb_h.status & CAM_STATUS_MASK);
3696                                 retval = 1;
3697                         }
3698                 }
3699         } while ((matchccb->ccb_h.status == CAM_REQ_CMP)
3700                  && (matchccb->cdm.status == CAM_DEV_MATCH_MORE));
3701
3702 bailout:
3703
3704         if (fd != -1)
3705                 close(fd);
3706
3707         if (matchccb != NULL) {
3708                 free(matchccb->cdm.patterns);
3709                 free(matchccb->cdm.matches);
3710                 free(matchccb);
3711         }
3712         free(ccb);
3713
3714         return (retval);
3715 }
3716
3717 static int
3718 scanlun_or_reset_dev(path_id_t bus, target_id_t target, lun_id_t lun, int scan)
3719 {
3720         union ccb ccb;
3721         struct cam_device *device;
3722         int fd;
3723
3724         device = NULL;
3725
3726         if (bus == CAM_BUS_WILDCARD) {
3727                 warnx("invalid bus number %d", bus);
3728                 return (1);
3729         }
3730
3731         if (target == CAM_TARGET_WILDCARD) {
3732                 warnx("invalid target number %d", target);
3733                 return (1);
3734         }
3735
3736         if (lun == CAM_LUN_WILDCARD) {
3737                 warnx("invalid lun number %jx", (uintmax_t)lun);
3738                 return (1);
3739         }
3740
3741         fd = -1;
3742
3743         bzero(&ccb, sizeof(union ccb));
3744
3745         if (scan) {
3746                 if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
3747                         warnx("error opening transport layer device %s\n",
3748                             XPT_DEVICE);
3749                         warn("%s", XPT_DEVICE);
3750                         return (1);
3751                 }
3752         } else {
3753                 device = cam_open_btl(bus, target, lun, O_RDWR, NULL);
3754                 if (device == NULL) {
3755                         warnx("%s", cam_errbuf);
3756                         return (1);
3757                 }
3758         }
3759
3760         ccb.ccb_h.func_code = (scan)? XPT_SCAN_LUN : XPT_RESET_DEV;
3761         ccb.ccb_h.path_id = bus;
3762         ccb.ccb_h.target_id = target;
3763         ccb.ccb_h.target_lun = lun;
3764         ccb.ccb_h.timeout = 5000;
3765         ccb.crcn.flags = CAM_FLAG_NONE;
3766
3767         /* run this at a low priority */
3768         ccb.ccb_h.pinfo.priority = 5;
3769
3770         if (scan) {
3771                 if (ioctl(fd, CAMIOCOMMAND, &ccb) < 0) {
3772                         warn("CAMIOCOMMAND ioctl failed");
3773                         close(fd);
3774                         return (1);
3775                 }
3776         } else {
3777                 if (cam_send_ccb(device, &ccb) < 0) {
3778                         warn("error sending XPT_RESET_DEV CCB");
3779                         cam_close_device(device);
3780                         return (1);
3781                 }
3782         }
3783
3784         if (scan)
3785                 close(fd);
3786         else
3787                 cam_close_device(device);
3788
3789         /*
3790          * An error code of CAM_BDR_SENT is normal for a BDR request.
3791          */
3792         if (((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
3793          || ((!scan)
3794           && ((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_BDR_SENT))) {
3795                 fprintf(stdout, "%s of %d:%d:%jx was successful\n",
3796                     scan? "Re-scan" : "Reset", bus, target, (uintmax_t)lun);
3797                 return (0);
3798         } else {
3799                 fprintf(stdout, "%s of %d:%d:%jx returned error %#x\n",
3800                     scan? "Re-scan" : "Reset", bus, target, (uintmax_t)lun,
3801                     ccb.ccb_h.status & CAM_STATUS_MASK);
3802                 return (1);
3803         }
3804 }
3805
3806
3807 static struct scsi_nv defect_list_type_map[] = {
3808         { "block", SRDD10_BLOCK_FORMAT },
3809         { "extbfi", SRDD10_EXT_BFI_FORMAT },
3810         { "extphys", SRDD10_EXT_PHYS_FORMAT },
3811         { "longblock", SRDD10_LONG_BLOCK_FORMAT },
3812         { "bfi", SRDD10_BYTES_FROM_INDEX_FORMAT },
3813         { "phys", SRDD10_PHYSICAL_SECTOR_FORMAT }
3814 };
3815
3816 static int
3817 readdefects(struct cam_device *device, int argc, char **argv,
3818             char *combinedopt, int task_attr, int retry_count, int timeout)
3819 {
3820         union ccb *ccb = NULL;
3821         struct scsi_read_defect_data_hdr_10 *hdr10 = NULL;
3822         struct scsi_read_defect_data_hdr_12 *hdr12 = NULL;
3823         size_t hdr_size = 0, entry_size = 0;
3824         int use_12byte = 0;
3825         int hex_format = 0;
3826         u_int8_t *defect_list = NULL;
3827         u_int8_t list_format = 0;
3828         int list_type_set = 0;
3829         u_int32_t dlist_length = 0;
3830         u_int32_t returned_length = 0, valid_len = 0;
3831         u_int32_t num_returned = 0, num_valid = 0;
3832         u_int32_t max_possible_size = 0, hdr_max = 0;
3833         u_int32_t starting_offset = 0;
3834         u_int8_t returned_format, returned_type;
3835         unsigned int i;
3836         int summary = 0, quiet = 0;
3837         int c, error = 0;
3838         int lists_specified = 0;
3839         int get_length = 1, first_pass = 1;
3840         int mads = 0;
3841
3842         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3843                 switch(c){
3844                 case 'f':
3845                 {
3846                         scsi_nv_status status;
3847                         int entry_num = 0;
3848
3849                         status = scsi_get_nv(defect_list_type_map,
3850                             sizeof(defect_list_type_map) /
3851                             sizeof(defect_list_type_map[0]), optarg,
3852                             &entry_num, SCSI_NV_FLAG_IG_CASE);
3853
3854                         if (status == SCSI_NV_FOUND) {
3855                                 list_format = defect_list_type_map[
3856                                     entry_num].value;
3857                                 list_type_set = 1;
3858                         } else {
3859                                 warnx("%s: %s %s option %s", __func__,
3860                                     (status == SCSI_NV_AMBIGUOUS) ?
3861                                     "ambiguous" : "invalid", "defect list type",
3862                                     optarg);
3863                                 error = 1;
3864                                 goto defect_bailout;
3865                         }
3866                         break;
3867                 }
3868                 case 'G':
3869                         arglist |= CAM_ARG_GLIST;
3870                         break;
3871                 case 'P':
3872                         arglist |= CAM_ARG_PLIST;
3873                         break;
3874                 case 'q':
3875                         quiet = 1;
3876                         break;
3877                 case 's':
3878                         summary = 1;
3879                         break;
3880                 case 'S': {
3881                         char *endptr;
3882
3883                         starting_offset = strtoul(optarg, &endptr, 0);
3884                         if (*endptr != '\0') {
3885                                 error = 1;
3886                                 warnx("invalid starting offset %s", optarg);
3887                                 goto defect_bailout;
3888                         }
3889                         break;
3890                 }
3891                 case 'X':
3892                         hex_format = 1;
3893                         break;
3894                 default:
3895                         break;
3896                 }
3897         }
3898
3899         if (list_type_set == 0) {
3900                 error = 1;
3901                 warnx("no defect list format specified");
3902                 goto defect_bailout;
3903         }
3904
3905         if (arglist & CAM_ARG_PLIST) {
3906                 list_format |= SRDD10_PLIST;
3907                 lists_specified++;
3908         }
3909
3910         if (arglist & CAM_ARG_GLIST) {
3911                 list_format |= SRDD10_GLIST;
3912                 lists_specified++;
3913         }
3914
3915         /*
3916          * This implies a summary, and was the previous behavior.
3917          */
3918         if (lists_specified == 0)
3919                 summary = 1;
3920
3921         ccb = cam_getccb(device);
3922
3923 retry_12byte:
3924
3925         /*
3926          * We start off asking for just the header to determine how much
3927          * defect data is available.  Some Hitachi drives return an error
3928          * if you ask for more data than the drive has.  Once we know the
3929          * length, we retry the command with the returned length.
3930          */
3931         if (use_12byte == 0)
3932                 dlist_length = sizeof(*hdr10);
3933         else
3934                 dlist_length = sizeof(*hdr12);
3935
3936 retry:
3937         if (defect_list != NULL) {
3938                 free(defect_list);
3939                 defect_list = NULL;
3940         }
3941         defect_list = malloc(dlist_length);
3942         if (defect_list == NULL) {
3943                 warnx("can't malloc memory for defect list");
3944                 error = 1;
3945                 goto defect_bailout;
3946         }
3947
3948 next_batch:
3949         bzero(defect_list, dlist_length);
3950
3951         /*
3952          * cam_getccb() zeros the CCB header only.  So we need to zero the
3953          * payload portion of the ccb.
3954          */
3955         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
3956
3957         scsi_read_defects(&ccb->csio,
3958                           /*retries*/ retry_count,
3959                           /*cbfcnp*/ NULL,
3960                           /*tag_action*/ task_attr,
3961                           /*list_format*/ list_format,
3962                           /*addr_desc_index*/ starting_offset,
3963                           /*data_ptr*/ defect_list,
3964                           /*dxfer_len*/ dlist_length,
3965                           /*minimum_cmd_size*/ use_12byte ? 12 : 0,
3966                           /*sense_len*/ SSD_FULL_SIZE,
3967                           /*timeout*/ timeout ? timeout : 5000);
3968
3969         /* Disable freezing the device queue */
3970         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
3971
3972         if (cam_send_ccb(device, ccb) < 0) {
3973                 warn("error sending READ DEFECT DATA command");
3974                 error = 1;
3975                 goto defect_bailout;
3976         }
3977
3978         valid_len = ccb->csio.dxfer_len - ccb->csio.resid;
3979
3980         if (use_12byte == 0) {
3981                 hdr10 = (struct scsi_read_defect_data_hdr_10 *)defect_list;
3982                 hdr_size = sizeof(*hdr10);
3983                 hdr_max = SRDDH10_MAX_LENGTH;
3984
3985                 if (valid_len >= hdr_size) {
3986                         returned_length = scsi_2btoul(hdr10->length);
3987                         returned_format = hdr10->format;
3988                 } else {
3989                         returned_length = 0;
3990                         returned_format = 0;
3991                 }
3992         } else {
3993                 hdr12 = (struct scsi_read_defect_data_hdr_12 *)defect_list;
3994                 hdr_size = sizeof(*hdr12);
3995                 hdr_max = SRDDH12_MAX_LENGTH;
3996
3997                 if (valid_len >= hdr_size) {
3998                         returned_length = scsi_4btoul(hdr12->length);
3999                         returned_format = hdr12->format;
4000                 } else {
4001                         returned_length = 0;
4002                         returned_format = 0;
4003                 }
4004         }
4005
4006         returned_type = returned_format & SRDDH10_DLIST_FORMAT_MASK;
4007         switch (returned_type) {
4008         case SRDD10_BLOCK_FORMAT:
4009                 entry_size = sizeof(struct scsi_defect_desc_block);
4010                 break;
4011         case SRDD10_LONG_BLOCK_FORMAT:
4012                 entry_size = sizeof(struct scsi_defect_desc_long_block);
4013                 break;
4014         case SRDD10_EXT_PHYS_FORMAT:
4015         case SRDD10_PHYSICAL_SECTOR_FORMAT:
4016                 entry_size = sizeof(struct scsi_defect_desc_phys_sector);
4017                 break;
4018         case SRDD10_EXT_BFI_FORMAT:
4019         case SRDD10_BYTES_FROM_INDEX_FORMAT:
4020                 entry_size = sizeof(struct scsi_defect_desc_bytes_from_index);
4021                 break;
4022         default:
4023                 warnx("Unknown defect format 0x%x\n", returned_type);
4024                 error = 1;
4025                 goto defect_bailout;
4026                 break;
4027         }
4028
4029         max_possible_size = (hdr_max / entry_size) * entry_size;
4030         num_returned = returned_length / entry_size;
4031         num_valid = min(returned_length, valid_len - hdr_size);
4032         num_valid /= entry_size;
4033
4034         if (get_length != 0) {
4035                 get_length = 0;
4036
4037                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) ==
4038                      CAM_SCSI_STATUS_ERROR) {
4039                         struct scsi_sense_data *sense;
4040                         int error_code, sense_key, asc, ascq;
4041
4042                         sense = &ccb->csio.sense_data;
4043                         scsi_extract_sense_len(sense, ccb->csio.sense_len -
4044                             ccb->csio.sense_resid, &error_code, &sense_key,
4045                             &asc, &ascq, /*show_errors*/ 1);
4046
4047                         /*
4048                          * If the drive is reporting that it just doesn't
4049                          * support the defect list format, go ahead and use
4050                          * the length it reported.  Otherwise, the length
4051                          * may not be valid, so use the maximum.
4052                          */
4053                         if ((sense_key == SSD_KEY_RECOVERED_ERROR)
4054                          && (asc == 0x1c) && (ascq == 0x00)
4055                          && (returned_length > 0)) {
4056                                 if ((use_12byte == 0)
4057                                  && (returned_length >= max_possible_size)) {
4058                                         get_length = 1;
4059                                         use_12byte = 1;
4060                                         goto retry_12byte;
4061                                 }
4062                                 dlist_length = returned_length + hdr_size;
4063                         } else if ((sense_key == SSD_KEY_RECOVERED_ERROR)
4064                                 && (asc == 0x1f) && (ascq == 0x00)
4065                                 && (returned_length > 0)) {
4066                                 /* Partial defect list transfer */
4067                                 /*
4068                                  * Hitachi drives return this error
4069                                  * along with a partial defect list if they
4070                                  * have more defects than the 10 byte
4071                                  * command can support.  Retry with the 12
4072                                  * byte command.
4073                                  */
4074                                 if (use_12byte == 0) {
4075                                         get_length = 1;
4076                                         use_12byte = 1;
4077                                         goto retry_12byte;
4078                                 }
4079                                 dlist_length = returned_length + hdr_size;
4080                         } else if ((sense_key == SSD_KEY_ILLEGAL_REQUEST)
4081                                 && (asc == 0x24) && (ascq == 0x00)) {
4082                                 /* Invalid field in CDB */
4083                                 /*
4084                                  * SBC-3 says that if the drive has more
4085                                  * defects than can be reported with the
4086                                  * 10 byte command, it should return this
4087                                  * error and no data.  Retry with the 12
4088                                  * byte command.
4089                                  */
4090                                 if (use_12byte == 0) {
4091                                         get_length = 1;
4092                                         use_12byte = 1;
4093                                         goto retry_12byte;
4094                                 }
4095                                 dlist_length = returned_length + hdr_size;
4096                         } else {
4097                                 /*
4098                                  * If we got a SCSI error and no valid length,
4099                                  * just use the 10 byte maximum.  The 12
4100                                  * byte maximum is too large.
4101                                  */
4102                                 if (returned_length == 0)
4103                                         dlist_length = SRDD10_MAX_LENGTH;
4104                                 else {
4105                                         if ((use_12byte == 0)
4106                                          && (returned_length >=
4107                                              max_possible_size)) {
4108                                                 get_length = 1;
4109                                                 use_12byte = 1;
4110                                                 goto retry_12byte;
4111                                         }
4112                                         dlist_length = returned_length +
4113                                             hdr_size;
4114                                 }
4115                         }
4116                 } else if ((ccb->ccb_h.status & CAM_STATUS_MASK) !=
4117                             CAM_REQ_CMP){
4118                         error = 1;
4119                         warnx("Error reading defect header");
4120                         if (arglist & CAM_ARG_VERBOSE)
4121                                 cam_error_print(device, ccb, CAM_ESF_ALL,
4122                                                 CAM_EPF_ALL, stderr);
4123                         goto defect_bailout;
4124                 } else {
4125                         if ((use_12byte == 0)
4126                          && (returned_length >= max_possible_size)) {
4127                                 get_length = 1;
4128                                 use_12byte = 1;
4129                                 goto retry_12byte;
4130                         }
4131                         dlist_length = returned_length + hdr_size;
4132                 }
4133                 if (summary != 0) {
4134                         fprintf(stdout, "%u", num_returned);
4135                         if (quiet == 0) {
4136                                 fprintf(stdout, " defect%s",
4137                                         (num_returned != 1) ? "s" : "");
4138                         }
4139                         fprintf(stdout, "\n");
4140
4141                         goto defect_bailout;
4142                 }
4143
4144                 /*
4145                  * We always limit the list length to the 10-byte maximum
4146                  * length (0xffff).  The reason is that some controllers
4147                  * can't handle larger I/Os, and we can transfer the entire
4148                  * 10 byte list in one shot.  For drives that support the 12
4149                  * byte read defects command, we'll step through the list
4150                  * by specifying a starting offset.  For drives that don't
4151                  * support the 12 byte command's starting offset, we'll
4152                  * just display the first 64K.
4153                  */
4154                 dlist_length = min(dlist_length, SRDD10_MAX_LENGTH);
4155
4156                 goto retry;
4157         }
4158
4159
4160         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_SCSI_STATUS_ERROR)
4161          && (ccb->csio.scsi_status == SCSI_STATUS_CHECK_COND)
4162          && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
4163                 struct scsi_sense_data *sense;
4164                 int error_code, sense_key, asc, ascq;
4165
4166                 sense = &ccb->csio.sense_data;
4167                 scsi_extract_sense_len(sense, ccb->csio.sense_len -
4168                     ccb->csio.sense_resid, &error_code, &sense_key, &asc,
4169                     &ascq, /*show_errors*/ 1);
4170
4171                 /*
4172                  * According to the SCSI spec, if the disk doesn't support
4173                  * the requested format, it will generally return a sense
4174                  * key of RECOVERED ERROR, and an additional sense code
4175                  * of "DEFECT LIST NOT FOUND".  HGST drives also return
4176                  * Primary/Grown defect list not found errors.  So just
4177                  * check for an ASC of 0x1c.
4178                  */
4179                 if ((sense_key == SSD_KEY_RECOVERED_ERROR)
4180                  && (asc == 0x1c)) {
4181                         const char *format_str;
4182
4183                         format_str = scsi_nv_to_str(defect_list_type_map,
4184                             sizeof(defect_list_type_map) /
4185                             sizeof(defect_list_type_map[0]),
4186                             list_format & SRDD10_DLIST_FORMAT_MASK);
4187                         warnx("requested defect format %s not available",
4188                             format_str ? format_str : "unknown");
4189
4190                         format_str = scsi_nv_to_str(defect_list_type_map,
4191                             sizeof(defect_list_type_map) /
4192                             sizeof(defect_list_type_map[0]), returned_type);
4193                         if (format_str != NULL) {
4194                                 warnx("Device returned %s format",
4195                                     format_str);
4196                         } else {
4197                                 error = 1;
4198                                 warnx("Device returned unknown defect"
4199                                      " data format %#x", returned_type);
4200                                 goto defect_bailout;
4201                         }
4202                 } else {
4203                         error = 1;
4204                         warnx("Error returned from read defect data command");
4205                         if (arglist & CAM_ARG_VERBOSE)
4206                                 cam_error_print(device, ccb, CAM_ESF_ALL,
4207                                                 CAM_EPF_ALL, stderr);
4208                         goto defect_bailout;
4209                 }
4210         } else if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
4211                 error = 1;
4212                 warnx("Error returned from read defect data command");
4213                 if (arglist & CAM_ARG_VERBOSE)
4214                         cam_error_print(device, ccb, CAM_ESF_ALL,
4215                                         CAM_EPF_ALL, stderr);
4216                 goto defect_bailout;
4217         }
4218
4219         if (first_pass != 0) {
4220                 fprintf(stderr, "Got %d defect", num_returned);
4221
4222                 if ((lists_specified == 0) || (num_returned == 0)) {
4223                         fprintf(stderr, "s.\n");
4224                         goto defect_bailout;
4225                 } else if (num_returned == 1)
4226                         fprintf(stderr, ":\n");
4227                 else
4228                         fprintf(stderr, "s:\n");
4229
4230                 first_pass = 0;
4231         }
4232
4233         /*
4234          * XXX KDM  I should probably clean up the printout format for the
4235          * disk defects.
4236          */
4237         switch (returned_type) {
4238         case SRDD10_PHYSICAL_SECTOR_FORMAT:
4239         case SRDD10_EXT_PHYS_FORMAT:
4240         {
4241                 struct scsi_defect_desc_phys_sector *dlist;
4242
4243                 dlist = (struct scsi_defect_desc_phys_sector *)
4244                         (defect_list + hdr_size);
4245
4246                 for (i = 0; i < num_valid; i++) {
4247                         uint32_t sector;
4248
4249                         sector = scsi_4btoul(dlist[i].sector);
4250                         if (returned_type == SRDD10_EXT_PHYS_FORMAT) {
4251                                 mads = (sector & SDD_EXT_PHYS_MADS) ?
4252                                        0 : 1;
4253                                 sector &= ~SDD_EXT_PHYS_FLAG_MASK;
4254                         }
4255                         if (hex_format == 0)
4256                                 fprintf(stdout, "%d:%d:%d%s",
4257                                         scsi_3btoul(dlist[i].cylinder),
4258                                         dlist[i].head,
4259                                         scsi_4btoul(dlist[i].sector),
4260                                         mads ? " - " : "\n");
4261                         else
4262                                 fprintf(stdout, "0x%x:0x%x:0x%x%s",
4263                                         scsi_3btoul(dlist[i].cylinder),
4264                                         dlist[i].head,
4265                                         scsi_4btoul(dlist[i].sector),
4266                                         mads ? " - " : "\n");
4267                         mads = 0;
4268                 }
4269                 if (num_valid < num_returned) {
4270                         starting_offset += num_valid;
4271                         goto next_batch;
4272                 }
4273                 break;
4274         }
4275         case SRDD10_BYTES_FROM_INDEX_FORMAT:
4276         case SRDD10_EXT_BFI_FORMAT:
4277         {
4278                 struct scsi_defect_desc_bytes_from_index *dlist;
4279
4280                 dlist = (struct scsi_defect_desc_bytes_from_index *)
4281                         (defect_list + hdr_size);
4282
4283                 for (i = 0; i < num_valid; i++) {
4284                         uint32_t bfi;
4285
4286                         bfi = scsi_4btoul(dlist[i].bytes_from_index);
4287                         if (returned_type == SRDD10_EXT_BFI_FORMAT) {
4288                                 mads = (bfi & SDD_EXT_BFI_MADS) ? 1 : 0;
4289                                 bfi &= ~SDD_EXT_BFI_FLAG_MASK;
4290                         }
4291                         if (hex_format == 0)
4292                                 fprintf(stdout, "%d:%d:%d%s",
4293                                         scsi_3btoul(dlist[i].cylinder),
4294                                         dlist[i].head,
4295                                         scsi_4btoul(dlist[i].bytes_from_index),
4296                                         mads ? " - " : "\n");
4297                         else
4298                                 fprintf(stdout, "0x%x:0x%x:0x%x%s",
4299                                         scsi_3btoul(dlist[i].cylinder),
4300                                         dlist[i].head,
4301                                         scsi_4btoul(dlist[i].bytes_from_index),
4302                                         mads ? " - " : "\n");
4303
4304                         mads = 0;
4305                 }
4306                 if (num_valid < num_returned) {
4307                         starting_offset += num_valid;
4308                         goto next_batch;
4309                 }
4310                 break;
4311         }
4312         case SRDDH10_BLOCK_FORMAT:
4313         {
4314                 struct scsi_defect_desc_block *dlist;
4315
4316                 dlist = (struct scsi_defect_desc_block *)
4317                         (defect_list + hdr_size);
4318
4319                 for (i = 0; i < num_valid; i++) {
4320                         if (hex_format == 0)
4321                                 fprintf(stdout, "%u\n",
4322                                         scsi_4btoul(dlist[i].address));
4323                         else
4324                                 fprintf(stdout, "0x%x\n",
4325                                         scsi_4btoul(dlist[i].address));
4326                 }
4327
4328                 if (num_valid < num_returned) {
4329                         starting_offset += num_valid;
4330                         goto next_batch;
4331                 }
4332
4333                 break;
4334         }
4335         case SRDD10_LONG_BLOCK_FORMAT:
4336         {
4337                 struct scsi_defect_desc_long_block *dlist;
4338
4339                 dlist = (struct scsi_defect_desc_long_block *)
4340                         (defect_list + hdr_size);
4341
4342                 for (i = 0; i < num_valid; i++) {
4343                         if (hex_format == 0)
4344                                 fprintf(stdout, "%ju\n",
4345                                         (uintmax_t)scsi_8btou64(
4346                                         dlist[i].address));
4347                         else
4348                                 fprintf(stdout, "0x%jx\n",
4349                                         (uintmax_t)scsi_8btou64(
4350                                         dlist[i].address));
4351                 }
4352
4353                 if (num_valid < num_returned) {
4354                         starting_offset += num_valid;
4355                         goto next_batch;
4356                 }
4357                 break;
4358         }
4359         default:
4360                 fprintf(stderr, "Unknown defect format 0x%x\n",
4361                         returned_type);
4362                 error = 1;
4363                 break;
4364         }
4365 defect_bailout:
4366
4367         if (defect_list != NULL)
4368                 free(defect_list);
4369
4370         if (ccb != NULL)
4371                 cam_freeccb(ccb);
4372
4373         return (error);
4374 }
4375
4376 #if 0
4377 void
4378 reassignblocks(struct cam_device *device, u_int32_t *blocks, int num_blocks)
4379 {
4380         union ccb *ccb;
4381
4382         ccb = cam_getccb(device);
4383
4384         cam_freeccb(ccb);
4385 }
4386 #endif
4387
4388 void
4389 mode_sense(struct cam_device *device, int *cdb_len, int dbd, int llbaa, int pc,
4390     int page, int subpage, int task_attr, int retry_count, int timeout,
4391     u_int8_t *data, int datalen)
4392 {
4393         union ccb *ccb;
4394         int error_code, sense_key, asc, ascq;
4395
4396         ccb = cam_getccb(device);
4397         if (ccb == NULL)
4398                 errx(1, "mode_sense: couldn't allocate CCB");
4399
4400 retry:
4401         /*
4402          * MODE SENSE(6) can't handle more then 255 bytes.  If there are more,
4403          * device must return error, so we should not get trucated data.
4404          */
4405         if (*cdb_len == 6 && datalen > 255)
4406                 datalen = 255;
4407
4408         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
4409
4410         scsi_mode_sense_subpage(&ccb->csio,
4411                         /* retries */ retry_count,
4412                         /* cbfcnp */ NULL,
4413                         /* tag_action */ task_attr,
4414                         /* dbd */ dbd,
4415                         /* pc */ pc << 6,
4416                         /* page */ page,
4417                         /* subpage */ subpage,
4418                         /* param_buf */ data,
4419                         /* param_len */ datalen,
4420                         /* minimum_cmd_size */ *cdb_len,
4421                         /* sense_len */ SSD_FULL_SIZE,
4422                         /* timeout */ timeout ? timeout : 5000);
4423         if (llbaa && ccb->csio.cdb_len == 10) {
4424                 struct scsi_mode_sense_10 *cdb =
4425                     (struct scsi_mode_sense_10 *)ccb->csio.cdb_io.cdb_bytes;
4426                 cdb->byte2 |= SMS10_LLBAA;
4427         }
4428
4429         /* Record what CDB size the above function really set. */
4430         *cdb_len = ccb->csio.cdb_len;
4431
4432         if (arglist & CAM_ARG_ERR_RECOVER)
4433                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
4434
4435         /* Disable freezing the device queue */
4436         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
4437
4438         if (cam_send_ccb(device, ccb) < 0)
4439                 err(1, "error sending mode sense command");
4440
4441         /* In case of ILLEGEL REQUEST try to fall back to 6-byte command. */
4442         if (*cdb_len != 6 &&
4443             ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INVALID ||
4444              (scsi_extract_sense_ccb(ccb, &error_code, &sense_key, &asc, &ascq)
4445               && sense_key == SSD_KEY_ILLEGAL_REQUEST))) {
4446                 *cdb_len = 6;
4447                 goto retry;
4448         }
4449
4450         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
4451                 if (arglist & CAM_ARG_VERBOSE) {
4452                         cam_error_print(device, ccb, CAM_ESF_ALL,
4453                                         CAM_EPF_ALL, stderr);
4454                 }
4455                 cam_freeccb(ccb);
4456                 cam_close_device(device);
4457                 errx(1, "mode sense command returned error");
4458         }
4459
4460         cam_freeccb(ccb);
4461 }
4462
4463 void
4464 mode_select(struct cam_device *device, int cdb_len, int save_pages,
4465     int task_attr, int retry_count, int timeout, u_int8_t *data, int datalen)
4466 {
4467         union ccb *ccb;
4468         int retval;
4469
4470         ccb = cam_getccb(device);
4471
4472         if (ccb == NULL)
4473                 errx(1, "mode_select: couldn't allocate CCB");
4474
4475         scsi_mode_select_len(&ccb->csio,
4476                          /* retries */ retry_count,
4477                          /* cbfcnp */ NULL,
4478                          /* tag_action */ task_attr,
4479                          /* scsi_page_fmt */ 1,
4480                          /* save_pages */ save_pages,
4481                          /* param_buf */ data,
4482                          /* param_len */ datalen,
4483                          /* minimum_cmd_size */ cdb_len,
4484                          /* sense_len */ SSD_FULL_SIZE,
4485                          /* timeout */ timeout ? timeout : 5000);
4486
4487         if (arglist & CAM_ARG_ERR_RECOVER)
4488                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
4489
4490         /* Disable freezing the device queue */
4491         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
4492
4493         if (((retval = cam_send_ccb(device, ccb)) < 0)
4494          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
4495                 if (arglist & CAM_ARG_VERBOSE) {
4496                         cam_error_print(device, ccb, CAM_ESF_ALL,
4497                                         CAM_EPF_ALL, stderr);
4498                 }
4499                 cam_freeccb(ccb);
4500                 cam_close_device(device);
4501
4502                 if (retval < 0)
4503                         err(1, "error sending mode select command");
4504                 else
4505                         errx(1, "error sending mode select command");
4506
4507         }
4508
4509         cam_freeccb(ccb);
4510 }
4511
4512 void
4513 modepage(struct cam_device *device, int argc, char **argv, char *combinedopt,
4514          int task_attr, int retry_count, int timeout)
4515 {
4516         char *str_subpage;
4517         int c, page = -1, subpage = 0, pc = 0, llbaa = 0;
4518         int binary = 0, cdb_len = 10, dbd = 0, desc = 0, edit = 0, list = 0;
4519
4520         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4521                 switch(c) {
4522                 case '6':
4523                         cdb_len = 6;
4524                         break;
4525                 case 'b':
4526                         binary = 1;
4527                         break;
4528                 case 'd':
4529                         dbd = 1;
4530                         break;
4531                 case 'e':
4532                         edit = 1;
4533                         break;
4534                 case 'l':
4535                         list++;
4536                         break;
4537                 case 'm':
4538                         str_subpage = optarg;
4539                         strsep(&str_subpage, ",");
4540                         page = strtol(optarg, NULL, 0);
4541                         if (str_subpage)
4542                             subpage = strtol(str_subpage, NULL, 0);
4543                         if (page < 0 || page > 0x3f)
4544                                 errx(1, "invalid mode page %d", page);
4545                         if (subpage < 0 || subpage > 0xff)
4546                                 errx(1, "invalid mode subpage %d", subpage);
4547                         break;
4548                 case 'D':
4549                         desc = 1;
4550                         break;
4551                 case 'L':
4552                         llbaa = 1;
4553                         break;
4554                 case 'P':
4555                         pc = strtol(optarg, NULL, 0);
4556                         if ((pc < 0) || (pc > 3))
4557                                 errx(1, "invalid page control field %d", pc);
4558                         break;
4559                 default:
4560                         break;
4561                 }
4562         }
4563
4564         if (desc && page == -1)
4565                 page = SMS_ALL_PAGES_PAGE;
4566
4567         if (page == -1 && list == 0)
4568                 errx(1, "you must specify a mode page!");
4569
4570         if (dbd && desc)
4571                 errx(1, "-d and -D are incompatible!");
4572
4573         if (llbaa && cdb_len != 10)
4574                 errx(1, "LLBAA bit is not present in MODE SENSE(6)!");
4575
4576         if (list != 0) {
4577                 mode_list(device, cdb_len, dbd, pc, list > 1, task_attr,
4578                     retry_count, timeout);
4579         } else {
4580                 mode_edit(device, cdb_len, desc, dbd, llbaa, pc, page, subpage,
4581                     edit, binary, task_attr, retry_count, timeout);
4582         }
4583 }
4584
4585 static int
4586 scsicmd(struct cam_device *device, int argc, char **argv, char *combinedopt,
4587         int task_attr, int retry_count, int timeout)
4588 {
4589         union ccb *ccb;
4590         u_int32_t flags = CAM_DIR_NONE;
4591         u_int8_t *data_ptr = NULL;
4592         u_int8_t cdb[20];
4593         u_int8_t atacmd[12];
4594         struct get_hook hook;
4595         int c, data_bytes = 0, valid_bytes;
4596         int cdb_len = 0;
4597         int atacmd_len = 0;
4598         int dmacmd = 0;
4599         int fpdmacmd = 0;
4600         int need_res = 0;
4601         char *datastr = NULL, *tstr, *resstr = NULL;
4602         int error = 0;
4603         int fd_data = 0, fd_res = 0;
4604         int retval;
4605
4606         ccb = cam_getccb(device);
4607
4608         if (ccb == NULL) {
4609                 warnx("scsicmd: error allocating ccb");
4610                 return (1);
4611         }
4612
4613         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4614                 switch(c) {
4615                 case 'a':
4616                         tstr = optarg;
4617                         while (isspace(*tstr) && (*tstr != '\0'))
4618                                 tstr++;
4619                         hook.argc = argc - optind;
4620                         hook.argv = argv + optind;
4621                         hook.got = 0;
4622                         atacmd_len = buff_encode_visit(atacmd, sizeof(atacmd), tstr,
4623                                                     iget, &hook);
4624                         /*
4625                          * Increment optind by the number of arguments the
4626                          * encoding routine processed.  After each call to
4627                          * getopt(3), optind points to the argument that
4628                          * getopt should process _next_.  In this case,
4629                          * that means it points to the first command string
4630                          * argument, if there is one.  Once we increment
4631                          * this, it should point to either the next command
4632                          * line argument, or it should be past the end of
4633                          * the list.
4634                          */
4635                         optind += hook.got;
4636                         break;
4637                 case 'c':
4638                         tstr = optarg;
4639                         while (isspace(*tstr) && (*tstr != '\0'))
4640                                 tstr++;
4641                         hook.argc = argc - optind;
4642                         hook.argv = argv + optind;
4643                         hook.got = 0;
4644                         cdb_len = buff_encode_visit(cdb, sizeof(cdb), tstr,
4645                                                     iget, &hook);
4646                         /*
4647                          * Increment optind by the number of arguments the
4648                          * encoding routine processed.  After each call to
4649                          * getopt(3), optind points to the argument that
4650                          * getopt should process _next_.  In this case,
4651                          * that means it points to the first command string
4652                          * argument, if there is one.  Once we increment
4653                          * this, it should point to either the next command
4654                          * line argument, or it should be past the end of
4655                          * the list.
4656                          */
4657                         optind += hook.got;
4658                         break;
4659                 case 'd':
4660                         dmacmd = 1;
4661                         break;
4662                 case 'f':
4663                         fpdmacmd = 1;
4664                         break;
4665                 case 'i':
4666                         if (arglist & CAM_ARG_CMD_OUT) {
4667                                 warnx("command must either be "
4668                                       "read or write, not both");
4669                                 error = 1;
4670                                 goto scsicmd_bailout;
4671                         }
4672                         arglist |= CAM_ARG_CMD_IN;
4673                         flags = CAM_DIR_IN;
4674                         data_bytes = strtol(optarg, NULL, 0);
4675                         if (data_bytes <= 0) {
4676                                 warnx("invalid number of input bytes %d",
4677                                       data_bytes);
4678                                 error = 1;
4679                                 goto scsicmd_bailout;
4680                         }
4681                         hook.argc = argc - optind;
4682                         hook.argv = argv + optind;
4683                         hook.got = 0;
4684                         optind++;
4685                         datastr = cget(&hook, NULL);
4686                         /*
4687                          * If the user supplied "-" instead of a format, he
4688                          * wants the data to be written to stdout.
4689                          */
4690                         if ((datastr != NULL)
4691                          && (datastr[0] == '-'))
4692                                 fd_data = 1;
4693
4694                         data_ptr = (u_int8_t *)malloc(data_bytes);
4695                         if (data_ptr == NULL) {
4696                                 warnx("can't malloc memory for data_ptr");
4697                                 error = 1;
4698                                 goto scsicmd_bailout;
4699                         }
4700                         break;
4701                 case 'o':
4702                         if (arglist & CAM_ARG_CMD_IN) {
4703                                 warnx("command must either be "
4704                                       "read or write, not both");
4705                                 error = 1;
4706                                 goto scsicmd_bailout;
4707                         }
4708                         arglist |= CAM_ARG_CMD_OUT;
4709                         flags = CAM_DIR_OUT;
4710                         data_bytes = strtol(optarg, NULL, 0);
4711                         if (data_bytes <= 0) {
4712                                 warnx("invalid number of output bytes %d",
4713                                       data_bytes);
4714                                 error = 1;
4715                                 goto scsicmd_bailout;
4716                         }
4717                         hook.argc = argc - optind;
4718                         hook.argv = argv + optind;
4719                         hook.got = 0;
4720                         datastr = cget(&hook, NULL);
4721                         data_ptr = (u_int8_t *)malloc(data_bytes);
4722                         if (data_ptr == NULL) {
4723                                 warnx("can't malloc memory for data_ptr");
4724                                 error = 1;
4725                                 goto scsicmd_bailout;
4726                         }
4727                         bzero(data_ptr, data_bytes);
4728                         /*
4729                          * If the user supplied "-" instead of a format, he
4730                          * wants the data to be read from stdin.
4731                          */
4732                         if ((datastr != NULL)
4733                          && (datastr[0] == '-'))
4734                                 fd_data = 1;
4735                         else
4736                                 buff_encode_visit(data_ptr, data_bytes, datastr,
4737                                                   iget, &hook);
4738                         optind += hook.got;
4739                         break;
4740                 case 'r':
4741                         need_res = 1;
4742                         hook.argc = argc - optind;
4743                         hook.argv = argv + optind;
4744                         hook.got = 0;
4745                         resstr = cget(&hook, NULL);
4746                         if ((resstr != NULL) && (resstr[0] == '-'))
4747                                 fd_res = 1;
4748                         optind += hook.got;
4749                         break;
4750                 default:
4751                         break;
4752                 }
4753         }
4754
4755         /*
4756          * If fd_data is set, and we're writing to the device, we need to
4757          * read the data the user wants written from stdin.
4758          */
4759         if ((fd_data == 1) && (arglist & CAM_ARG_CMD_OUT)) {
4760                 ssize_t amt_read;
4761                 int amt_to_read = data_bytes;
4762                 u_int8_t *buf_ptr = data_ptr;
4763
4764                 for (amt_read = 0; amt_to_read > 0;
4765                      amt_read = read(STDIN_FILENO, buf_ptr, amt_to_read)) {
4766                         if (amt_read == -1) {
4767                                 warn("error reading data from stdin");
4768                                 error = 1;
4769                                 goto scsicmd_bailout;
4770                         }
4771                         amt_to_read -= amt_read;
4772                         buf_ptr += amt_read;
4773                 }
4774         }
4775
4776         if (arglist & CAM_ARG_ERR_RECOVER)
4777                 flags |= CAM_PASS_ERR_RECOVER;
4778
4779         /* Disable freezing the device queue */
4780         flags |= CAM_DEV_QFRZDIS;
4781
4782         if (cdb_len) {
4783                 /*
4784                  * This is taken from the SCSI-3 draft spec.
4785                  * (T10/1157D revision 0.3)
4786                  * The top 3 bits of an opcode are the group code.
4787                  * The next 5 bits are the command code.
4788                  * Group 0:  six byte commands
4789                  * Group 1:  ten byte commands
4790                  * Group 2:  ten byte commands
4791                  * Group 3:  reserved
4792                  * Group 4:  sixteen byte commands
4793                  * Group 5:  twelve byte commands
4794                  * Group 6:  vendor specific
4795                  * Group 7:  vendor specific
4796                  */
4797                 switch((cdb[0] >> 5) & 0x7) {
4798                         case 0:
4799                                 cdb_len = 6;
4800                                 break;
4801                         case 1:
4802                         case 2:
4803                                 cdb_len = 10;
4804                                 break;
4805                         case 3:
4806                         case 6:
4807                         case 7:
4808                                 /* computed by buff_encode_visit */
4809                                 break;
4810                         case 4:
4811                                 cdb_len = 16;
4812                                 break;
4813                         case 5:
4814                                 cdb_len = 12;
4815                                 break;
4816                 }
4817
4818                 /*
4819                  * We should probably use csio_build_visit or something like that
4820                  * here, but it's easier to encode arguments as you go.  The
4821                  * alternative would be skipping the CDB argument and then encoding
4822                  * it here, since we've got the data buffer argument by now.
4823                  */
4824                 bcopy(cdb, &ccb->csio.cdb_io.cdb_bytes, cdb_len);
4825
4826                 cam_fill_csio(&ccb->csio,
4827                       /*retries*/ retry_count,
4828                       /*cbfcnp*/ NULL,
4829                       /*flags*/ flags,
4830                       /*tag_action*/ task_attr,
4831                       /*data_ptr*/ data_ptr,
4832                       /*dxfer_len*/ data_bytes,
4833                       /*sense_len*/ SSD_FULL_SIZE,
4834                       /*cdb_len*/ cdb_len,
4835                       /*timeout*/ timeout ? timeout : 5000);
4836         } else {
4837                 atacmd_len = 12;
4838                 bcopy(atacmd, &ccb->ataio.cmd.command, atacmd_len);
4839                 if (need_res)
4840                         ccb->ataio.cmd.flags |= CAM_ATAIO_NEEDRESULT;
4841                 if (dmacmd)
4842                         ccb->ataio.cmd.flags |= CAM_ATAIO_DMA;
4843                 if (fpdmacmd)
4844                         ccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA;
4845
4846                 cam_fill_ataio(&ccb->ataio,
4847                       /*retries*/ retry_count,
4848                       /*cbfcnp*/ NULL,
4849                       /*flags*/ flags,
4850                       /*tag_action*/ 0,
4851                       /*data_ptr*/ data_ptr,
4852                       /*dxfer_len*/ data_bytes,
4853                       /*timeout*/ timeout ? timeout : 5000);
4854         }
4855
4856         if (((retval = cam_send_ccb(device, ccb)) < 0)
4857          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
4858                 const char warnstr[] = "error sending command";
4859
4860                 if (retval < 0)
4861                         warn(warnstr);
4862                 else
4863                         warnx(warnstr);
4864
4865                 if (arglist & CAM_ARG_VERBOSE) {
4866                         cam_error_print(device, ccb, CAM_ESF_ALL,
4867                                         CAM_EPF_ALL, stderr);
4868                 }
4869
4870                 error = 1;
4871                 goto scsicmd_bailout;
4872         }
4873
4874         if (atacmd_len && need_res) {
4875                 if (fd_res == 0) {
4876                         buff_decode_visit(&ccb->ataio.res.status, 11, resstr,
4877                                           arg_put, NULL);
4878                         fprintf(stdout, "\n");
4879                 } else {
4880                         fprintf(stdout,
4881                             "%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
4882                             ccb->ataio.res.status,
4883                             ccb->ataio.res.error,
4884                             ccb->ataio.res.lba_low,
4885                             ccb->ataio.res.lba_mid,
4886                             ccb->ataio.res.lba_high,
4887                             ccb->ataio.res.device,
4888                             ccb->ataio.res.lba_low_exp,
4889                             ccb->ataio.res.lba_mid_exp,
4890                             ccb->ataio.res.lba_high_exp,
4891                             ccb->ataio.res.sector_count,
4892                             ccb->ataio.res.sector_count_exp);
4893                         fflush(stdout);
4894                 }
4895         }
4896
4897         if (cdb_len)
4898                 valid_bytes = ccb->csio.dxfer_len - ccb->csio.resid;
4899         else
4900                 valid_bytes = ccb->ataio.dxfer_len - ccb->ataio.resid;
4901         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
4902          && (arglist & CAM_ARG_CMD_IN)
4903          && (valid_bytes > 0)) {
4904                 if (fd_data == 0) {
4905                         buff_decode_visit(data_ptr, valid_bytes, datastr,
4906                                           arg_put, NULL);
4907                         fprintf(stdout, "\n");
4908                 } else {
4909                         ssize_t amt_written;
4910                         int amt_to_write = valid_bytes;
4911                         u_int8_t *buf_ptr = data_ptr;
4912
4913                         for (amt_written = 0; (amt_to_write > 0) &&
4914                              (amt_written =write(1, buf_ptr,amt_to_write))> 0;){
4915                                 amt_to_write -= amt_written;
4916                                 buf_ptr += amt_written;
4917                         }
4918                         if (amt_written == -1) {
4919                                 warn("error writing data to stdout");
4920                                 error = 1;
4921                                 goto scsicmd_bailout;
4922                         } else if ((amt_written == 0)
4923                                 && (amt_to_write > 0)) {
4924                                 warnx("only wrote %u bytes out of %u",
4925                                       valid_bytes - amt_to_write, valid_bytes);
4926                         }
4927                 }
4928         }
4929
4930 scsicmd_bailout:
4931
4932         if ((data_bytes > 0) && (data_ptr != NULL))
4933                 free(data_ptr);
4934
4935         cam_freeccb(ccb);
4936
4937         return (error);
4938 }
4939
4940 static int
4941 camdebug(int argc, char **argv, char *combinedopt)
4942 {
4943         int c, fd;
4944         path_id_t bus = CAM_BUS_WILDCARD;
4945         target_id_t target = CAM_TARGET_WILDCARD;
4946         lun_id_t lun = CAM_LUN_WILDCARD;
4947         char *tstr;
4948         union ccb ccb;
4949         int error = 0, rv;
4950
4951         bzero(&ccb, sizeof(union ccb));
4952
4953         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4954                 switch(c) {
4955                 case 'I':
4956                         arglist |= CAM_ARG_DEBUG_INFO;
4957                         ccb.cdbg.flags |= CAM_DEBUG_INFO;
4958                         break;
4959                 case 'P':
4960                         arglist |= CAM_ARG_DEBUG_PERIPH;
4961                         ccb.cdbg.flags |= CAM_DEBUG_PERIPH;
4962                         break;
4963                 case 'S':
4964                         arglist |= CAM_ARG_DEBUG_SUBTRACE;
4965                         ccb.cdbg.flags |= CAM_DEBUG_SUBTRACE;
4966                         break;
4967                 case 'T':
4968                         arglist |= CAM_ARG_DEBUG_TRACE;
4969                         ccb.cdbg.flags |= CAM_DEBUG_TRACE;
4970                         break;
4971                 case 'X':
4972                         arglist |= CAM_ARG_DEBUG_XPT;
4973                         ccb.cdbg.flags |= CAM_DEBUG_XPT;
4974                         break;
4975                 case 'c':
4976                         arglist |= CAM_ARG_DEBUG_CDB;
4977                         ccb.cdbg.flags |= CAM_DEBUG_CDB;
4978                         break;
4979                 case 'p':
4980                         arglist |= CAM_ARG_DEBUG_PROBE;
4981                         ccb.cdbg.flags |= CAM_DEBUG_PROBE;
4982                         break;
4983                 default:
4984                         break;
4985                 }
4986         }
4987
4988         argc -= optind;
4989         argv += optind;
4990
4991         if (argc <= 0) {
4992                 warnx("you must specify \"off\", \"all\" or a bus,");
4993                 warnx("bus:target, bus:target:lun or periph");
4994                 return (1);
4995         }
4996
4997         tstr = *argv;
4998         while (isspace(*tstr) && (*tstr != '\0'))
4999                 tstr++;
5000
5001         if (strncmp(tstr, "off", 3) == 0) {
5002                 ccb.cdbg.flags = CAM_DEBUG_NONE;
5003                 arglist &= ~(CAM_ARG_DEBUG_INFO|CAM_ARG_DEBUG_PERIPH|
5004                              CAM_ARG_DEBUG_TRACE|CAM_ARG_DEBUG_SUBTRACE|
5005                              CAM_ARG_DEBUG_XPT|CAM_ARG_DEBUG_PROBE);
5006         } else {
5007                 rv = parse_btl(tstr, &bus, &target, &lun, &arglist);
5008                 if (rv < 1) {
5009                         warnx("you must specify \"all\", \"off\", or a bus,");
5010                         warnx("bus:target, bus:target:lun or periph to debug");
5011                         return (1);
5012                 }
5013         }
5014
5015         if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
5016                 warnx("error opening transport layer device %s", XPT_DEVICE);
5017                 warn("%s", XPT_DEVICE);
5018                 return (1);
5019         }
5020
5021         ccb.ccb_h.func_code = XPT_DEBUG;
5022         ccb.ccb_h.path_id = bus;
5023         ccb.ccb_h.target_id = target;
5024         ccb.ccb_h.target_lun = lun;
5025
5026         if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
5027                 warn("CAMIOCOMMAND ioctl failed");
5028                 error = 1;
5029         } else {
5030                 if ((ccb.ccb_h.status & CAM_STATUS_MASK) ==
5031                      CAM_FUNC_NOTAVAIL) {
5032                         warnx("CAM debugging not available");
5033                         warnx("you need to put options CAMDEBUG in"
5034                               " your kernel config file!");
5035                         error = 1;
5036                 } else if ((ccb.ccb_h.status & CAM_STATUS_MASK) !=
5037                             CAM_REQ_CMP) {
5038                         warnx("XPT_DEBUG CCB failed with status %#x",
5039                               ccb.ccb_h.status);
5040                         error = 1;
5041                 } else {
5042                         if (ccb.cdbg.flags == CAM_DEBUG_NONE) {
5043                                 fprintf(stderr,
5044                                         "Debugging turned off\n");
5045                         } else {
5046                                 fprintf(stderr,
5047                                         "Debugging enabled for "
5048                                         "%d:%d:%jx\n",
5049                                         bus, target, (uintmax_t)lun);
5050                         }
5051                 }
5052         }
5053         close(fd);
5054
5055         return (error);
5056 }
5057
5058 static int
5059 tagcontrol(struct cam_device *device, int argc, char **argv,
5060            char *combinedopt)
5061 {
5062         int c;
5063         union ccb *ccb;
5064         int numtags = -1;
5065         int retval = 0;
5066         int quiet = 0;
5067         char pathstr[1024];
5068
5069         ccb = cam_getccb(device);
5070
5071         if (ccb == NULL) {
5072                 warnx("tagcontrol: error allocating ccb");
5073                 return (1);
5074         }
5075
5076         while ((c = getopt(argc, argv, combinedopt)) != -1) {
5077                 switch(c) {
5078                 case 'N':
5079                         numtags = strtol(optarg, NULL, 0);
5080                         if (numtags < 0) {
5081                                 warnx("tag count %d is < 0", numtags);
5082                                 retval = 1;
5083                                 goto tagcontrol_bailout;
5084                         }
5085                         break;
5086                 case 'q':
5087                         quiet++;
5088                         break;
5089                 default:
5090                         break;
5091                 }
5092         }
5093
5094         cam_path_string(device, pathstr, sizeof(pathstr));
5095
5096         if (numtags >= 0) {
5097                 ccb->ccb_h.func_code = XPT_REL_SIMQ;
5098                 ccb->ccb_h.flags = CAM_DEV_QFREEZE;
5099                 ccb->crs.release_flags = RELSIM_ADJUST_OPENINGS;
5100                 ccb->crs.openings = numtags;
5101
5102
5103                 if (cam_send_ccb(device, ccb) < 0) {
5104                         warn("error sending XPT_REL_SIMQ CCB");
5105                         retval = 1;
5106                         goto tagcontrol_bailout;
5107                 }
5108
5109                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5110                         warnx("XPT_REL_SIMQ CCB failed");
5111                         cam_error_print(device, ccb, CAM_ESF_ALL,
5112                                         CAM_EPF_ALL, stderr);
5113                         retval = 1;
5114                         goto tagcontrol_bailout;
5115                 }
5116
5117
5118                 if (quiet == 0)
5119                         fprintf(stdout, "%stagged openings now %d\n",
5120                                 pathstr, ccb->crs.openings);
5121         }
5122
5123         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cgds);
5124
5125         ccb->ccb_h.func_code = XPT_GDEV_STATS;
5126
5127         if (cam_send_ccb(device, ccb) < 0) {
5128                 warn("error sending XPT_GDEV_STATS CCB");
5129                 retval = 1;
5130                 goto tagcontrol_bailout;
5131         }
5132
5133         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5134                 warnx("XPT_GDEV_STATS CCB failed");
5135                 cam_error_print(device, ccb, CAM_ESF_ALL,
5136                                 CAM_EPF_ALL, stderr);
5137                 retval = 1;
5138                 goto tagcontrol_bailout;
5139         }
5140
5141         if (arglist & CAM_ARG_VERBOSE) {
5142                 fprintf(stdout, "%s", pathstr);
5143                 fprintf(stdout, "dev_openings  %d\n", ccb->cgds.dev_openings);
5144                 fprintf(stdout, "%s", pathstr);
5145                 fprintf(stdout, "dev_active    %d\n", ccb->cgds.dev_active);
5146                 fprintf(stdout, "%s", pathstr);
5147                 fprintf(stdout, "allocated     %d\n", ccb->cgds.allocated);
5148                 fprintf(stdout, "%s", pathstr);
5149                 fprintf(stdout, "queued        %d\n", ccb->cgds.queued);
5150                 fprintf(stdout, "%s", pathstr);
5151                 fprintf(stdout, "held          %d\n", ccb->cgds.held);
5152                 fprintf(stdout, "%s", pathstr);
5153                 fprintf(stdout, "mintags       %d\n", ccb->cgds.mintags);
5154                 fprintf(stdout, "%s", pathstr);
5155                 fprintf(stdout, "maxtags       %d\n", ccb->cgds.maxtags);
5156         } else {
5157                 if (quiet == 0) {
5158                         fprintf(stdout, "%s", pathstr);
5159                         fprintf(stdout, "device openings: ");
5160                 }
5161                 fprintf(stdout, "%d\n", ccb->cgds.dev_openings +
5162                         ccb->cgds.dev_active);
5163         }
5164
5165 tagcontrol_bailout:
5166
5167         cam_freeccb(ccb);
5168         return (retval);
5169 }
5170
5171 static void
5172 cts_print(struct cam_device *device, struct ccb_trans_settings *cts)
5173 {
5174         char pathstr[1024];
5175
5176         cam_path_string(device, pathstr, sizeof(pathstr));
5177
5178         if (cts->transport == XPORT_SPI) {
5179                 struct ccb_trans_settings_spi *spi =
5180                     &cts->xport_specific.spi;
5181
5182                 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) {
5183
5184                         fprintf(stdout, "%ssync parameter: %d\n", pathstr,
5185                                 spi->sync_period);
5186
5187                         if (spi->sync_offset != 0) {
5188                                 u_int freq;
5189
5190                                 freq = scsi_calc_syncsrate(spi->sync_period);
5191                                 fprintf(stdout, "%sfrequency: %d.%03dMHz\n",
5192                                         pathstr, freq / 1000, freq % 1000);
5193                         }
5194                 }
5195
5196                 if (spi->valid & CTS_SPI_VALID_SYNC_OFFSET) {
5197                         fprintf(stdout, "%soffset: %d\n", pathstr,
5198                             spi->sync_offset);
5199                 }
5200
5201                 if (spi->valid & CTS_SPI_VALID_BUS_WIDTH) {
5202                         fprintf(stdout, "%sbus width: %d bits\n", pathstr,
5203                                 (0x01 << spi->bus_width) * 8);
5204                 }
5205
5206                 if (spi->valid & CTS_SPI_VALID_DISC) {
5207                         fprintf(stdout, "%sdisconnection is %s\n", pathstr,
5208                                 (spi->flags & CTS_SPI_FLAGS_DISC_ENB) ?
5209                                 "enabled" : "disabled");
5210                 }
5211         }
5212         if (cts->transport == XPORT_FC) {
5213                 struct ccb_trans_settings_fc *fc =
5214                     &cts->xport_specific.fc;
5215
5216                 if (fc->valid & CTS_FC_VALID_WWNN)
5217                         fprintf(stdout, "%sWWNN: 0x%llx\n", pathstr,
5218                             (long long) fc->wwnn);
5219                 if (fc->valid & CTS_FC_VALID_WWPN)
5220                         fprintf(stdout, "%sWWPN: 0x%llx\n", pathstr,
5221                             (long long) fc->wwpn);
5222                 if (fc->valid & CTS_FC_VALID_PORT)
5223                         fprintf(stdout, "%sPortID: 0x%x\n", pathstr, fc->port);
5224                 if (fc->valid & CTS_FC_VALID_SPEED)
5225                         fprintf(stdout, "%stransfer speed: %d.%03dMB/s\n",
5226                             pathstr, fc->bitrate / 1000, fc->bitrate % 1000);
5227         }
5228         if (cts->transport == XPORT_SAS) {
5229                 struct ccb_trans_settings_sas *sas =
5230                     &cts->xport_specific.sas;
5231
5232                 if (sas->valid & CTS_SAS_VALID_SPEED)
5233                         fprintf(stdout, "%stransfer speed: %d.%03dMB/s\n",
5234                             pathstr, sas->bitrate / 1000, sas->bitrate % 1000);
5235         }
5236         if (cts->transport == XPORT_ATA) {
5237                 struct ccb_trans_settings_pata *pata =
5238                     &cts->xport_specific.ata;
5239
5240                 if ((pata->valid & CTS_ATA_VALID_MODE) != 0) {
5241                         fprintf(stdout, "%sATA mode: %s\n", pathstr,
5242                                 ata_mode2string(pata->mode));
5243                 }
5244                 if ((pata->valid & CTS_ATA_VALID_ATAPI) != 0) {
5245                         fprintf(stdout, "%sATAPI packet length: %d\n", pathstr,
5246                                 pata->atapi);
5247                 }
5248                 if ((pata->valid & CTS_ATA_VALID_BYTECOUNT) != 0) {
5249                         fprintf(stdout, "%sPIO transaction length: %d\n",
5250                                 pathstr, pata->bytecount);
5251                 }
5252         }
5253         if (cts->transport == XPORT_SATA) {
5254                 struct ccb_trans_settings_sata *sata =
5255                     &cts->xport_specific.sata;
5256
5257                 if ((sata->valid & CTS_SATA_VALID_REVISION) != 0) {
5258                         fprintf(stdout, "%sSATA revision: %d.x\n", pathstr,
5259                                 sata->revision);
5260                 }
5261                 if ((sata->valid & CTS_SATA_VALID_MODE) != 0) {
5262                         fprintf(stdout, "%sATA mode: %s\n", pathstr,
5263                                 ata_mode2string(sata->mode));
5264                 }
5265                 if ((sata->valid & CTS_SATA_VALID_ATAPI) != 0) {
5266                         fprintf(stdout, "%sATAPI packet length: %d\n", pathstr,
5267                                 sata->atapi);
5268                 }
5269                 if ((sata->valid & CTS_SATA_VALID_BYTECOUNT) != 0) {
5270                         fprintf(stdout, "%sPIO transaction length: %d\n",
5271                                 pathstr, sata->bytecount);
5272                 }
5273                 if ((sata->valid & CTS_SATA_VALID_PM) != 0) {
5274                         fprintf(stdout, "%sPMP presence: %d\n", pathstr,
5275                                 sata->pm_present);
5276                 }
5277                 if ((sata->valid & CTS_SATA_VALID_TAGS) != 0) {
5278                         fprintf(stdout, "%sNumber of tags: %d\n", pathstr,
5279                                 sata->tags);
5280                 }
5281                 if ((sata->valid & CTS_SATA_VALID_CAPS) != 0) {
5282                         fprintf(stdout, "%sSATA capabilities: %08x\n", pathstr,
5283                                 sata->caps);
5284                 }
5285         }
5286         if (cts->protocol == PROTO_ATA) {
5287                 struct ccb_trans_settings_ata *ata=
5288                     &cts->proto_specific.ata;
5289
5290                 if (ata->valid & CTS_ATA_VALID_TQ) {
5291                         fprintf(stdout, "%stagged queueing: %s\n", pathstr,
5292                                 (ata->flags & CTS_ATA_FLAGS_TAG_ENB) ?
5293                                 "enabled" : "disabled");
5294                 }
5295         }
5296         if (cts->protocol == PROTO_SCSI) {
5297                 struct ccb_trans_settings_scsi *scsi=
5298                     &cts->proto_specific.scsi;
5299
5300                 if (scsi->valid & CTS_SCSI_VALID_TQ) {
5301                         fprintf(stdout, "%stagged queueing: %s\n", pathstr,
5302                                 (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) ?
5303                                 "enabled" : "disabled");
5304                 }
5305         }
5306 #ifdef WITH_NVME
5307         if (cts->protocol == PROTO_NVME) {
5308                 struct ccb_trans_settings_nvme *nvmex =
5309                     &cts->xport_specific.nvme;
5310
5311                 if (nvmex->valid & CTS_NVME_VALID_SPEC) {
5312                         fprintf(stdout, "%sNVMe Spec: %d.%d\n", pathstr,
5313                             NVME_MAJOR(nvmex->spec),
5314                             NVME_MINOR(nvmex->spec));
5315                 }
5316                 if (nvmex->valid & CTS_NVME_VALID_LINK) {
5317                         fprintf(stdout, "%sPCIe lanes: %d (%d max)\n", pathstr,
5318                             nvmex->lanes, nvmex->max_lanes);
5319                         fprintf(stdout, "%sPCIe Generation: %d (%d max)\n", pathstr,
5320                             nvmex->speed, nvmex->max_speed);
5321                 }
5322         }
5323 #endif
5324 }
5325
5326 /*
5327  * Get a path inquiry CCB for the specified device.
5328  */
5329 static int
5330 get_cpi(struct cam_device *device, struct ccb_pathinq *cpi)
5331 {
5332         union ccb *ccb;
5333         int retval = 0;
5334
5335         ccb = cam_getccb(device);
5336         if (ccb == NULL) {
5337                 warnx("get_cpi: couldn't allocate CCB");
5338                 return (1);
5339         }
5340         ccb->ccb_h.func_code = XPT_PATH_INQ;
5341         if (cam_send_ccb(device, ccb) < 0) {
5342                 warn("get_cpi: error sending Path Inquiry CCB");
5343                 retval = 1;
5344                 goto get_cpi_bailout;
5345         }
5346         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5347                 if (arglist & CAM_ARG_VERBOSE)
5348                         cam_error_print(device, ccb, CAM_ESF_ALL,
5349                                         CAM_EPF_ALL, stderr);
5350                 retval = 1;
5351                 goto get_cpi_bailout;
5352         }
5353         bcopy(&ccb->cpi, cpi, sizeof(struct ccb_pathinq));
5354
5355 get_cpi_bailout:
5356         cam_freeccb(ccb);
5357         return (retval);
5358 }
5359
5360 /*
5361  * Get a get device CCB for the specified device.
5362  */
5363 static int
5364 get_cgd(struct cam_device *device, struct ccb_getdev *cgd)
5365 {
5366         union ccb *ccb;
5367         int retval = 0;
5368
5369         ccb = cam_getccb(device);
5370         if (ccb == NULL) {
5371                 warnx("get_cgd: couldn't allocate CCB");
5372                 return (1);
5373         }
5374         ccb->ccb_h.func_code = XPT_GDEV_TYPE;
5375         if (cam_send_ccb(device, ccb) < 0) {
5376                 warn("get_cgd: error sending Get type information CCB");
5377                 retval = 1;
5378                 goto get_cgd_bailout;
5379         }
5380         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5381                 if (arglist & CAM_ARG_VERBOSE)
5382                         cam_error_print(device, ccb, CAM_ESF_ALL,
5383                                         CAM_EPF_ALL, stderr);
5384                 retval = 1;
5385                 goto get_cgd_bailout;
5386         }
5387         bcopy(&ccb->cgd, cgd, sizeof(struct ccb_getdev));
5388
5389 get_cgd_bailout:
5390         cam_freeccb(ccb);
5391         return (retval);
5392 }
5393
5394 /*
5395  * Returns 1 if the device has the VPD page, 0 if it does not, and -1 on an
5396  * error.
5397  */
5398 int
5399 dev_has_vpd_page(struct cam_device *dev, uint8_t page_id, int retry_count,
5400                  int timeout, int verbosemode)
5401 {
5402         union ccb *ccb = NULL;
5403         struct scsi_vpd_supported_page_list sup_pages;
5404         int i;
5405         int retval = 0;
5406
5407         ccb = cam_getccb(dev);
5408         if (ccb == NULL) {
5409                 warn("Unable to allocate CCB");
5410                 retval = -1;
5411                 goto bailout;
5412         }
5413
5414         bzero(&sup_pages, sizeof(sup_pages));
5415
5416         scsi_inquiry(&ccb->csio,
5417                      /*retries*/ retry_count,
5418                      /*cbfcnp*/ NULL,
5419                      /* tag_action */ MSG_SIMPLE_Q_TAG,
5420                      /* inq_buf */ (u_int8_t *)&sup_pages,
5421                      /* inq_len */ sizeof(sup_pages),
5422                      /* evpd */ 1,
5423                      /* page_code */ SVPD_SUPPORTED_PAGE_LIST,
5424                      /* sense_len */ SSD_FULL_SIZE,
5425                      /* timeout */ timeout ? timeout : 5000);
5426
5427         /* Disable freezing the device queue */
5428         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
5429
5430         if (retry_count != 0)
5431                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
5432
5433         if (cam_send_ccb(dev, ccb) < 0) {
5434                 cam_freeccb(ccb);
5435                 ccb = NULL;
5436                 retval = -1;
5437                 goto bailout;
5438         }
5439
5440         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5441                 if (verbosemode != 0)
5442                         cam_error_print(dev, ccb, CAM_ESF_ALL,
5443                                         CAM_EPF_ALL, stderr);
5444                 retval = -1;
5445                 goto bailout;
5446         }
5447
5448         for (i = 0; i < sup_pages.length; i++) {
5449                 if (sup_pages.list[i] == page_id) {
5450                         retval = 1;
5451                         goto bailout;
5452                 }
5453         }
5454 bailout:
5455         if (ccb != NULL)
5456                 cam_freeccb(ccb);
5457
5458         return (retval);
5459 }
5460
5461 /*
5462  * devtype is filled in with the type of device.
5463  * Returns 0 for success, non-zero for failure.
5464  */
5465 int
5466 get_device_type(struct cam_device *dev, int retry_count, int timeout,
5467                     int verbosemode, camcontrol_devtype *devtype)
5468 {
5469         struct ccb_getdev cgd;
5470         int retval;
5471
5472         retval = get_cgd(dev, &cgd);
5473         if (retval != 0)
5474                 goto bailout;
5475
5476         switch (cgd.protocol) {
5477         case PROTO_SCSI:
5478                 break;
5479         case PROTO_ATA:
5480         case PROTO_ATAPI:
5481         case PROTO_SATAPM:
5482                 *devtype = CC_DT_ATA;
5483                 goto bailout;
5484                 break; /*NOTREACHED*/
5485         case PROTO_NVME:
5486                 *devtype = CC_DT_NVME;
5487                 goto bailout;
5488                 break; /*NOTREACHED*/
5489         case PROTO_MMCSD:
5490                 *devtype = CC_DT_MMCSD;
5491                 goto bailout;
5492                 break; /*NOTREACHED*/
5493         default:
5494                 *devtype = CC_DT_UNKNOWN;
5495                 goto bailout;
5496                 break; /*NOTREACHED*/
5497         }
5498
5499         if (retry_count == -1) {
5500                 /*
5501                  * For a retry count of -1, used only the cached data to avoid
5502                  * I/O to the drive. Sending the identify command to the drive
5503                  * can cause issues for SATL attachaed drives since identify is
5504                  * not an NCQ command. We check for the strings that windows
5505                  * displays since those will not be NULs (they are supposed
5506                  * to be space padded). We could check other bits, but anything
5507                  * non-zero implies SATL.
5508                  */
5509                 if (cgd.ident_data.serial[0] != 0 ||
5510                     cgd.ident_data.revision[0] != 0 ||
5511                     cgd.ident_data.model[0] != 0)
5512                         *devtype = CC_DT_SATL;
5513                 else
5514                         *devtype = CC_DT_SCSI;
5515         } else {
5516                 /*
5517                  * Check for the ATA Information VPD page (0x89).  If this is an
5518                  * ATA device behind a SCSI to ATA translation layer (SATL),
5519                  * this VPD page should be present.
5520                  *
5521                  * If that VPD page isn't present, or we get an error back from
5522                  * the INQUIRY command, we'll just treat it as a normal SCSI
5523                  * device.
5524                  */
5525                 retval = dev_has_vpd_page(dev, SVPD_ATA_INFORMATION, retry_count,
5526                     timeout, verbosemode);
5527                 if (retval == 1)
5528                         *devtype = CC_DT_SATL;
5529                 else
5530                         *devtype = CC_DT_SCSI;
5531         }
5532         retval = 0;
5533
5534 bailout:
5535         return (retval);
5536 }
5537
5538 int
5539 build_ata_cmd(union ccb *ccb, uint32_t retry_count, uint32_t flags,
5540     uint8_t tag_action, uint8_t protocol, uint8_t ata_flags, uint16_t features,
5541     uint16_t sector_count, uint64_t lba, uint8_t command, uint32_t auxiliary,
5542     uint8_t *data_ptr, uint32_t dxfer_len, uint8_t *cdb_storage,
5543     size_t cdb_storage_len, uint8_t sense_len, uint32_t timeout,
5544     int is48bit, camcontrol_devtype devtype)
5545 {
5546         int retval = 0;
5547
5548         if (devtype == CC_DT_ATA) {
5549                 cam_fill_ataio(&ccb->ataio,
5550                     /*retries*/ retry_count,
5551                     /*cbfcnp*/ NULL,
5552                     /*flags*/ flags,
5553                     /*tag_action*/ tag_action,
5554                     /*data_ptr*/ data_ptr,
5555                     /*dxfer_len*/ dxfer_len,
5556                     /*timeout*/ timeout);
5557                 if (is48bit || lba > ATA_MAX_28BIT_LBA)
5558                         ata_48bit_cmd(&ccb->ataio, command, features, lba,
5559                             sector_count);
5560                 else
5561                         ata_28bit_cmd(&ccb->ataio, command, features, lba,
5562                             sector_count);
5563
5564                 if (auxiliary != 0) {
5565                         ccb->ataio.ata_flags |= ATA_FLAG_AUX;
5566                         ccb->ataio.aux = auxiliary;
5567                 }
5568
5569                 if (ata_flags & AP_FLAG_CHK_COND)
5570                         ccb->ataio.cmd.flags |= CAM_ATAIO_NEEDRESULT;
5571
5572                 if ((protocol & AP_PROTO_MASK) == AP_PROTO_DMA)
5573                         ccb->ataio.cmd.flags |= CAM_ATAIO_DMA;
5574                 else if ((protocol & AP_PROTO_MASK) == AP_PROTO_FPDMA)
5575                         ccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA;
5576         } else {
5577                 if (is48bit || lba > ATA_MAX_28BIT_LBA)
5578                         protocol |= AP_EXTEND;
5579
5580                 retval = scsi_ata_pass(&ccb->csio,
5581                     /*retries*/ retry_count,
5582                     /*cbfcnp*/ NULL,
5583                     /*flags*/ flags,
5584                     /*tag_action*/ tag_action,
5585                     /*protocol*/ protocol,
5586                     /*ata_flags*/ ata_flags,
5587                     /*features*/ features,
5588                     /*sector_count*/ sector_count,
5589                     /*lba*/ lba,
5590                     /*command*/ command,
5591                     /*device*/ 0,
5592                     /*icc*/ 0,
5593                     /*auxiliary*/ auxiliary,
5594                     /*control*/ 0,
5595                     /*data_ptr*/ data_ptr,
5596                     /*dxfer_len*/ dxfer_len,
5597                     /*cdb_storage*/ cdb_storage,
5598                     /*cdb_storage_len*/ cdb_storage_len,
5599                     /*minimum_cmd_size*/ 0,
5600                     /*sense_len*/ sense_len,
5601                     /*timeout*/ timeout);
5602         }
5603
5604         return (retval);
5605 }
5606
5607 /*
5608  * Returns: 0 -- success, 1 -- error, 2 -- lba truncated,
5609  *          4 -- count truncated, 6 -- lba and count truncated.
5610  */
5611 int
5612 get_ata_status(struct cam_device *dev, union ccb *ccb, uint8_t *error,
5613                uint16_t *count, uint64_t *lba, uint8_t *device, uint8_t *status)
5614 {
5615         int retval;
5616
5617         switch (ccb->ccb_h.func_code) {
5618         case XPT_SCSI_IO: {
5619                 uint8_t opcode;
5620                 int error_code = 0, sense_key = 0, asc = 0, ascq = 0;
5621                 u_int sense_len;
5622
5623                 /*
5624                  * In this case, we have SCSI ATA PASS-THROUGH command, 12
5625                  * or 16 byte, and need to see what
5626                  */
5627                 if (ccb->ccb_h.flags & CAM_CDB_POINTER)
5628                         opcode = ccb->csio.cdb_io.cdb_ptr[0];
5629                 else
5630                         opcode = ccb->csio.cdb_io.cdb_bytes[0];
5631                 if ((opcode != ATA_PASS_12)
5632                  && (opcode != ATA_PASS_16)) {
5633                         warnx("%s: unsupported opcode %02x", __func__, opcode);
5634                         return (1);
5635                 }
5636
5637                 retval = scsi_extract_sense_ccb(ccb, &error_code, &sense_key,
5638                                                 &asc, &ascq);
5639                 /* Note: the _ccb() variant returns 0 for an error */
5640                 if (retval == 0)
5641                         return (1);
5642
5643                 sense_len = ccb->csio.sense_len - ccb->csio.sense_resid;
5644                 switch (error_code) {
5645                 case SSD_DESC_CURRENT_ERROR:
5646                 case SSD_DESC_DEFERRED_ERROR: {
5647                         struct scsi_sense_data_desc *sense;
5648                         struct scsi_sense_ata_ret_desc *desc;
5649                         uint8_t *desc_ptr;
5650
5651                         sense = (struct scsi_sense_data_desc *)
5652                             &ccb->csio.sense_data;
5653
5654                         desc_ptr = scsi_find_desc(sense, sense_len,
5655                             SSD_DESC_ATA);
5656                         if (desc_ptr == NULL) {
5657                                 cam_error_print(dev, ccb, CAM_ESF_ALL,
5658                                     CAM_EPF_ALL, stderr);
5659                                 return (1);
5660                         }
5661                         desc = (struct scsi_sense_ata_ret_desc *)desc_ptr;
5662
5663                         *error = desc->error;
5664                         *count = (desc->count_15_8 << 8) |
5665                                   desc->count_7_0;
5666                         *lba = ((uint64_t)desc->lba_47_40 << 40) |
5667                                ((uint64_t)desc->lba_39_32 << 32) |
5668                                ((uint64_t)desc->lba_31_24 << 24) |
5669                                (desc->lba_23_16 << 16) |
5670                                (desc->lba_15_8  <<  8) |
5671                                 desc->lba_7_0;
5672                         *device = desc->device;
5673                         *status = desc->status;
5674
5675                         /*
5676                          * If the extend bit isn't set, the result is for a
5677                          * 12-byte ATA PASS-THROUGH command or a 16 or 32 byte
5678                          * command without the extend bit set.  This means
5679                          * that the device is supposed to return 28-bit
5680                          * status.  The count field is only 8 bits, and the
5681                          * LBA field is only 8 bits.
5682                          */
5683                         if ((desc->flags & SSD_DESC_ATA_FLAG_EXTEND) == 0){
5684                                 *count &= 0xff;
5685                                 *lba &= 0x0fffffff;
5686                         }
5687                         break;
5688                 }
5689                 case SSD_CURRENT_ERROR:
5690                 case SSD_DEFERRED_ERROR: {
5691                         uint64_t val;
5692
5693                         /*
5694                          * In my understanding of SAT-5 specification, saying:
5695                          * "without interpreting the contents of the STATUS",
5696                          * this should not happen if CK_COND was set, but it
5697                          * does at least for some devices, so try to revert.
5698                          */
5699                         if ((sense_key == SSD_KEY_ABORTED_COMMAND) &&
5700                             (asc == 0) && (ascq == 0)) {
5701                                 *status = ATA_STATUS_ERROR;
5702                                 *error = ATA_ERROR_ABORT;
5703                                 *device = 0;
5704                                 *count = 0;
5705                                 *lba = 0;
5706                                 return (0);
5707                         }
5708
5709                         if ((sense_key != SSD_KEY_RECOVERED_ERROR) ||
5710                             (asc != 0x00) || (ascq != 0x1d))
5711                                 return (1);
5712
5713                         val = 0;
5714                         scsi_get_sense_info(&ccb->csio.sense_data, sense_len,
5715                             SSD_DESC_INFO, &val, NULL);
5716                         *error = (val >> 24) & 0xff;
5717                         *status = (val >> 16) & 0xff;
5718                         *device = (val >> 8) & 0xff;
5719                         *count = val & 0xff;
5720
5721                         val = 0;
5722                         scsi_get_sense_info(&ccb->csio.sense_data, sense_len,
5723                             SSD_DESC_COMMAND, &val, NULL);
5724                         *lba = ((val >> 16) & 0xff) | (val & 0xff00) |
5725                                 ((val & 0xff) << 16);
5726
5727                         /* Report UPPER NONZERO bits as errors 2, 4 and 6. */
5728                         return ((val >> 28) & 0x06);
5729                 }
5730                 default:
5731                         return (1);
5732                 }
5733
5734                 break;
5735         }
5736         case XPT_ATA_IO: {
5737                 struct ata_res *res;
5738
5739                 /* Only some statuses return ATA result register set. */
5740                 if (cam_ccb_status(ccb) != CAM_REQ_CMP &&
5741                     cam_ccb_status(ccb) != CAM_ATA_STATUS_ERROR)
5742                         return (1);
5743
5744                 res = &ccb->ataio.res;
5745                 *error = res->error;
5746                 *status = res->status;
5747                 *device = res->device;
5748                 *count = res->sector_count;
5749                 *lba = (res->lba_high << 16) |
5750                        (res->lba_mid << 8) |
5751                        (res->lba_low);
5752                 if (ccb->ataio.cmd.flags & CAM_ATAIO_48BIT) {
5753                         *count |= (res->sector_count_exp << 8);
5754                         *lba |= ((uint64_t)res->lba_low_exp << 24) |
5755                                 ((uint64_t)res->lba_mid_exp << 32) |
5756                                 ((uint64_t)res->lba_high_exp << 40);
5757                 } else {
5758                         *lba |= (res->device & 0xf) << 24;
5759                 }
5760                 break;
5761         }
5762         default:
5763                 return (1);
5764         }
5765         return (0);
5766 }
5767
5768 static void
5769 cpi_print(struct ccb_pathinq *cpi)
5770 {
5771         char adapter_str[1024];
5772         uint64_t i;
5773
5774         snprintf(adapter_str, sizeof(adapter_str),
5775                  "%s%d:", cpi->dev_name, cpi->unit_number);
5776
5777         fprintf(stdout, "%s SIM/HBA version: %d\n", adapter_str,
5778                 cpi->version_num);
5779
5780         for (i = 1; i < UINT8_MAX; i = i << 1) {
5781                 const char *str;
5782
5783                 if ((i & cpi->hba_inquiry) == 0)
5784                         continue;
5785
5786                 fprintf(stdout, "%s supports ", adapter_str);
5787
5788                 switch(i) {
5789                 case PI_MDP_ABLE:
5790                         str = "MDP message";
5791                         break;
5792                 case PI_WIDE_32:
5793                         str = "32 bit wide SCSI";
5794                         break;
5795                 case PI_WIDE_16:
5796                         str = "16 bit wide SCSI";
5797                         break;
5798                 case PI_SDTR_ABLE:
5799                         str = "SDTR message";
5800                         break;
5801                 case PI_LINKED_CDB:
5802                         str = "linked CDBs";
5803                         break;
5804                 case PI_TAG_ABLE:
5805                         str = "tag queue messages";
5806                         break;
5807                 case PI_SOFT_RST:
5808                         str = "soft reset alternative";
5809                         break;
5810                 case PI_SATAPM:
5811                         str = "SATA Port Multiplier";
5812                         break;
5813                 default:
5814                         str = "unknown PI bit set";
5815                         break;
5816                 }
5817                 fprintf(stdout, "%s\n", str);
5818         }
5819
5820         for (i = 1; i < UINT32_MAX; i = i << 1) {
5821                 const char *str;
5822
5823                 if ((i & cpi->hba_misc) == 0)
5824                         continue;
5825
5826                 fprintf(stdout, "%s ", adapter_str);
5827
5828                 switch(i) {
5829                 case PIM_ATA_EXT:
5830                         str = "can understand ata_ext requests";
5831                         break;
5832                 case PIM_EXTLUNS:
5833                         str = "64bit extended LUNs supported";
5834                         break;
5835                 case PIM_SCANHILO:
5836                         str = "bus scans from high ID to low ID";
5837                         break;
5838                 case PIM_NOREMOVE:
5839                         str = "removable devices not included in scan";
5840                         break;
5841                 case PIM_NOINITIATOR:
5842                         str = "initiator role not supported";
5843                         break;
5844                 case PIM_NOBUSRESET:
5845                         str = "user has disabled initial BUS RESET or"
5846                               " controller is in target/mixed mode";
5847                         break;
5848                 case PIM_NO_6_BYTE:
5849                         str = "do not send 6-byte commands";
5850                         break;
5851                 case PIM_SEQSCAN:
5852                         str = "scan bus sequentially";
5853                         break;
5854                 case PIM_UNMAPPED:
5855                         str = "unmapped I/O supported";
5856                         break;
5857                 case PIM_NOSCAN:
5858                         str = "does its own scanning";
5859                         break;
5860                 default:
5861                         str = "unknown PIM bit set";
5862                         break;
5863                 }
5864                 fprintf(stdout, "%s\n", str);
5865         }
5866
5867         for (i = 1; i < UINT16_MAX; i = i << 1) {
5868                 const char *str;
5869
5870                 if ((i & cpi->target_sprt) == 0)
5871                         continue;
5872
5873                 fprintf(stdout, "%s supports ", adapter_str);
5874                 switch(i) {
5875                 case PIT_PROCESSOR:
5876                         str = "target mode processor mode";
5877                         break;
5878                 case PIT_PHASE:
5879                         str = "target mode phase cog. mode";
5880                         break;
5881                 case PIT_DISCONNECT:
5882                         str = "disconnects in target mode";
5883                         break;
5884                 case PIT_TERM_IO:
5885                         str = "terminate I/O message in target mode";
5886                         break;
5887                 case PIT_GRP_6:
5888                         str = "group 6 commands in target mode";
5889                         break;
5890                 case PIT_GRP_7:
5891                         str = "group 7 commands in target mode";
5892                         break;
5893                 default:
5894                         str = "unknown PIT bit set";
5895                         break;
5896                 }
5897
5898                 fprintf(stdout, "%s\n", str);
5899         }
5900         fprintf(stdout, "%s HBA engine count: %d\n", adapter_str,
5901                 cpi->hba_eng_cnt);
5902         fprintf(stdout, "%s maximum target: %d\n", adapter_str,
5903                 cpi->max_target);
5904         fprintf(stdout, "%s maximum LUN: %d\n", adapter_str,
5905                 cpi->max_lun);
5906         fprintf(stdout, "%s highest path ID in subsystem: %d\n",
5907                 adapter_str, cpi->hpath_id);
5908         fprintf(stdout, "%s initiator ID: %d\n", adapter_str,
5909                 cpi->initiator_id);
5910         fprintf(stdout, "%s SIM vendor: %s\n", adapter_str, cpi->sim_vid);
5911         fprintf(stdout, "%s HBA vendor: %s\n", adapter_str, cpi->hba_vid);
5912         fprintf(stdout, "%s HBA vendor ID: 0x%04x\n",
5913             adapter_str, cpi->hba_vendor);
5914         fprintf(stdout, "%s HBA device ID: 0x%04x\n",
5915             adapter_str, cpi->hba_device);
5916         fprintf(stdout, "%s HBA subvendor ID: 0x%04x\n",
5917             adapter_str, cpi->hba_subvendor);
5918         fprintf(stdout, "%s HBA subdevice ID: 0x%04x\n",
5919             adapter_str, cpi->hba_subdevice);
5920         fprintf(stdout, "%s bus ID: %d\n", adapter_str, cpi->bus_id);
5921         fprintf(stdout, "%s base transfer speed: ", adapter_str);
5922         if (cpi->base_transfer_speed > 1000)
5923                 fprintf(stdout, "%d.%03dMB/sec\n",
5924                         cpi->base_transfer_speed / 1000,
5925                         cpi->base_transfer_speed % 1000);
5926         else
5927                 fprintf(stdout, "%dKB/sec\n",
5928                         (cpi->base_transfer_speed % 1000) * 1000);
5929         fprintf(stdout, "%s maximum transfer size: %u bytes\n",
5930             adapter_str, cpi->maxio);
5931 }
5932
5933 static int
5934 get_print_cts(struct cam_device *device, int user_settings, int quiet,
5935               struct ccb_trans_settings *cts)
5936 {
5937         int retval;
5938         union ccb *ccb;
5939
5940         retval = 0;
5941         ccb = cam_getccb(device);
5942
5943         if (ccb == NULL) {
5944                 warnx("get_print_cts: error allocating ccb");
5945                 return (1);
5946         }
5947
5948         ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
5949
5950         if (user_settings == 0)
5951                 ccb->cts.type = CTS_TYPE_CURRENT_SETTINGS;
5952         else
5953                 ccb->cts.type = CTS_TYPE_USER_SETTINGS;
5954
5955         if (cam_send_ccb(device, ccb) < 0) {
5956                 warn("error sending XPT_GET_TRAN_SETTINGS CCB");
5957                 retval = 1;
5958                 goto get_print_cts_bailout;
5959         }
5960
5961         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5962                 warnx("XPT_GET_TRANS_SETTINGS CCB failed");
5963                 if (arglist & CAM_ARG_VERBOSE)
5964                         cam_error_print(device, ccb, CAM_ESF_ALL,
5965                                         CAM_EPF_ALL, stderr);
5966                 retval = 1;
5967                 goto get_print_cts_bailout;
5968         }
5969
5970         if (quiet == 0)
5971                 cts_print(device, &ccb->cts);
5972
5973         if (cts != NULL)
5974                 bcopy(&ccb->cts, cts, sizeof(struct ccb_trans_settings));
5975
5976 get_print_cts_bailout:
5977
5978         cam_freeccb(ccb);
5979
5980         return (retval);
5981 }
5982
5983 static int
5984 ratecontrol(struct cam_device *device, int task_attr, int retry_count,
5985             int timeout, int argc, char **argv, char *combinedopt)
5986 {
5987         int c;
5988         union ccb *ccb;
5989         int user_settings = 0;
5990         int retval = 0;
5991         int disc_enable = -1, tag_enable = -1;
5992         int mode = -1;
5993         int offset = -1;
5994         double syncrate = -1;
5995         int bus_width = -1;
5996         int quiet = 0;
5997         int change_settings = 0, send_tur = 0;
5998         struct ccb_pathinq cpi;
5999
6000         ccb = cam_getccb(device);
6001         if (ccb == NULL) {
6002                 warnx("ratecontrol: error allocating ccb");
6003                 return (1);
6004         }
6005         while ((c = getopt(argc, argv, combinedopt)) != -1) {
6006                 switch(c){
6007                 case 'a':
6008                         send_tur = 1;
6009                         break;
6010                 case 'c':
6011                         user_settings = 0;
6012                         break;
6013                 case 'D':
6014                         if (strncasecmp(optarg, "enable", 6) == 0)
6015                                 disc_enable = 1;
6016                         else if (strncasecmp(optarg, "disable", 7) == 0)
6017                                 disc_enable = 0;
6018                         else {
6019                                 warnx("-D argument \"%s\" is unknown", optarg);
6020                                 retval = 1;
6021                                 goto ratecontrol_bailout;
6022                         }
6023                         change_settings = 1;
6024                         break;
6025                 case 'M':
6026                         mode = ata_string2mode(optarg);
6027                         if (mode < 0) {
6028                                 warnx("unknown mode '%s'", optarg);
6029                                 retval = 1;
6030                                 goto ratecontrol_bailout;
6031                         }
6032                         change_settings = 1;
6033                         break;
6034                 case 'O':
6035                         offset = strtol(optarg, NULL, 0);
6036                         if (offset < 0) {
6037                                 warnx("offset value %d is < 0", offset);
6038                                 retval = 1;
6039                                 goto ratecontrol_bailout;
6040                         }
6041                         change_settings = 1;
6042                         break;
6043                 case 'q':
6044                         quiet++;
6045                         break;
6046                 case 'R':
6047                         syncrate = atof(optarg);
6048                         if (syncrate < 0) {
6049                                 warnx("sync rate %f is < 0", syncrate);
6050                                 retval = 1;
6051                                 goto ratecontrol_bailout;
6052                         }
6053                         change_settings = 1;
6054                         break;
6055                 case 'T':
6056                         if (strncasecmp(optarg, "enable", 6) == 0)
6057                                 tag_enable = 1;
6058                         else if (strncasecmp(optarg, "disable", 7) == 0)
6059                                 tag_enable = 0;
6060                         else {
6061                                 warnx("-T argument \"%s\" is unknown", optarg);
6062                                 retval = 1;
6063                                 goto ratecontrol_bailout;
6064                         }
6065                         change_settings = 1;
6066                         break;
6067                 case 'U':
6068                         user_settings = 1;
6069                         break;
6070                 case 'W':
6071                         bus_width = strtol(optarg, NULL, 0);
6072                         if (bus_width < 0) {
6073                                 warnx("bus width %d is < 0", bus_width);
6074                                 retval = 1;
6075                                 goto ratecontrol_bailout;
6076                         }
6077                         change_settings = 1;
6078                         break;
6079                 default:
6080                         break;
6081                 }
6082         }
6083         /*
6084          * Grab path inquiry information, so we can determine whether
6085          * or not the initiator is capable of the things that the user
6086          * requests.
6087          */
6088         if ((retval = get_cpi(device, &cpi)) != 0)
6089                 goto ratecontrol_bailout;
6090         if (quiet == 0) {
6091                 fprintf(stdout, "%s parameters:\n",
6092                     user_settings ? "User" : "Current");
6093         }
6094         retval = get_print_cts(device, user_settings, quiet, &ccb->cts);
6095         if (retval != 0)
6096                 goto ratecontrol_bailout;
6097
6098         if (arglist & CAM_ARG_VERBOSE)
6099                 cpi_print(&cpi);
6100
6101         if (change_settings) {
6102                 int didsettings = 0;
6103                 struct ccb_trans_settings_spi *spi = NULL;
6104                 struct ccb_trans_settings_pata *pata = NULL;
6105                 struct ccb_trans_settings_sata *sata = NULL;
6106                 struct ccb_trans_settings_ata *ata = NULL;
6107                 struct ccb_trans_settings_scsi *scsi = NULL;
6108
6109                 if (ccb->cts.transport == XPORT_SPI)
6110                         spi = &ccb->cts.xport_specific.spi;
6111                 if (ccb->cts.transport == XPORT_ATA)
6112                         pata = &ccb->cts.xport_specific.ata;
6113                 if (ccb->cts.transport == XPORT_SATA)
6114                         sata = &ccb->cts.xport_specific.sata;
6115                 if (ccb->cts.protocol == PROTO_ATA)
6116                         ata = &ccb->cts.proto_specific.ata;
6117                 if (ccb->cts.protocol == PROTO_SCSI)
6118                         scsi = &ccb->cts.proto_specific.scsi;
6119                 ccb->cts.xport_specific.valid = 0;
6120                 ccb->cts.proto_specific.valid = 0;
6121                 if (spi && disc_enable != -1) {
6122                         spi->valid |= CTS_SPI_VALID_DISC;
6123                         if (disc_enable == 0)
6124                                 spi->flags &= ~CTS_SPI_FLAGS_DISC_ENB;
6125                         else
6126                                 spi->flags |= CTS_SPI_FLAGS_DISC_ENB;
6127                         didsettings++;
6128                 }
6129                 if (tag_enable != -1) {
6130                         if ((cpi.hba_inquiry & PI_TAG_ABLE) == 0) {
6131                                 warnx("HBA does not support tagged queueing, "
6132                                       "so you cannot modify tag settings");
6133                                 retval = 1;
6134                                 goto ratecontrol_bailout;
6135                         }
6136                         if (ata) {
6137                                 ata->valid |= CTS_SCSI_VALID_TQ;
6138                                 if (tag_enable == 0)
6139                                         ata->flags &= ~CTS_ATA_FLAGS_TAG_ENB;
6140                                 else
6141                                         ata->flags |= CTS_ATA_FLAGS_TAG_ENB;
6142                                 didsettings++;
6143                         } else if (scsi) {
6144                                 scsi->valid |= CTS_SCSI_VALID_TQ;
6145                                 if (tag_enable == 0)
6146                                         scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB;
6147                                 else
6148                                         scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB;
6149                                 didsettings++;
6150                         }
6151                 }
6152                 if (spi && offset != -1) {
6153                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
6154                                 warnx("HBA is not capable of changing offset");
6155                                 retval = 1;
6156                                 goto ratecontrol_bailout;
6157                         }
6158                         spi->valid |= CTS_SPI_VALID_SYNC_OFFSET;
6159                         spi->sync_offset = offset;
6160                         didsettings++;
6161                 }
6162                 if (spi && syncrate != -1) {
6163                         int prelim_sync_period;
6164
6165                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
6166                                 warnx("HBA is not capable of changing "
6167                                       "transfer rates");
6168                                 retval = 1;
6169                                 goto ratecontrol_bailout;
6170                         }
6171                         spi->valid |= CTS_SPI_VALID_SYNC_RATE;
6172                         /*
6173                          * The sync rate the user gives us is in MHz.
6174                          * We need to translate it into KHz for this
6175                          * calculation.
6176                          */
6177                         syncrate *= 1000;
6178                         /*
6179                          * Next, we calculate a "preliminary" sync period
6180                          * in tenths of a nanosecond.
6181                          */
6182                         if (syncrate == 0)
6183                                 prelim_sync_period = 0;
6184                         else
6185                                 prelim_sync_period = 10000000 / syncrate;
6186                         spi->sync_period =
6187                                 scsi_calc_syncparam(prelim_sync_period);
6188                         didsettings++;
6189                 }
6190                 if (sata && syncrate != -1) {
6191                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
6192                                 warnx("HBA is not capable of changing "
6193                                       "transfer rates");
6194                                 retval = 1;
6195                                 goto ratecontrol_bailout;
6196                         }
6197                         if  (!user_settings) {
6198                                 warnx("You can modify only user rate "
6199                                     "settings for SATA");
6200                                 retval = 1;
6201                                 goto ratecontrol_bailout;
6202                         }
6203                         sata->revision = ata_speed2revision(syncrate * 100);
6204                         if (sata->revision < 0) {
6205                                 warnx("Invalid rate %f", syncrate);
6206                                 retval = 1;
6207                                 goto ratecontrol_bailout;
6208                         }
6209                         sata->valid |= CTS_SATA_VALID_REVISION;
6210                         didsettings++;
6211                 }
6212                 if ((pata || sata) && mode != -1) {
6213                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
6214                                 warnx("HBA is not capable of changing "
6215                                       "transfer rates");
6216                                 retval = 1;
6217                                 goto ratecontrol_bailout;
6218                         }
6219                         if  (!user_settings) {
6220                                 warnx("You can modify only user mode "
6221                                     "settings for ATA/SATA");
6222                                 retval = 1;
6223                                 goto ratecontrol_bailout;
6224                         }
6225                         if (pata) {
6226                                 pata->mode = mode;
6227                                 pata->valid |= CTS_ATA_VALID_MODE;
6228                         } else {
6229                                 sata->mode = mode;
6230                                 sata->valid |= CTS_SATA_VALID_MODE;
6231                         }
6232                         didsettings++;
6233                 }
6234                 /*
6235                  * The bus_width argument goes like this:
6236                  * 0 == 8 bit
6237                  * 1 == 16 bit
6238                  * 2 == 32 bit
6239                  * Therefore, if you shift the number of bits given on the
6240                  * command line right by 4, you should get the correct
6241                  * number.
6242                  */
6243                 if (spi && bus_width != -1) {
6244                         /*
6245                          * We might as well validate things here with a
6246                          * decipherable error message, rather than what
6247                          * will probably be an indecipherable error message
6248                          * by the time it gets back to us.
6249                          */
6250                         if ((bus_width == 16)
6251                          && ((cpi.hba_inquiry & PI_WIDE_16) == 0)) {
6252                                 warnx("HBA does not support 16 bit bus width");
6253                                 retval = 1;
6254                                 goto ratecontrol_bailout;
6255                         } else if ((bus_width == 32)
6256                                 && ((cpi.hba_inquiry & PI_WIDE_32) == 0)) {
6257                                 warnx("HBA does not support 32 bit bus width");
6258                                 retval = 1;
6259                                 goto ratecontrol_bailout;
6260                         } else if ((bus_width != 8)
6261                                 && (bus_width != 16)
6262                                 && (bus_width != 32)) {
6263                                 warnx("Invalid bus width %d", bus_width);
6264                                 retval = 1;
6265                                 goto ratecontrol_bailout;
6266                         }
6267                         spi->valid |= CTS_SPI_VALID_BUS_WIDTH;
6268                         spi->bus_width = bus_width >> 4;
6269                         didsettings++;
6270                 }
6271                 if  (didsettings == 0) {
6272                         goto ratecontrol_bailout;
6273                 }
6274                 ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
6275                 if (cam_send_ccb(device, ccb) < 0) {
6276                         warn("error sending XPT_SET_TRAN_SETTINGS CCB");
6277                         retval = 1;
6278                         goto ratecontrol_bailout;
6279                 }
6280                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
6281                         warnx("XPT_SET_TRANS_SETTINGS CCB failed");
6282                         if (arglist & CAM_ARG_VERBOSE) {
6283                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6284                                                 CAM_EPF_ALL, stderr);
6285                         }
6286                         retval = 1;
6287                         goto ratecontrol_bailout;
6288                 }
6289         }
6290         if (send_tur) {
6291                 retval = testunitready(device, task_attr, retry_count, timeout,
6292                                        (arglist & CAM_ARG_VERBOSE) ? 0 : 1);
6293                 /*
6294                  * If the TUR didn't succeed, just bail.
6295                  */
6296                 if (retval != 0) {
6297                         if (quiet == 0)
6298                                 fprintf(stderr, "Test Unit Ready failed\n");
6299                         goto ratecontrol_bailout;
6300                 }
6301         }
6302         if ((change_settings || send_tur) && !quiet &&
6303             (ccb->cts.transport == XPORT_ATA ||
6304              ccb->cts.transport == XPORT_SATA || send_tur)) {
6305                 fprintf(stdout, "New parameters:\n");
6306                 retval = get_print_cts(device, user_settings, 0, NULL);
6307         }
6308
6309 ratecontrol_bailout:
6310         cam_freeccb(ccb);
6311         return (retval);
6312 }
6313
6314 static int
6315 scsiformat(struct cam_device *device, int argc, char **argv,
6316            char *combinedopt, int task_attr, int retry_count, int timeout)
6317 {
6318         union ccb *ccb;
6319         int c;
6320         int ycount = 0, quiet = 0;
6321         int error = 0, retval = 0;
6322         int use_timeout = 10800 * 1000;
6323         int immediate = 1;
6324         struct format_defect_list_header fh;
6325         u_int8_t *data_ptr = NULL;
6326         u_int32_t dxfer_len = 0;
6327         u_int8_t byte2 = 0;
6328         int num_warnings = 0;
6329         int reportonly = 0;
6330
6331         ccb = cam_getccb(device);
6332
6333         if (ccb == NULL) {
6334                 warnx("scsiformat: error allocating ccb");
6335                 return (1);
6336         }
6337
6338         while ((c = getopt(argc, argv, combinedopt)) != -1) {
6339                 switch(c) {
6340                 case 'q':
6341                         quiet++;
6342                         break;
6343                 case 'r':
6344                         reportonly = 1;
6345                         break;
6346                 case 'w':
6347                         immediate = 0;
6348                         break;
6349                 case 'y':
6350                         ycount++;
6351                         break;
6352                 }
6353         }
6354
6355         if (reportonly)
6356                 goto doreport;
6357
6358         if (quiet == 0 && ycount == 0) {
6359                 fprintf(stdout, "You are about to REMOVE ALL DATA from the "
6360                         "following device:\n");
6361
6362                 error = scsidoinquiry(device, argc, argv, combinedopt,
6363                                       task_attr, retry_count, timeout);
6364
6365                 if (error != 0) {
6366                         warnx("scsiformat: error sending inquiry");
6367                         goto scsiformat_bailout;
6368                 }
6369         }
6370
6371         if (ycount == 0) {
6372                 if (!get_confirmation()) {
6373                         error = 1;
6374                         goto scsiformat_bailout;
6375                 }
6376         }
6377
6378         if (timeout != 0)
6379                 use_timeout = timeout;
6380
6381         if (quiet == 0) {
6382                 fprintf(stdout, "Current format timeout is %d seconds\n",
6383                         use_timeout / 1000);
6384         }
6385
6386         /*
6387          * If the user hasn't disabled questions and didn't specify a
6388          * timeout on the command line, ask them if they want the current
6389          * timeout.
6390          */
6391         if ((ycount == 0)
6392          && (timeout == 0)) {
6393                 char str[1024];
6394                 int new_timeout = 0;
6395
6396                 fprintf(stdout, "Enter new timeout in seconds or press\n"
6397                         "return to keep the current timeout [%d] ",
6398                         use_timeout / 1000);
6399
6400                 if (fgets(str, sizeof(str), stdin) != NULL) {
6401                         if (str[0] != '\0')
6402                                 new_timeout = atoi(str);
6403                 }
6404
6405                 if (new_timeout != 0) {
6406                         use_timeout = new_timeout * 1000;
6407                         fprintf(stdout, "Using new timeout value %d\n",
6408                                 use_timeout / 1000);
6409                 }
6410         }
6411
6412         /*
6413          * Keep this outside the if block below to silence any unused
6414          * variable warnings.
6415          */
6416         bzero(&fh, sizeof(fh));
6417
6418         /*
6419          * If we're in immediate mode, we've got to include the format
6420          * header
6421          */
6422         if (immediate != 0) {
6423                 fh.byte2 = FU_DLH_IMMED;
6424                 data_ptr = (u_int8_t *)&fh;
6425                 dxfer_len = sizeof(fh);
6426                 byte2 = FU_FMT_DATA;
6427         } else if (quiet == 0) {
6428                 fprintf(stdout, "Formatting...");
6429                 fflush(stdout);
6430         }
6431
6432         scsi_format_unit(&ccb->csio,
6433                          /* retries */ retry_count,
6434                          /* cbfcnp */ NULL,
6435                          /* tag_action */ task_attr,
6436                          /* byte2 */ byte2,
6437                          /* ileave */ 0,
6438                          /* data_ptr */ data_ptr,
6439                          /* dxfer_len */ dxfer_len,
6440                          /* sense_len */ SSD_FULL_SIZE,
6441                          /* timeout */ use_timeout);
6442
6443         /* Disable freezing the device queue */
6444         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6445
6446         if (arglist & CAM_ARG_ERR_RECOVER)
6447                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
6448
6449         if (((retval = cam_send_ccb(device, ccb)) < 0)
6450          || ((immediate == 0)
6451            && ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP))) {
6452                 const char errstr[] = "error sending format command";
6453
6454                 if (retval < 0)
6455                         warn(errstr);
6456                 else
6457                         warnx(errstr);
6458
6459                 if (arglist & CAM_ARG_VERBOSE) {
6460                         cam_error_print(device, ccb, CAM_ESF_ALL,
6461                                         CAM_EPF_ALL, stderr);
6462                 }
6463                 error = 1;
6464                 goto scsiformat_bailout;
6465         }
6466
6467         /*
6468          * If we ran in non-immediate mode, we already checked for errors
6469          * above and printed out any necessary information.  If we're in
6470          * immediate mode, we need to loop through and get status
6471          * information periodically.
6472          */
6473         if (immediate == 0) {
6474                 if (quiet == 0) {
6475                         fprintf(stdout, "Format Complete\n");
6476                 }
6477                 goto scsiformat_bailout;
6478         }
6479
6480 doreport:
6481         do {
6482                 cam_status status;
6483
6484                 CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
6485
6486                 /*
6487                  * There's really no need to do error recovery or
6488                  * retries here, since we're just going to sit in a
6489                  * loop and wait for the device to finish formatting.
6490                  */
6491                 scsi_test_unit_ready(&ccb->csio,
6492                                      /* retries */ 0,
6493                                      /* cbfcnp */ NULL,
6494                                      /* tag_action */ task_attr,
6495                                      /* sense_len */ SSD_FULL_SIZE,
6496                                      /* timeout */ 5000);
6497
6498                 /* Disable freezing the device queue */
6499                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6500
6501                 retval = cam_send_ccb(device, ccb);
6502
6503                 /*
6504                  * If we get an error from the ioctl, bail out.  SCSI
6505                  * errors are expected.
6506                  */
6507                 if (retval < 0) {
6508                         warn("error sending TEST UNIT READY command");
6509                         error = 1;
6510                         goto scsiformat_bailout;
6511                 }
6512
6513                 status = ccb->ccb_h.status & CAM_STATUS_MASK;
6514
6515                 if ((status != CAM_REQ_CMP)
6516                  && (status == CAM_SCSI_STATUS_ERROR)
6517                  && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
6518                         struct scsi_sense_data *sense;
6519                         int error_code, sense_key, asc, ascq;
6520
6521                         sense = &ccb->csio.sense_data;
6522                         scsi_extract_sense_len(sense, ccb->csio.sense_len -
6523                             ccb->csio.sense_resid, &error_code, &sense_key,
6524                             &asc, &ascq, /*show_errors*/ 1);
6525
6526                         /*
6527                          * According to the SCSI-2 and SCSI-3 specs, a
6528                          * drive that is in the middle of a format should
6529                          * return NOT READY with an ASC of "logical unit
6530                          * not ready, format in progress".  The sense key
6531                          * specific bytes will then be a progress indicator.
6532                          */
6533                         if ((sense_key == SSD_KEY_NOT_READY)
6534                          && (asc == 0x04) && (ascq == 0x04)) {
6535                                 uint8_t sks[3];
6536
6537                                 if ((scsi_get_sks(sense, ccb->csio.sense_len -
6538                                      ccb->csio.sense_resid, sks) == 0)
6539                                  && (quiet == 0)) {
6540                                         uint32_t val;
6541                                         u_int64_t percentage;
6542
6543                                         val = scsi_2btoul(&sks[1]);
6544                                         percentage = 10000ull * val;
6545
6546                                         fprintf(stdout,
6547                                                 "\rFormatting:  %ju.%02u %% "
6548                                                 "(%u/%d) done",
6549                                                 (uintmax_t)(percentage /
6550                                                 (0x10000 * 100)),
6551                                                 (unsigned)((percentage /
6552                                                 0x10000) % 100),
6553                                                 val, 0x10000);
6554                                         fflush(stdout);
6555                                 } else if ((quiet == 0)
6556                                         && (++num_warnings <= 1)) {
6557                                         warnx("Unexpected SCSI Sense Key "
6558                                               "Specific value returned "
6559                                               "during format:");
6560                                         scsi_sense_print(device, &ccb->csio,
6561                                                          stderr);
6562                                         warnx("Unable to print status "
6563                                               "information, but format will "
6564                                               "proceed.");
6565                                         warnx("will exit when format is "
6566                                               "complete");
6567                                 }
6568                                 sleep(1);
6569                         } else {
6570                                 warnx("Unexpected SCSI error during format");
6571                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6572                                                 CAM_EPF_ALL, stderr);
6573                                 error = 1;
6574                                 goto scsiformat_bailout;
6575                         }
6576
6577                 } else if (status != CAM_REQ_CMP) {
6578                         warnx("Unexpected CAM status %#x", status);
6579                         if (arglist & CAM_ARG_VERBOSE)
6580                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6581                                                 CAM_EPF_ALL, stderr);
6582                         error = 1;
6583                         goto scsiformat_bailout;
6584                 }
6585
6586         } while((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP);
6587
6588         if (quiet == 0)
6589                 fprintf(stdout, "\nFormat Complete\n");
6590
6591 scsiformat_bailout:
6592
6593         cam_freeccb(ccb);
6594
6595         return (error);
6596 }
6597
6598 static int
6599 sanitize_wait_ata(struct cam_device *device, union ccb *ccb, int quiet,
6600     camcontrol_devtype devtype)
6601 {
6602         int retval;
6603         uint8_t error = 0, ata_device = 0, status = 0;
6604         uint16_t count = 0;
6605         uint64_t lba = 0;
6606         u_int val, perc;
6607
6608         do {
6609                 retval = build_ata_cmd(ccb,
6610                              /*retries*/ 0,
6611                              /*flags*/ CAM_DIR_NONE,
6612                              /*tag_action*/ MSG_SIMPLE_Q_TAG,
6613                              /*protocol*/ AP_PROTO_NON_DATA,
6614                              /*ata_flags*/ AP_FLAG_CHK_COND,
6615                              /*features*/ 0x00, /* SANITIZE STATUS EXT */
6616                              /*sector_count*/ 0,
6617                              /*lba*/ 0,
6618                              /*command*/ ATA_SANITIZE,
6619                              /*auxiliary*/ 0,
6620                              /*data_ptr*/ NULL,
6621                              /*dxfer_len*/ 0,
6622                              /*cdb_storage*/ NULL,
6623                              /*cdb_storage_len*/ 0,
6624                              /*sense_len*/ SSD_FULL_SIZE,
6625                              /*timeout*/ 10000,
6626                              /*is48bit*/ 1,
6627                              /*devtype*/ devtype);
6628                 if (retval != 0) {
6629                         warnx("%s: build_ata_cmd() failed, likely "
6630                             "programmer error", __func__);
6631                         return (1);
6632                 }
6633
6634                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6635                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
6636                 retval = cam_send_ccb(device, ccb);
6637                 if (retval != 0) {
6638                         warn("error sending SANITIZE STATUS EXT command");
6639                         return (1);
6640                 }
6641
6642                 retval = get_ata_status(device, ccb, &error, &count, &lba,
6643                     &ata_device, &status);
6644                 if (retval != 0) {
6645                         warnx("Can't get SANITIZE STATUS EXT status, "
6646                             "sanitize may still run.");
6647                         return (retval);
6648                 }
6649                 if (status & ATA_STATUS_ERROR) {
6650                         if (error & ATA_ERROR_ABORT) {
6651                                 switch (lba & 0xff) {
6652                                 case 0x00:
6653                                         warnx("Reason not reported or sanitize failed.");
6654                                         return (1);
6655                                 case 0x01:
6656                                         warnx("Sanitize command unsuccessful.       ");
6657                                         return (1);
6658                                 case 0x02:
6659                                         warnx("Unsupported sanitize device command. ");
6660                                         return (1);
6661                                 case 0x03:
6662                                         warnx("Device is in sanitize frozen state.  ");
6663                                         return (1);
6664                                 case 0x04:
6665                                         warnx("Sanitize antifreeze lock is enabled. ");
6666                                         return (1);
6667                                 }
6668                         }
6669                         warnx("SANITIZE STATUS EXT failed, "
6670                             "sanitize may still run.");
6671                         return (1);
6672                 }
6673                 if (count & 0x4000) {
6674                         if (quiet == 0) {
6675                                 val = lba & 0xffff;
6676                                 perc = 10000 * val;
6677                                 fprintf(stdout,
6678                                     "Sanitizing: %u.%02u%% (%d/%d)\r",
6679                                     (perc / (0x10000 * 100)),
6680                                     ((perc / 0x10000) % 100),
6681                                     val, 0x10000);
6682                                 fflush(stdout);
6683                         }
6684                         sleep(1);
6685                 } else
6686                         break;
6687         } while (1);
6688         return (0);
6689 }
6690
6691 static int
6692 sanitize_wait_scsi(struct cam_device *device, union ccb *ccb, int task_attr, int quiet)
6693 {
6694         int warnings = 0, retval;
6695         cam_status status;
6696         u_int val, perc;
6697
6698         do {
6699                 CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
6700
6701                 /*
6702                  * There's really no need to do error recovery or
6703                  * retries here, since we're just going to sit in a
6704                  * loop and wait for the device to finish sanitizing.
6705                  */
6706                 scsi_test_unit_ready(&ccb->csio,
6707                                      /* retries */ 0,
6708                                      /* cbfcnp */ NULL,
6709                                      /* tag_action */ task_attr,
6710                                      /* sense_len */ SSD_FULL_SIZE,
6711                                      /* timeout */ 5000);
6712
6713                 /* Disable freezing the device queue */
6714                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6715
6716                 retval = cam_send_ccb(device, ccb);
6717
6718                 /*
6719                  * If we get an error from the ioctl, bail out.  SCSI
6720                  * errors are expected.
6721                  */
6722                 if (retval < 0) {
6723                         warn("error sending TEST UNIT READY command");
6724                         return (1);
6725                 }
6726
6727                 status = ccb->ccb_h.status & CAM_STATUS_MASK;
6728                 if ((status == CAM_SCSI_STATUS_ERROR) &&
6729                     ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
6730                         struct scsi_sense_data *sense;
6731                         int error_code, sense_key, asc, ascq;
6732
6733                         sense = &ccb->csio.sense_data;
6734                         scsi_extract_sense_len(sense, ccb->csio.sense_len -
6735                             ccb->csio.sense_resid, &error_code, &sense_key,
6736                             &asc, &ascq, /*show_errors*/ 1);
6737
6738                         /*
6739                          * According to the SCSI-3 spec, a drive that is in the
6740                          * middle of a sanitize should return NOT READY with an
6741                          * ASC of "logical unit not ready, sanitize in
6742                          * progress". The sense key specific bytes will then
6743                          * be a progress indicator.
6744                          */
6745                         if ((sense_key == SSD_KEY_NOT_READY)
6746                          && (asc == 0x04) && (ascq == 0x1b)) {
6747                                 uint8_t sks[3];
6748
6749                                 if ((scsi_get_sks(sense, ccb->csio.sense_len -
6750                                      ccb->csio.sense_resid, sks) == 0)
6751                                  && (quiet == 0)) {
6752                                         val = scsi_2btoul(&sks[1]);
6753                                         perc = 10000 * val;
6754                                         fprintf(stdout,
6755                                             "Sanitizing: %u.%02u%% (%d/%d)\r",
6756                                             (perc / (0x10000 * 100)),
6757                                             ((perc / 0x10000) % 100),
6758                                             val, 0x10000);
6759                                         fflush(stdout);
6760                                 } else if ((quiet == 0) && (++warnings <= 1)) {
6761                                         warnx("Unexpected SCSI Sense Key "
6762                                               "Specific value returned "
6763                                               "during sanitize:");
6764                                         scsi_sense_print(device, &ccb->csio,
6765                                                          stderr);
6766                                         warnx("Unable to print status "
6767                                               "information, but sanitze will "
6768                                               "proceed.");
6769                                         warnx("will exit when sanitize is "
6770                                               "complete");
6771                                 }
6772                                 sleep(1);
6773                         } else {
6774                                 warnx("Unexpected SCSI error during sanitize");
6775                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6776                                                 CAM_EPF_ALL, stderr);
6777                                 return (1);
6778                         }
6779
6780                 } else if (status != CAM_REQ_CMP && status != CAM_REQUEUE_REQ) {
6781                         warnx("Unexpected CAM status %#x", status);
6782                         if (arglist & CAM_ARG_VERBOSE)
6783                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6784                                                 CAM_EPF_ALL, stderr);
6785                         return (1);
6786                 }
6787         } while ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP);
6788         return (0);
6789 }
6790
6791 static int
6792 sanitize(struct cam_device *device, int argc, char **argv,
6793              char *combinedopt, int task_attr, int retry_count, int timeout)
6794 {
6795         union ccb *ccb;
6796         u_int8_t action = 0;
6797         int c;
6798         int ycount = 0, quiet = 0;
6799         int error = 0;
6800         int use_timeout;
6801         int immediate = 1;
6802         int invert = 0;
6803         int passes = 0;
6804         int ause = 0;
6805         int fd = -1;
6806         const char *pattern = NULL;
6807         u_int8_t *data_ptr = NULL;
6808         u_int32_t dxfer_len = 0;
6809         uint8_t byte2;
6810         uint16_t feature, count;
6811         uint64_t lba;
6812         int reportonly = 0;
6813         camcontrol_devtype dt;
6814
6815         /*
6816          * Get the device type, request no I/O be done to do this.
6817          */
6818         error = get_device_type(device, -1, 0, 0, &dt);
6819         if (error != 0 || (unsigned)dt > CC_DT_UNKNOWN) {
6820                 warnx("sanitize: can't get device type");
6821                 return (1);
6822         }
6823
6824         ccb = cam_getccb(device);
6825
6826         if (ccb == NULL) {
6827                 warnx("sanitize: error allocating ccb");
6828                 return (1);
6829         }
6830
6831         while ((c = getopt(argc, argv, combinedopt)) != -1) {
6832                 switch(c) {
6833                 case 'a':
6834                         if (strcasecmp(optarg, "overwrite") == 0)
6835                                 action = SSZ_SERVICE_ACTION_OVERWRITE;
6836                         else if (strcasecmp(optarg, "block") == 0)
6837                                 action = SSZ_SERVICE_ACTION_BLOCK_ERASE;
6838                         else if (strcasecmp(optarg, "crypto") == 0)
6839                                 action = SSZ_SERVICE_ACTION_CRYPTO_ERASE;
6840                         else if (strcasecmp(optarg, "exitfailure") == 0)
6841                                 action = SSZ_SERVICE_ACTION_EXIT_MODE_FAILURE;
6842                         else {
6843                                 warnx("invalid service operation \"%s\"",
6844                                       optarg);
6845                                 error = 1;
6846                                 goto sanitize_bailout;
6847                         }
6848                         break;
6849                 case 'c':
6850                         passes = strtol(optarg, NULL, 0);
6851                         if (passes < 1 || passes > 31) {
6852                                 warnx("invalid passes value %d", passes);
6853                                 error = 1;
6854                                 goto sanitize_bailout;
6855                         }
6856                         break;
6857                 case 'I':
6858                         invert = 1;
6859                         break;
6860                 case 'P':
6861                         pattern = optarg;
6862                         break;
6863                 case 'q':
6864                         quiet++;
6865                         break;
6866                 case 'U':
6867                         ause = 1;
6868                         break;
6869                 case 'r':
6870                         reportonly = 1;
6871                         break;
6872                 case 'w':
6873                         /* ATA supports only immediate commands. */
6874                         if (dt == CC_DT_SCSI)
6875                                 immediate = 0;
6876                         break;
6877                 case 'y':
6878                         ycount++;
6879                         break;
6880                 }
6881         }
6882
6883         if (reportonly)
6884                 goto doreport;
6885
6886         if (action == 0) {
6887                 warnx("an action is required");
6888                 error = 1;
6889                 goto sanitize_bailout;
6890         } else if (action == SSZ_SERVICE_ACTION_OVERWRITE) {
6891                 struct scsi_sanitize_parameter_list *pl;
6892                 struct stat sb;
6893                 ssize_t sz, amt;
6894
6895                 if (pattern == NULL) {
6896                         warnx("overwrite action requires -P argument");
6897                         error = 1;
6898                         goto sanitize_bailout;
6899                 }
6900                 fd = open(pattern, O_RDONLY);
6901                 if (fd < 0) {
6902                         warn("cannot open pattern file %s", pattern);
6903                         error = 1;
6904                         goto sanitize_bailout;
6905                 }
6906                 if (fstat(fd, &sb) < 0) {
6907                         warn("cannot stat pattern file %s", pattern);
6908                         error = 1;
6909                         goto sanitize_bailout;
6910                 }
6911                 sz = sb.st_size;
6912                 if (sz > SSZPL_MAX_PATTERN_LENGTH) {
6913                         warnx("pattern file size exceeds maximum value %d",
6914                               SSZPL_MAX_PATTERN_LENGTH);
6915                         error = 1;
6916                         goto sanitize_bailout;
6917                 }
6918                 dxfer_len = sizeof(*pl) + sz;
6919                 data_ptr = calloc(1, dxfer_len);
6920                 if (data_ptr == NULL) {
6921                         warnx("cannot allocate parameter list buffer");
6922                         error = 1;
6923                         goto sanitize_bailout;
6924                 }
6925
6926                 amt = read(fd, data_ptr + sizeof(*pl), sz);
6927                 if (amt < 0) {
6928                         warn("cannot read pattern file");
6929                         error = 1;
6930                         goto sanitize_bailout;
6931                 } else if (amt != sz) {
6932                         warnx("short pattern file read");
6933                         error = 1;
6934                         goto sanitize_bailout;
6935                 }
6936
6937                 pl = (struct scsi_sanitize_parameter_list *)data_ptr;
6938                 if (passes == 0)
6939                         pl->byte1 = 1;
6940                 else
6941                         pl->byte1 = passes;
6942                 if (invert != 0)
6943                         pl->byte1 |= SSZPL_INVERT;
6944                 scsi_ulto2b(sz, pl->length);
6945         } else {
6946                 const char *arg;
6947
6948                 if (passes != 0)
6949                         arg = "-c";
6950                 else if (invert != 0)
6951                         arg = "-I";
6952                 else if (pattern != NULL)
6953                         arg = "-P";
6954                 else
6955                         arg = NULL;
6956                 if (arg != NULL) {
6957                         warnx("%s argument only valid with overwrite "
6958                               "operation", arg);
6959                         error = 1;
6960                         goto sanitize_bailout;
6961                 }
6962         }
6963
6964         if (quiet == 0 && ycount == 0) {
6965                 fprintf(stdout, "You are about to REMOVE ALL DATA from the "
6966                         "following device:\n");
6967
6968                 if (dt == CC_DT_SCSI) {
6969                         error = scsidoinquiry(device, argc, argv, combinedopt,
6970                                               task_attr, retry_count, timeout);
6971                 } else if (dt == CC_DT_ATA || dt == CC_DT_SATL) {
6972                         struct ata_params *ident_buf;
6973                         error = ata_do_identify(device, retry_count, timeout,
6974                                                 ccb, &ident_buf);
6975                         if (error == 0) {
6976                                 printf("%s%d: ", device->device_name,
6977                                     device->dev_unit_num);
6978                                 ata_print_ident(ident_buf);
6979                                 free(ident_buf);
6980                         }
6981                 } else
6982                         error = 1;
6983
6984                 if (error != 0) {
6985                         warnx("sanitize: error sending inquiry");
6986                         goto sanitize_bailout;
6987                 }
6988         }
6989
6990         if (ycount == 0) {
6991                 if (!get_confirmation()) {
6992                         error = 1;
6993                         goto sanitize_bailout;
6994                 }
6995         }
6996
6997         if (timeout != 0)
6998                 use_timeout = timeout;
6999         else
7000                 use_timeout = (immediate ? 10 : 10800) * 1000;
7001
7002         if (immediate == 0 && quiet == 0) {
7003                 fprintf(stdout, "Current sanitize timeout is %d seconds\n",
7004                         use_timeout / 1000);
7005         }
7006
7007         /*
7008          * If the user hasn't disabled questions and didn't specify a
7009          * timeout on the command line, ask them if they want the current
7010          * timeout.
7011          */
7012         if (immediate == 0 && ycount == 0 && timeout == 0) {
7013                 char str[1024];
7014                 int new_timeout = 0;
7015
7016                 fprintf(stdout, "Enter new timeout in seconds or press\n"
7017                         "return to keep the current timeout [%d] ",
7018                         use_timeout / 1000);
7019
7020                 if (fgets(str, sizeof(str), stdin) != NULL) {
7021                         if (str[0] != '\0')
7022                                 new_timeout = atoi(str);
7023                 }
7024
7025                 if (new_timeout != 0) {
7026                         use_timeout = new_timeout * 1000;
7027                         fprintf(stdout, "Using new timeout value %d\n",
7028                                 use_timeout / 1000);
7029                 }
7030         }
7031
7032         if (dt == CC_DT_SCSI) {
7033                 byte2 = action;
7034                 if (ause != 0)
7035                         byte2 |= SSZ_UNRESTRICTED_EXIT;
7036                 if (immediate != 0)
7037                         byte2 |= SSZ_IMMED;
7038                 scsi_sanitize(&ccb->csio,
7039                               /* retries */ retry_count,
7040                               /* cbfcnp */ NULL,
7041                               /* tag_action */ task_attr,
7042                               /* byte2 */ byte2,
7043                               /* control */ 0,
7044                               /* data_ptr */ data_ptr,
7045                               /* dxfer_len */ dxfer_len,
7046                               /* sense_len */ SSD_FULL_SIZE,
7047                               /* timeout */ use_timeout);
7048
7049                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
7050                 if (arglist & CAM_ARG_ERR_RECOVER)
7051                         ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
7052                 if (cam_send_ccb(device, ccb) < 0) {
7053                         warn("error sending sanitize command");
7054                         error = 1;
7055                         goto sanitize_bailout;
7056                 }
7057         } else if (dt == CC_DT_ATA || dt == CC_DT_SATL) {
7058                 if (action == SSZ_SERVICE_ACTION_OVERWRITE) {
7059                         feature = 0x14; /* OVERWRITE EXT */
7060                         lba = 0x4F5700000000 | scsi_4btoul(data_ptr + 4);
7061                         count = (passes == 0) ? 1 : (passes >= 16) ? 0 : passes;
7062                         if (invert)
7063                                 count |= 0x80; /* INVERT PATTERN */
7064                         if (ause)
7065                                 count |= 0x10; /* FAILURE MODE */
7066                 } else if (action == SSZ_SERVICE_ACTION_BLOCK_ERASE) {
7067                         feature = 0x12; /* BLOCK ERASE EXT */
7068                         lba = 0x0000426B4572;
7069                         count = 0;
7070                         if (ause)
7071                                 count |= 0x10; /* FAILURE MODE */
7072                 } else if (action == SSZ_SERVICE_ACTION_CRYPTO_ERASE) {
7073                         feature = 0x11; /* CRYPTO SCRAMBLE EXT */
7074                         lba = 0x000043727970;
7075                         count = 0;
7076                         if (ause)
7077                                 count |= 0x10; /* FAILURE MODE */
7078                 } else if (action == SSZ_SERVICE_ACTION_EXIT_MODE_FAILURE) {
7079                         feature = 0x00; /* SANITIZE STATUS EXT */
7080                         lba = 0;
7081                         count = 1; /* CLEAR SANITIZE OPERATION FAILED */
7082                 } else {
7083                         error = 1;
7084                         goto sanitize_bailout;
7085                 }
7086
7087                 error = ata_do_cmd(device,
7088                                    ccb,
7089                                    retry_count,
7090                                    /*flags*/CAM_DIR_NONE,
7091                                    /*protocol*/AP_PROTO_NON_DATA | AP_EXTEND,
7092                                    /*ata_flags*/0,
7093                                    /*tag_action*/MSG_SIMPLE_Q_TAG,
7094                                    /*command*/ATA_SANITIZE,
7095                                    /*features*/feature,
7096                                    /*lba*/lba,
7097                                    /*sector_count*/count,
7098                                    /*data_ptr*/NULL,
7099                                    /*dxfer_len*/0,
7100                                    /*timeout*/ use_timeout,
7101                                    /*is48bit*/1);
7102         }
7103
7104         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
7105                 struct scsi_sense_data *sense;
7106                 int error_code, sense_key, asc, ascq;
7107
7108                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) ==
7109                     CAM_SCSI_STATUS_ERROR) {
7110                         sense = &ccb->csio.sense_data;
7111                         scsi_extract_sense_len(sense, ccb->csio.sense_len -
7112                             ccb->csio.sense_resid, &error_code, &sense_key,
7113                             &asc, &ascq, /*show_errors*/ 1);
7114
7115                         if (sense_key == SSD_KEY_ILLEGAL_REQUEST &&
7116                             asc == 0x20 && ascq == 0x00)
7117                                 warnx("sanitize is not supported by "
7118                                       "this device");
7119                         else
7120                                 warnx("error sanitizing this device");
7121                 } else
7122                         warnx("error sanitizing this device");
7123
7124                 if (arglist & CAM_ARG_VERBOSE) {
7125                         cam_error_print(device, ccb, CAM_ESF_ALL,
7126                                         CAM_EPF_ALL, stderr);
7127                 }
7128                 error = 1;
7129                 goto sanitize_bailout;
7130         }
7131
7132         /*
7133          * If we ran in non-immediate mode, we already checked for errors
7134          * above and printed out any necessary information.  If we're in
7135          * immediate mode, we need to loop through and get status
7136          * information periodically.
7137          */
7138         if (immediate == 0) {
7139                 if (quiet == 0) {
7140                         fprintf(stdout, "Sanitize Complete\n");
7141                 }
7142                 goto sanitize_bailout;
7143         }
7144
7145 doreport:
7146         if (dt == CC_DT_SCSI) {
7147                 error = sanitize_wait_scsi(device, ccb, task_attr, quiet);
7148         } else if (dt == CC_DT_ATA || dt == CC_DT_SATL) {
7149                 error = sanitize_wait_ata(device, ccb, quiet, dt);
7150         } else
7151                 error = 1;
7152         if (error == 0 && quiet == 0)
7153                 fprintf(stdout, "Sanitize Complete                      \n");
7154
7155 sanitize_bailout:
7156         if (fd >= 0)
7157                 close(fd);
7158         if (data_ptr != NULL)
7159                 free(data_ptr);
7160         cam_freeccb(ccb);
7161
7162         return (error);
7163 }
7164
7165 static int
7166 scsireportluns(struct cam_device *device, int argc, char **argv,
7167                char *combinedopt, int task_attr, int retry_count, int timeout)
7168 {
7169         union ccb *ccb;
7170         int c, countonly, lunsonly;
7171         struct scsi_report_luns_data *lundata;
7172         int alloc_len;
7173         uint8_t report_type;
7174         uint32_t list_len, i, j;
7175         int retval;
7176
7177         retval = 0;
7178         lundata = NULL;
7179         report_type = RPL_REPORT_DEFAULT;
7180         ccb = cam_getccb(device);
7181
7182         if (ccb == NULL) {
7183                 warnx("%s: error allocating ccb", __func__);
7184                 return (1);
7185         }
7186
7187         countonly = 0;
7188         lunsonly = 0;
7189
7190         while ((c = getopt(argc, argv, combinedopt)) != -1) {
7191                 switch (c) {
7192                 case 'c':
7193                         countonly++;
7194                         break;
7195                 case 'l':
7196                         lunsonly++;
7197                         break;
7198                 case 'r':
7199                         if (strcasecmp(optarg, "default") == 0)
7200                                 report_type = RPL_REPORT_DEFAULT;
7201                         else if (strcasecmp(optarg, "wellknown") == 0)
7202                                 report_type = RPL_REPORT_WELLKNOWN;
7203                         else if (strcasecmp(optarg, "all") == 0)
7204                                 report_type = RPL_REPORT_ALL;
7205                         else {
7206                                 warnx("%s: invalid report type \"%s\"",
7207                                       __func__, optarg);
7208                                 retval = 1;
7209                                 goto bailout;
7210                         }
7211                         break;
7212                 default:
7213                         break;
7214                 }
7215         }
7216
7217         if ((countonly != 0)
7218          && (lunsonly != 0)) {
7219                 warnx("%s: you can only specify one of -c or -l", __func__);
7220                 retval = 1;
7221                 goto bailout;
7222         }
7223         /*
7224          * According to SPC-4, the allocation length must be at least 16
7225          * bytes -- enough for the header and one LUN.
7226          */
7227         alloc_len = sizeof(*lundata) + 8;
7228
7229 retry:
7230
7231         lundata = malloc(alloc_len);
7232
7233         if (lundata == NULL) {
7234                 warn("%s: error mallocing %d bytes", __func__, alloc_len);
7235                 retval = 1;
7236                 goto bailout;
7237         }
7238
7239         scsi_report_luns(&ccb->csio,
7240                          /*retries*/ retry_count,
7241                          /*cbfcnp*/ NULL,
7242                          /*tag_action*/ task_attr,
7243                          /*select_report*/ report_type,
7244                          /*rpl_buf*/ lundata,
7245                          /*alloc_len*/ alloc_len,
7246                          /*sense_len*/ SSD_FULL_SIZE,
7247                          /*timeout*/ timeout ? timeout : 5000);
7248
7249         /* Disable freezing the device queue */
7250         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
7251
7252         if (arglist & CAM_ARG_ERR_RECOVER)
7253                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
7254
7255         if (cam_send_ccb(device, ccb) < 0) {
7256                 warn("error sending REPORT LUNS command");
7257                 retval = 1;
7258                 goto bailout;
7259         }
7260
7261         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
7262                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
7263                 retval = 1;
7264                 goto bailout;
7265         }
7266
7267
7268         list_len = scsi_4btoul(lundata->length);
7269
7270         /*
7271          * If we need to list the LUNs, and our allocation
7272          * length was too short, reallocate and retry.
7273          */
7274         if ((countonly == 0)
7275          && (list_len > (alloc_len - sizeof(*lundata)))) {
7276                 alloc_len = list_len + sizeof(*lundata);
7277                 free(lundata);
7278                 goto retry;
7279         }
7280
7281         if (lunsonly == 0)
7282                 fprintf(stdout, "%u LUN%s found\n", list_len / 8,
7283                         ((list_len / 8) > 1) ? "s" : "");
7284
7285         if (countonly != 0)
7286                 goto bailout;
7287
7288         for (i = 0; i < (list_len / 8); i++) {
7289                 int no_more;
7290
7291                 no_more = 0;
7292                 for (j = 0; j < sizeof(lundata->luns[i].lundata); j += 2) {
7293                         if (j != 0)
7294                                 fprintf(stdout, ",");
7295                         switch (lundata->luns[i].lundata[j] &
7296                                 RPL_LUNDATA_ATYP_MASK) {
7297                         case RPL_LUNDATA_ATYP_PERIPH:
7298                                 if ((lundata->luns[i].lundata[j] &
7299                                     RPL_LUNDATA_PERIPH_BUS_MASK) != 0)
7300                                         fprintf(stdout, "%d:",
7301                                                 lundata->luns[i].lundata[j] &
7302                                                 RPL_LUNDATA_PERIPH_BUS_MASK);
7303                                 else if ((j == 0)
7304                                       && ((lundata->luns[i].lundata[j+2] &
7305                                           RPL_LUNDATA_PERIPH_BUS_MASK) == 0))
7306                                         no_more = 1;
7307
7308                                 fprintf(stdout, "%d",
7309                                         lundata->luns[i].lundata[j+1]);
7310                                 break;
7311                         case RPL_LUNDATA_ATYP_FLAT: {
7312                                 uint8_t tmplun[2];
7313                                 tmplun[0] = lundata->luns[i].lundata[j] &
7314                                         RPL_LUNDATA_FLAT_LUN_MASK;
7315                                 tmplun[1] = lundata->luns[i].lundata[j+1];
7316
7317                                 fprintf(stdout, "%d", scsi_2btoul(tmplun));
7318                                 no_more = 1;
7319                                 break;
7320                         }
7321                         case RPL_LUNDATA_ATYP_LUN:
7322                                 fprintf(stdout, "%d:%d:%d",
7323                                         (lundata->luns[i].lundata[j+1] &
7324                                         RPL_LUNDATA_LUN_BUS_MASK) >> 5,
7325                                         lundata->luns[i].lundata[j] &
7326                                         RPL_LUNDATA_LUN_TARG_MASK,
7327                                         lundata->luns[i].lundata[j+1] &
7328                                         RPL_LUNDATA_LUN_LUN_MASK);
7329                                 break;
7330                         case RPL_LUNDATA_ATYP_EXTLUN: {
7331                                 int field_len_code, eam_code;
7332
7333                                 eam_code = lundata->luns[i].lundata[j] &
7334                                         RPL_LUNDATA_EXT_EAM_MASK;
7335                                 field_len_code = (lundata->luns[i].lundata[j] &
7336                                         RPL_LUNDATA_EXT_LEN_MASK) >> 4;
7337
7338                                 if ((eam_code == RPL_LUNDATA_EXT_EAM_WK)
7339                                  && (field_len_code == 0x00)) {
7340                                         fprintf(stdout, "%d",
7341                                                 lundata->luns[i].lundata[j+1]);
7342                                 } else if ((eam_code ==
7343                                             RPL_LUNDATA_EXT_EAM_NOT_SPEC)
7344                                         && (field_len_code == 0x03)) {
7345                                         uint8_t tmp_lun[8];
7346
7347                                         /*
7348                                          * This format takes up all 8 bytes.
7349                                          * If we aren't starting at offset 0,
7350                                          * that's a bug.
7351                                          */
7352                                         if (j != 0) {
7353                                                 fprintf(stdout, "Invalid "
7354                                                         "offset %d for "
7355                                                         "Extended LUN not "
7356                                                         "specified format", j);
7357                                                 no_more = 1;
7358                                                 break;
7359                                         }
7360                                         bzero(tmp_lun, sizeof(tmp_lun));
7361                                         bcopy(&lundata->luns[i].lundata[j+1],
7362                                               &tmp_lun[1], sizeof(tmp_lun) - 1);
7363                                         fprintf(stdout, "%#jx",
7364                                                (intmax_t)scsi_8btou64(tmp_lun));
7365                                         no_more = 1;
7366                                 } else {
7367                                         fprintf(stderr, "Unknown Extended LUN"
7368                                                 "Address method %#x, length "
7369                                                 "code %#x", eam_code,
7370                                                 field_len_code);
7371                                         no_more = 1;
7372                                 }
7373                                 break;
7374                         }
7375                         default:
7376                                 fprintf(stderr, "Unknown LUN address method "
7377                                         "%#x\n", lundata->luns[i].lundata[0] &
7378                                         RPL_LUNDATA_ATYP_MASK);
7379                                 break;
7380                         }
7381                         /*
7382                          * For the flat addressing method, there are no
7383                          * other levels after it.
7384                          */
7385                         if (no_more != 0)
7386                                 break;
7387                 }
7388                 fprintf(stdout, "\n");
7389         }
7390
7391 bailout:
7392
7393         cam_freeccb(ccb);
7394
7395         free(lundata);
7396
7397         return (retval);
7398 }
7399
7400 static int
7401 scsireadcapacity(struct cam_device *device, int argc, char **argv,
7402                  char *combinedopt, int task_attr, int retry_count, int timeout)
7403 {
7404         union ccb *ccb;
7405         int blocksizeonly, humanize, numblocks, quiet, sizeonly, baseten, longonly;
7406         struct scsi_read_capacity_data rcap;
7407         struct scsi_read_capacity_data_long rcaplong;
7408         uint64_t maxsector;
7409         uint32_t block_len;
7410         int retval;
7411         int c;
7412
7413         blocksizeonly = 0;
7414         humanize = 0;
7415         longonly = 0;
7416         numblocks = 0;
7417         quiet = 0;
7418         sizeonly = 0;
7419         baseten = 0;
7420         retval = 0;
7421
7422         ccb = cam_getccb(device);
7423
7424         if (ccb == NULL) {
7425                 warnx("%s: error allocating ccb", __func__);
7426                 return (1);
7427         }
7428
7429         while ((c = getopt(argc, argv, combinedopt)) != -1) {
7430                 switch (c) {
7431                 case 'b':
7432                         blocksizeonly++;
7433                         break;
7434                 case 'h':
7435                         humanize++;
7436                         baseten = 0;
7437                         break;
7438                 case 'H':
7439                         humanize++;
7440                         baseten++;
7441                         break;
7442                 case 'l':
7443                         longonly++;
7444                         break;
7445                 case 'N':
7446                         numblocks++;
7447                         break;
7448                 case 'q':
7449                         quiet++;
7450                         break;
7451                 case 's':
7452                         sizeonly++;
7453                         break;
7454                 default:
7455                         break;
7456                 }
7457         }
7458
7459         if ((blocksizeonly != 0)
7460          && (numblocks != 0)) {
7461                 warnx("%s: you can only specify one of -b or -N", __func__);
7462                 retval = 1;
7463                 goto bailout;
7464         }
7465
7466         if ((blocksizeonly != 0)
7467          && (sizeonly != 0)) {
7468                 warnx("%s: you can only specify one of -b or -s", __func__);
7469                 retval = 1;
7470                 goto bailout;
7471         }
7472
7473         if ((humanize != 0)
7474          && (quiet != 0)) {
7475                 warnx("%s: you can only specify one of -h/-H or -q", __func__);
7476                 retval = 1;
7477                 goto bailout;
7478         }
7479
7480         if ((humanize != 0)
7481          && (blocksizeonly != 0)) {
7482                 warnx("%s: you can only specify one of -h/-H or -b", __func__);
7483                 retval = 1;
7484                 goto bailout;
7485         }
7486
7487         if (longonly != 0)
7488                 goto long_only;
7489
7490         scsi_read_capacity(&ccb->csio,
7491                            /*retries*/ retry_count,
7492                            /*cbfcnp*/ NULL,
7493                            /*tag_action*/ task_attr,
7494                            &rcap,
7495                            SSD_FULL_SIZE,
7496                            /*timeout*/ timeout ? timeout : 5000);
7497
7498         /* Disable freezing the device queue */
7499         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
7500
7501         if (arglist & CAM_ARG_ERR_RECOVER)
7502                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
7503
7504         if (cam_send_ccb(device, ccb) < 0) {
7505                 warn("error sending READ CAPACITY command");
7506                 retval = 1;
7507                 goto bailout;
7508         }
7509
7510         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
7511                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
7512                 retval = 1;
7513                 goto bailout;
7514         }
7515
7516         maxsector = scsi_4btoul(rcap.addr);
7517         block_len = scsi_4btoul(rcap.length);
7518
7519         /*
7520          * A last block of 2^32-1 means that the true capacity is over 2TB,
7521          * and we need to issue the long READ CAPACITY to get the real
7522          * capacity.  Otherwise, we're all set.
7523          */
7524         if (maxsector != 0xffffffff)
7525                 goto do_print;
7526
7527 long_only:
7528         scsi_read_capacity_16(&ccb->csio,
7529                               /*retries*/ retry_count,
7530                               /*cbfcnp*/ NULL,
7531                               /*tag_action*/ task_attr,
7532                               /*lba*/ 0,
7533                               /*reladdr*/ 0,
7534                               /*pmi*/ 0,
7535                               /*rcap_buf*/ (uint8_t *)&rcaplong,
7536                               /*rcap_buf_len*/ sizeof(rcaplong),
7537                               /*sense_len*/ SSD_FULL_SIZE,
7538                               /*timeout*/ timeout ? timeout : 5000);
7539
7540         /* Disable freezing the device queue */
7541         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
7542
7543         if (arglist & CAM_ARG_ERR_RECOVER)
7544                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
7545
7546         if (cam_send_ccb(device, ccb) < 0) {
7547                 warn("error sending READ CAPACITY (16) command");
7548                 retval = 1;
7549                 goto bailout;
7550         }
7551
7552         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
7553                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
7554                 retval = 1;
7555                 goto bailout;
7556         }
7557
7558         maxsector = scsi_8btou64(rcaplong.addr);
7559         block_len = scsi_4btoul(rcaplong.length);
7560
7561 do_print:
7562         if (blocksizeonly == 0) {
7563                 /*
7564                  * Humanize implies !quiet, and also implies numblocks.
7565                  */
7566                 if (humanize != 0) {
7567                         char tmpstr[6];
7568                         int64_t tmpbytes;
7569                         int ret;
7570
7571                         tmpbytes = (maxsector + 1) * block_len;
7572                         ret = humanize_number(tmpstr, sizeof(tmpstr),
7573                                               tmpbytes, "", HN_AUTOSCALE,
7574                                               HN_B | HN_DECIMAL |
7575                                               ((baseten != 0) ?
7576                                               HN_DIVISOR_1000 : 0));
7577                         if (ret == -1) {
7578                                 warnx("%s: humanize_number failed!", __func__);
7579                                 retval = 1;
7580                                 goto bailout;
7581                         }
7582                         fprintf(stdout, "Device Size: %s%s", tmpstr,
7583                                 (sizeonly == 0) ?  ", " : "\n");
7584                 } else if (numblocks != 0) {
7585                         fprintf(stdout, "%s%ju%s", (quiet == 0) ?
7586                                 "Blocks: " : "", (uintmax_t)maxsector + 1,
7587                                 (sizeonly == 0) ? ", " : "\n");
7588                 } else {
7589                         fprintf(stdout, "%s%ju%s", (quiet == 0) ?
7590                                 "Last Block: " : "", (uintmax_t)maxsector,
7591                                 (sizeonly == 0) ? ", " : "\n");
7592                 }
7593         }
7594         if (sizeonly == 0)
7595                 fprintf(stdout, "%s%u%s\n", (quiet == 0) ?
7596                         "Block Length: " : "", block_len, (quiet == 0) ?
7597                         " bytes" : "");
7598 bailout:
7599         cam_freeccb(ccb);
7600
7601         return (retval);
7602 }
7603
7604 static int
7605 smpcmd(struct cam_device *device, int argc, char **argv, char *combinedopt,
7606        int retry_count, int timeout)
7607 {
7608         int c, error = 0;
7609         union ccb *ccb;
7610         uint8_t *smp_request = NULL, *smp_response = NULL;
7611         int request_size = 0, response_size = 0;
7612         int fd_request = 0, fd_response = 0;
7613         char *datastr = NULL;
7614         struct get_hook hook;
7615         int retval;
7616         int flags = 0;
7617
7618         /*
7619          * Note that at the moment we don't support sending SMP CCBs to
7620          * devices that aren't probed by CAM.
7621          */
7622         ccb = cam_getccb(device);
7623         if (ccb == NULL) {
7624                 warnx("%s: error allocating CCB", __func__);
7625                 return (1);
7626         }
7627
7628         while ((c = getopt(argc, argv, combinedopt)) != -1) {
7629                 switch (c) {
7630                 case 'R':
7631                         arglist |= CAM_ARG_CMD_IN;
7632                         response_size = strtol(optarg, NULL, 0);
7633                         if (response_size <= 0) {
7634                                 warnx("invalid number of response bytes %d",
7635                                       response_size);
7636                                 error = 1;
7637                                 goto smpcmd_bailout;
7638                         }
7639                         hook.argc = argc - optind;
7640                         hook.argv = argv + optind;
7641                         hook.got = 0;
7642                         optind++;
7643                         datastr = cget(&hook, NULL);
7644                         /*
7645                          * If the user supplied "-" instead of a format, he
7646                          * wants the data to be written to stdout.
7647                          */
7648                         if ((datastr != NULL)
7649                          && (datastr[0] == '-'))
7650                                 fd_response = 1;
7651
7652                         smp_response = (u_int8_t *)malloc(response_size);
7653                         if (smp_response == NULL) {
7654                                 warn("can't malloc memory for SMP response");
7655                                 error = 1;
7656                                 goto smpcmd_bailout;
7657                         }
7658                         break;
7659                 case 'r':
7660                         arglist |= CAM_ARG_CMD_OUT;
7661                         request_size = strtol(optarg, NULL, 0);
7662                         if (request_size <= 0) {
7663                                 warnx("invalid number of request bytes %d",
7664                                       request_size);
7665                                 error = 1;
7666                                 goto smpcmd_bailout;
7667                         }
7668                         hook.argc = argc - optind;
7669                         hook.argv = argv + optind;
7670                         hook.got = 0;
7671                         datastr = cget(&hook, NULL);
7672                         smp_request = (u_int8_t *)malloc(request_size);
7673                         if (smp_request == NULL) {
7674                                 warn("can't malloc memory for SMP request");
7675                                 error = 1;
7676                                 goto smpcmd_bailout;
7677                         }
7678                         bzero(smp_request, request_size);
7679                         /*
7680                          * If the user supplied "-" instead of a format, he
7681                          * wants the data to be read from stdin.
7682                          */
7683                         if ((datastr != NULL)
7684                          && (datastr[0] == '-'))
7685                                 fd_request = 1;
7686                         else
7687                                 buff_encode_visit(smp_request, request_size,
7688                                                   datastr,
7689                                                   iget, &hook);
7690                         optind += hook.got;
7691                         break;
7692                 default:
7693                         break;
7694                 }
7695         }
7696
7697         /*
7698          * If fd_data is set, and we're writing to the device, we need to
7699          * read the data the user wants written from stdin.
7700          */
7701         if ((fd_request == 1) && (arglist & CAM_ARG_CMD_OUT)) {
7702                 ssize_t amt_read;
7703                 int amt_to_read = request_size;
7704                 u_int8_t *buf_ptr = smp_request;
7705
7706                 for (amt_read = 0; amt_to_read > 0;
7707                      amt_read = read(STDIN_FILENO, buf_ptr, amt_to_read)) {
7708                         if (amt_read == -1) {
7709                                 warn("error reading data from stdin");
7710                                 error = 1;
7711                                 goto smpcmd_bailout;
7712                         }
7713                         amt_to_read -= amt_read;
7714                         buf_ptr += amt_read;
7715                 }
7716         }
7717
7718         if (((arglist & CAM_ARG_CMD_IN) == 0)
7719          || ((arglist & CAM_ARG_CMD_OUT) == 0)) {
7720                 warnx("%s: need both the request (-r) and response (-R) "
7721                       "arguments", __func__);
7722                 error = 1;
7723                 goto smpcmd_bailout;
7724         }
7725
7726         flags |= CAM_DEV_QFRZDIS;
7727
7728         cam_fill_smpio(&ccb->smpio,
7729                        /*retries*/ retry_count,
7730                        /*cbfcnp*/ NULL,
7731                        /*flags*/ flags,
7732                        /*smp_request*/ smp_request,
7733                        /*smp_request_len*/ request_size,
7734                        /*smp_response*/ smp_response,
7735                        /*smp_response_len*/ response_size,
7736                        /*timeout*/ timeout ? timeout : 5000);
7737
7738         ccb->smpio.flags = SMP_FLAG_NONE;
7739
7740         if (((retval = cam_send_ccb(device, ccb)) < 0)
7741          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7742                 const char warnstr[] = "error sending command";
7743
7744                 if (retval < 0)
7745                         warn(warnstr);
7746                 else
7747                         warnx(warnstr);
7748
7749                 if (arglist & CAM_ARG_VERBOSE) {
7750                         cam_error_print(device, ccb, CAM_ESF_ALL,
7751                                         CAM_EPF_ALL, stderr);
7752                 }
7753         }
7754
7755         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
7756          && (response_size > 0)) {
7757                 if (fd_response == 0) {
7758                         buff_decode_visit(smp_response, response_size,
7759                                           datastr, arg_put, NULL);
7760                         fprintf(stdout, "\n");
7761                 } else {
7762                         ssize_t amt_written;
7763                         int amt_to_write = response_size;
7764                         u_int8_t *buf_ptr = smp_response;
7765
7766                         for (amt_written = 0; (amt_to_write > 0) &&
7767                              (amt_written = write(STDOUT_FILENO, buf_ptr,
7768                                                   amt_to_write)) > 0;){
7769                                 amt_to_write -= amt_written;
7770                                 buf_ptr += amt_written;
7771                         }
7772                         if (amt_written == -1) {
7773                                 warn("error writing data to stdout");
7774                                 error = 1;
7775                                 goto smpcmd_bailout;
7776                         } else if ((amt_written == 0)
7777                                 && (amt_to_write > 0)) {
7778                                 warnx("only wrote %u bytes out of %u",
7779                                       response_size - amt_to_write,
7780                                       response_size);
7781                         }
7782                 }
7783         }
7784 smpcmd_bailout:
7785         if (ccb != NULL)
7786                 cam_freeccb(ccb);
7787
7788         if (smp_request != NULL)
7789                 free(smp_request);
7790
7791         if (smp_response != NULL)
7792                 free(smp_response);
7793
7794         return (error);
7795 }
7796
7797 static int
7798 mmcsdcmd(struct cam_device *device, int argc, char **argv, char *combinedopt,
7799        int retry_count, int timeout)
7800 {
7801         int c, error = 0;
7802         union ccb *ccb;
7803         int32_t mmc_opcode = 0, mmc_arg = 0;
7804         int32_t mmc_flags = -1;
7805         int retval;
7806         int is_write = 0;
7807         int is_bw_4 = 0, is_bw_1 = 0;
7808         int is_frequency = 0;
7809         int is_highspeed = 0, is_stdspeed = 0;
7810         int is_info_request = 0;
7811         int flags = 0;
7812         uint8_t mmc_data_byte = 0;
7813         uint32_t mmc_frequency = 0;
7814
7815         /* For IO_RW_EXTENDED command */
7816         uint8_t *mmc_data = NULL;
7817         struct mmc_data mmc_d;
7818         int mmc_data_len = 0;
7819
7820         /*
7821          * Note that at the moment we don't support sending SMP CCBs to
7822          * devices that aren't probed by CAM.
7823          */
7824         ccb = cam_getccb(device);
7825         if (ccb == NULL) {
7826                 warnx("%s: error allocating CCB", __func__);
7827                 return (1);
7828         }
7829
7830         bzero(&(&ccb->ccb_h)[1],
7831               sizeof(union ccb) - sizeof(struct ccb_hdr));
7832
7833         while ((c = getopt(argc, argv, combinedopt)) != -1) {
7834                 switch (c) {
7835                 case '4':
7836                         is_bw_4 = 1;
7837                         break;
7838                 case '1':
7839                         is_bw_1 = 1;
7840                         break;
7841                 case 'S':
7842                         if (!strcmp(optarg, "high"))
7843                                 is_highspeed = 1;
7844                         else
7845                                 is_stdspeed = 1;
7846                         break;
7847                 case 'I':
7848                         is_info_request = 1;
7849                         break;
7850                 case 'F':
7851                         is_frequency = 1;
7852                         mmc_frequency = strtol(optarg, NULL, 0);
7853                         break;
7854                 case 'c':
7855                         mmc_opcode = strtol(optarg, NULL, 0);
7856                         if (mmc_opcode < 0) {
7857                                 warnx("invalid MMC opcode %d",
7858                                       mmc_opcode);
7859                                 error = 1;
7860                                 goto mmccmd_bailout;
7861                         }
7862                         break;
7863                 case 'a':
7864                         mmc_arg = strtol(optarg, NULL, 0);
7865                         if (mmc_arg < 0) {
7866                                 warnx("invalid MMC arg %d",
7867                                       mmc_arg);
7868                                 error = 1;
7869                                 goto mmccmd_bailout;
7870                         }
7871                         break;
7872                 case 'f':
7873                         mmc_flags = strtol(optarg, NULL, 0);
7874                         if (mmc_flags < 0) {
7875                                 warnx("invalid MMC flags %d",
7876                                       mmc_flags);
7877                                 error = 1;
7878                                 goto mmccmd_bailout;
7879                         }
7880                         break;
7881                 case 'l':
7882                         mmc_data_len = strtol(optarg, NULL, 0);
7883                         if (mmc_data_len <= 0) {
7884                                 warnx("invalid MMC data len %d",
7885                                       mmc_data_len);
7886                                 error = 1;
7887                                 goto mmccmd_bailout;
7888                         }
7889                         break;
7890                 case 'W':
7891                         is_write = 1;
7892                         break;
7893                 case 'b':
7894                         mmc_data_byte = strtol(optarg, NULL, 0);
7895                         break;
7896                 default:
7897                         break;
7898                 }
7899         }
7900         flags |= CAM_DEV_QFRZDIS; /* masks are broken?! */
7901
7902         /* If flags are left default, supply the right flags */
7903         if (mmc_flags < 0)
7904                 switch (mmc_opcode) {
7905                 case MMC_GO_IDLE_STATE:
7906                         mmc_flags = MMC_RSP_NONE | MMC_CMD_BC;
7907                         break;
7908                 case IO_SEND_OP_COND:
7909                         mmc_flags = MMC_RSP_R4;
7910                         break;
7911                 case SD_SEND_RELATIVE_ADDR:
7912                         mmc_flags = MMC_RSP_R6 | MMC_CMD_BCR;
7913                         break;
7914                 case MMC_SELECT_CARD:
7915                         mmc_flags = MMC_RSP_R1B | MMC_CMD_AC;
7916                         mmc_arg = mmc_arg << 16;
7917                         break;
7918                 case SD_IO_RW_DIRECT:
7919                         mmc_flags = MMC_RSP_R5 | MMC_CMD_AC;
7920                         mmc_arg = SD_IO_RW_ADR(mmc_arg);
7921                         if (is_write)
7922                                 mmc_arg |= SD_IO_RW_WR | SD_IO_RW_RAW | SD_IO_RW_DAT(mmc_data_byte);
7923                         break;
7924                 case SD_IO_RW_EXTENDED:
7925                         mmc_flags = MMC_RSP_R5 | MMC_CMD_ADTC;
7926                         mmc_arg = SD_IO_RW_ADR(mmc_arg);
7927                         int len_arg = mmc_data_len;
7928                         if (mmc_data_len == 512)
7929                                 len_arg = 0;
7930
7931                         // Byte mode
7932                         mmc_arg |= SD_IOE_RW_LEN(len_arg) | SD_IO_RW_INCR;
7933                         // Block mode
7934 //                        mmc_arg |= SD_IOE_RW_BLK | SD_IOE_RW_LEN(len_arg) | SD_IO_RW_INCR;
7935                         break;
7936                 default:
7937                         mmc_flags = MMC_RSP_R1;
7938                         break;
7939                 }
7940
7941         // Switch bus width instead of sending IO command
7942         if (is_bw_4 || is_bw_1) {
7943                 struct ccb_trans_settings_mmc *cts;
7944                 ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
7945                 ccb->ccb_h.flags = 0;
7946                 cts = &ccb->cts.proto_specific.mmc;
7947                 cts->ios.bus_width = is_bw_4 == 1 ? bus_width_4 : bus_width_1;
7948                 cts->ios_valid = MMC_BW;
7949                 if (((retval = cam_send_ccb(device, ccb)) < 0)
7950                     || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7951                         warn("Error sending command");
7952                 } else {
7953                         printf("Parameters set OK\n");
7954                 }
7955                 cam_freeccb(ccb);
7956                 return (retval);
7957         }
7958
7959         if (is_frequency) {
7960                 struct ccb_trans_settings_mmc *cts;
7961                 ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
7962                 ccb->ccb_h.flags = 0;
7963                 cts = &ccb->cts.proto_specific.mmc;
7964                 cts->ios.clock = mmc_frequency;
7965                 cts->ios_valid = MMC_CLK;
7966                 if (((retval = cam_send_ccb(device, ccb)) < 0)
7967                     || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7968                         warn("Error sending command");
7969                 } else {
7970                         printf("Parameters set OK\n");
7971                 }
7972                 cam_freeccb(ccb);
7973                 return (retval);
7974         }
7975
7976         // Switch bus speed instead of sending IO command
7977         if (is_stdspeed || is_highspeed) {
7978                 struct ccb_trans_settings_mmc *cts;
7979                 ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
7980                 ccb->ccb_h.flags = 0;
7981                 cts = &ccb->cts.proto_specific.mmc;
7982                 cts->ios.timing = is_highspeed == 1 ? bus_timing_hs : bus_timing_normal;
7983                 cts->ios_valid = MMC_BT;
7984                 if (((retval = cam_send_ccb(device, ccb)) < 0)
7985                     || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7986                         warn("Error sending command");
7987                 } else {
7988                         printf("Speed set OK (HS: %d)\n", is_highspeed);
7989                 }
7990                 cam_freeccb(ccb);
7991                 return (retval);
7992         }
7993
7994         // Get information about controller and its settings
7995         if (is_info_request) {
7996                 ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
7997                 ccb->ccb_h.flags = 0;
7998                 struct ccb_trans_settings_mmc *cts;
7999                 cts = &ccb->cts.proto_specific.mmc;
8000                 if (((retval = cam_send_ccb(device, ccb)) < 0)
8001                     || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
8002                         warn("Error sending command");
8003                         return (retval);
8004                 }
8005                 printf("Host controller information\n");
8006                 printf("Host OCR: 0x%x\n", cts->host_ocr);
8007                 printf("Min frequency: %u KHz\n", cts->host_f_min / 1000);
8008                 printf("Max frequency: %u MHz\n", cts->host_f_max / 1000000);
8009                 printf("Supported bus width:\n");
8010                 if (cts->host_caps & MMC_CAP_4_BIT_DATA)
8011                         printf(" 4 bit\n");
8012                 if (cts->host_caps & MMC_CAP_8_BIT_DATA)
8013                         printf(" 8 bit\n");
8014
8015                 printf("Supported operating modes:\n");
8016                 if (cts->host_caps & MMC_CAP_HSPEED)
8017                         printf(" Can do High Speed transfers\n");
8018                 if (cts->host_caps & MMC_CAP_UHS_SDR12)
8019                         printf(" Can do UHS SDR12\n");
8020                 if (cts->host_caps & MMC_CAP_UHS_SDR25)
8021                         printf(" Can do UHS SDR25\n");
8022                 if (cts->host_caps & MMC_CAP_UHS_SDR50)
8023                         printf(" Can do UHS SDR50\n");
8024                 if (cts->host_caps & MMC_CAP_UHS_SDR104)
8025                         printf(" Can do UHS SDR104\n");
8026                 if (cts->host_caps & MMC_CAP_UHS_DDR50)
8027                         printf(" Can do UHS DDR50\n");
8028                 if (cts->host_caps & MMC_CAP_MMC_DDR52_120)
8029                         printf(" Can do eMMC DDR52 at 1.2V\n");
8030                 if (cts->host_caps & MMC_CAP_MMC_DDR52_180)
8031                         printf(" Can do eMMC DDR52 at 1.8V\n");
8032                 if (cts->host_caps & MMC_CAP_MMC_HS200_120)
8033                         printf(" Can do eMMC HS200 at 1.2V\n");
8034                 if (cts->host_caps & MMC_CAP_MMC_HS200_180)
8035                         printf(" Can do eMMC HS200 at 1.8V\n");
8036                 if (cts->host_caps & MMC_CAP_MMC_HS400_120)
8037                         printf(" Can do eMMC HS400 at 1.2V\n");
8038                 if (cts->host_caps & MMC_CAP_MMC_HS400_180)
8039                         printf(" Can do eMMC HS400 at 1.8V\n");
8040
8041                 printf("Supported VCCQ voltages:\n");
8042                 if (cts->host_caps & MMC_CAP_SIGNALING_120)
8043                         printf(" 1.2V\n");
8044                 if (cts->host_caps & MMC_CAP_SIGNALING_180)
8045                         printf(" 1.8V\n");
8046                 if (cts->host_caps & MMC_CAP_SIGNALING_330)
8047                         printf(" 3.3V\n");
8048
8049                 printf("Current settings:\n");
8050                 printf(" Bus width: ");
8051                 switch (cts->ios.bus_width) {
8052                 case bus_width_1:
8053                         printf("1 bit\n");
8054                         break;
8055                 case bus_width_4:
8056                         printf("4 bit\n");
8057                         break;
8058                 case bus_width_8:
8059                         printf("8 bit\n");
8060                         break;
8061                 }
8062                 printf(" Freq: %d.%03d MHz%s\n",
8063                        cts->ios.clock / 1000000,
8064                        (cts->ios.clock / 1000) % 1000,
8065                        cts->ios.timing == bus_timing_hs ? " (high-speed timing)" : "");
8066
8067                 printf(" VCCQ: ");
8068                 switch (cts->ios.vccq) {
8069                 case vccq_330:
8070                         printf("3.3V\n");
8071                         break;
8072                 case vccq_180:
8073                         printf("1.8V\n");
8074                         break;
8075                 case vccq_120:
8076                         printf("1.2V\n");
8077                         break;
8078                 }
8079                 return (0);
8080         }
8081
8082         printf("CMD %d arg %d flags %02x\n", mmc_opcode, mmc_arg, mmc_flags);
8083
8084         if (mmc_data_len > 0) {
8085                 flags |= CAM_DIR_IN;
8086                 mmc_data = malloc(mmc_data_len);
8087                 memset(mmc_data, 0, mmc_data_len);
8088                 memset(&mmc_d, 0, sizeof(mmc_d));
8089                 mmc_d.len = mmc_data_len;
8090                 mmc_d.data = mmc_data;
8091                 mmc_d.flags = MMC_DATA_READ;
8092         } else flags |= CAM_DIR_NONE;
8093
8094         cam_fill_mmcio(&ccb->mmcio,
8095                        /*retries*/ retry_count,
8096                        /*cbfcnp*/ NULL,
8097                        /*flags*/ flags,
8098                        /*mmc_opcode*/ mmc_opcode,
8099                        /*mmc_arg*/ mmc_arg,
8100                        /*mmc_flags*/ mmc_flags,
8101                        /*mmc_data*/ mmc_data_len > 0 ? &mmc_d : NULL,
8102                        /*timeout*/ timeout ? timeout : 5000);
8103
8104         if (((retval = cam_send_ccb(device, ccb)) < 0)
8105          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
8106                 const char warnstr[] = "error sending command";
8107
8108                 if (retval < 0)
8109                         warn(warnstr);
8110                 else
8111                         warnx(warnstr);
8112
8113                 if (arglist & CAM_ARG_VERBOSE) {
8114                         cam_error_print(device, ccb, CAM_ESF_ALL,
8115                                         CAM_EPF_ALL, stderr);
8116                 }
8117         }
8118
8119         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)) {
8120                 printf("MMCIO: error %d, %08x %08x %08x %08x\n",
8121                        ccb->mmcio.cmd.error, ccb->mmcio.cmd.resp[0],
8122                        ccb->mmcio.cmd.resp[1],
8123                        ccb->mmcio.cmd.resp[2],
8124                        ccb->mmcio.cmd.resp[3]);
8125
8126                 switch (mmc_opcode) {
8127                 case SD_IO_RW_DIRECT:
8128                         printf("IO_RW_DIRECT: resp byte %02x, cur state %d\n",
8129                                SD_R5_DATA(ccb->mmcio.cmd.resp),
8130                                (ccb->mmcio.cmd.resp[0] >> 12) & 0x3);
8131                         break;
8132                 case SD_IO_RW_EXTENDED:
8133                         printf("IO_RW_EXTENDED: read %d bytes w/o error:\n", mmc_data_len);
8134                         hexdump(mmc_data, mmc_data_len, NULL, 0);
8135                         break;
8136                 case SD_SEND_RELATIVE_ADDR:
8137                         printf("SEND_RELATIVE_ADDR: published RCA %02x\n", ccb->mmcio.cmd.resp[0] >> 16);
8138                         break;
8139                 default:
8140                         printf("No command-specific decoder for CMD %d\n", mmc_opcode);
8141                 }
8142         }
8143 mmccmd_bailout:
8144         if (ccb != NULL)
8145                 cam_freeccb(ccb);
8146
8147         if (mmc_data_len > 0 && mmc_data != NULL)
8148                 free(mmc_data);
8149
8150         return (error);
8151 }
8152
8153 static int
8154 smpreportgeneral(struct cam_device *device, int argc, char **argv,
8155                  char *combinedopt, int retry_count, int timeout)
8156 {
8157         union ccb *ccb;
8158         struct smp_report_general_request *request = NULL;
8159         struct smp_report_general_response *response = NULL;
8160         struct sbuf *sb = NULL;
8161         int error = 0;
8162         int c, long_response = 0;
8163         int retval;
8164
8165         /*
8166          * Note that at the moment we don't support sending SMP CCBs to
8167          * devices that aren't probed by CAM.
8168          */
8169         ccb = cam_getccb(device);
8170         if (ccb == NULL) {
8171                 warnx("%s: error allocating CCB", __func__);
8172                 return (1);
8173         }
8174
8175         while ((c = getopt(argc, argv, combinedopt)) != -1) {
8176                 switch (c) {
8177                 case 'l':
8178                         long_response = 1;
8179                         break;
8180                 default:
8181                         break;
8182                 }
8183         }
8184         request = malloc(sizeof(*request));
8185         if (request == NULL) {
8186                 warn("%s: unable to allocate %zd bytes", __func__,
8187                      sizeof(*request));
8188                 error = 1;
8189                 goto bailout;
8190         }
8191
8192         response = malloc(sizeof(*response));
8193         if (response == NULL) {
8194                 warn("%s: unable to allocate %zd bytes", __func__,
8195                      sizeof(*response));
8196                 error = 1;
8197                 goto bailout;
8198         }
8199
8200 try_long:
8201         smp_report_general(&ccb->smpio,
8202                            retry_count,
8203                            /*cbfcnp*/ NULL,
8204                            request,
8205                            /*request_len*/ sizeof(*request),
8206                            (uint8_t *)response,
8207                            /*response_len*/ sizeof(*response),
8208                            /*long_response*/ long_response,
8209                            timeout);
8210
8211         if (((retval = cam_send_ccb(device, ccb)) < 0)
8212          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
8213                 const char warnstr[] = "error sending command";
8214
8215                 if (retval < 0)
8216                         warn(warnstr);
8217                 else
8218                         warnx(warnstr);
8219
8220                 if (arglist & CAM_ARG_VERBOSE) {
8221                         cam_error_print(device, ccb, CAM_ESF_ALL,
8222                                         CAM_EPF_ALL, stderr);
8223                 }
8224                 error = 1;
8225                 goto bailout;
8226         }
8227
8228         /*
8229          * If the device supports the long response bit, try again and see
8230          * if we can get all of the data.
8231          */
8232         if ((response->long_response & SMP_RG_LONG_RESPONSE)
8233          && (long_response == 0)) {
8234                 ccb->ccb_h.status = CAM_REQ_INPROG;
8235                 CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
8236                 long_response = 1;
8237                 goto try_long;
8238         }
8239
8240         /*
8241          * XXX KDM detect and decode SMP errors here.
8242          */
8243         sb = sbuf_new_auto();
8244         if (sb == NULL) {
8245                 warnx("%s: error allocating sbuf", __func__);
8246                 goto bailout;
8247         }
8248
8249         smp_report_general_sbuf(response, sizeof(*response), sb);
8250
8251         if (sbuf_finish(sb) != 0) {
8252                 warnx("%s: sbuf_finish", __func__);
8253                 goto bailout;
8254         }
8255
8256         printf("%s", sbuf_data(sb));
8257
8258 bailout:
8259         if (ccb != NULL)
8260                 cam_freeccb(ccb);
8261
8262         if (request != NULL)
8263                 free(request);
8264
8265         if (response != NULL)
8266                 free(response);
8267
8268         if (sb != NULL)
8269                 sbuf_delete(sb);
8270
8271         return (error);
8272 }
8273
8274 static struct camcontrol_opts phy_ops[] = {
8275         {"nop", SMP_PC_PHY_OP_NOP, CAM_ARG_NONE, NULL},
8276         {"linkreset", SMP_PC_PHY_OP_LINK_RESET, CAM_ARG_NONE, NULL},
8277         {"hardreset", SMP_PC_PHY_OP_HARD_RESET, CAM_ARG_NONE, NULL},
8278         {"disable", SMP_PC_PHY_OP_DISABLE, CAM_ARG_NONE, NULL},
8279         {"clearerrlog", SMP_PC_PHY_OP_CLEAR_ERR_LOG, CAM_ARG_NONE, NULL},
8280         {"clearaffiliation", SMP_PC_PHY_OP_CLEAR_AFFILIATON, CAM_ARG_NONE,NULL},
8281         {"sataportsel", SMP_PC_PHY_OP_TRANS_SATA_PSS, CAM_ARG_NONE, NULL},
8282         {"clearitnl", SMP_PC_PHY_OP_CLEAR_STP_ITN_LS, CAM_ARG_NONE, NULL},
8283         {"setdevname", SMP_PC_PHY_OP_SET_ATT_DEV_NAME, CAM_ARG_NONE, NULL},
8284         {NULL, 0, 0, NULL}
8285 };
8286
8287 static int
8288 smpphycontrol(struct cam_device *device, int argc, char **argv,
8289               char *combinedopt, int retry_count, int timeout)
8290 {
8291         union ccb *ccb;
8292         struct smp_phy_control_request *request = NULL;
8293         struct smp_phy_control_response *response = NULL;
8294         int long_response = 0;
8295         int retval = 0;
8296         int phy = -1;
8297         uint32_t phy_operation = SMP_PC_PHY_OP_NOP;
8298         int phy_op_set = 0;
8299         uint64_t attached_dev_name = 0;
8300         int dev_name_set = 0;
8301         uint32_t min_plr = 0, max_plr = 0;
8302         uint32_t pp_timeout_val = 0;
8303         int slumber_partial = 0;
8304         int set_pp_timeout_val = 0;
8305         int c;
8306
8307         /*
8308          * Note that at the moment we don't support sending SMP CCBs to
8309          * devices that aren't probed by CAM.
8310          */
8311         ccb = cam_getccb(device);
8312         if (ccb == NULL) {
8313                 warnx("%s: error allocating CCB", __func__);
8314                 return (1);
8315         }
8316
8317         while ((c = getopt(argc, argv, combinedopt)) != -1) {
8318                 switch (c) {
8319                 case 'a':
8320                 case 'A':
8321                 case 's':
8322                 case 'S': {
8323                         int enable = -1;
8324
8325                         if (strcasecmp(optarg, "enable") == 0)
8326                                 enable = 1;
8327                         else if (strcasecmp(optarg, "disable") == 0)
8328                                 enable = 2;
8329                         else {
8330                                 warnx("%s: Invalid argument %s", __func__,
8331                                       optarg);
8332                                 retval = 1;
8333                                 goto bailout;
8334                         }
8335                         switch (c) {
8336                         case 's':
8337                                 slumber_partial |= enable <<
8338                                                    SMP_PC_SAS_SLUMBER_SHIFT;
8339                                 break;
8340                         case 'S':
8341                                 slumber_partial |= enable <<
8342                                                    SMP_PC_SAS_PARTIAL_SHIFT;
8343                                 break;
8344                         case 'a':
8345                                 slumber_partial |= enable <<
8346                                                    SMP_PC_SATA_SLUMBER_SHIFT;
8347                                 break;
8348                         case 'A':
8349                                 slumber_partial |= enable <<
8350                                                    SMP_PC_SATA_PARTIAL_SHIFT;
8351                                 break;
8352                         default:
8353                                 warnx("%s: programmer error", __func__);
8354                                 retval = 1;
8355                                 goto bailout;
8356                                 break; /*NOTREACHED*/
8357                         }
8358                         break;
8359                 }
8360                 case 'd':
8361                         attached_dev_name = (uintmax_t)strtoumax(optarg,
8362                                                                  NULL,0);
8363                         dev_name_set = 1;
8364                         break;
8365                 case 'l':
8366                         long_response = 1;
8367                         break;
8368                 case 'm':
8369                         /*
8370                          * We don't do extensive checking here, so this
8371                          * will continue to work when new speeds come out.
8372                          */
8373                         min_plr = strtoul(optarg, NULL, 0);
8374                         if ((min_plr == 0)
8375                          || (min_plr > 0xf)) {
8376                                 warnx("%s: invalid link rate %x",
8377                                       __func__, min_plr);
8378                                 retval = 1;
8379                                 goto bailout;
8380                         }
8381                         break;
8382                 case 'M':
8383                         /*
8384                          * We don't do extensive checking here, so this
8385                          * will continue to work when new speeds come out.
8386                          */
8387                         max_plr = strtoul(optarg, NULL, 0);
8388                         if ((max_plr == 0)
8389                          || (max_plr > 0xf)) {
8390                                 warnx("%s: invalid link rate %x",
8391                                       __func__, max_plr);
8392                                 retval = 1;
8393                                 goto bailout;
8394                         }
8395                         break;
8396                 case 'o': {
8397                         camcontrol_optret optreturn;
8398                         cam_argmask argnums;
8399                         const char *subopt;
8400
8401                         if (phy_op_set != 0) {
8402                                 warnx("%s: only one phy operation argument "
8403                                       "(-o) allowed", __func__);
8404                                 retval = 1;
8405                                 goto bailout;
8406                         }
8407
8408                         phy_op_set = 1;
8409
8410                         /*
8411                          * Allow the user to specify the phy operation
8412                          * numerically, as well as with a name.  This will
8413                          * future-proof it a bit, so options that are added
8414                          * in future specs can be used.
8415                          */
8416                         if (isdigit(optarg[0])) {
8417                                 phy_operation = strtoul(optarg, NULL, 0);
8418                                 if ((phy_operation == 0)
8419                                  || (phy_operation > 0xff)) {
8420                                         warnx("%s: invalid phy operation %#x",
8421                                               __func__, phy_operation);
8422                                         retval = 1;
8423                                         goto bailout;
8424                                 }
8425                                 break;
8426                         }
8427                         optreturn = getoption(phy_ops, optarg, &phy_operation,
8428                                               &argnums, &subopt);
8429
8430                         if (optreturn == CC_OR_AMBIGUOUS) {
8431                                 warnx("%s: ambiguous option %s", __func__,
8432                                       optarg);
8433                                 usage(0);
8434                                 retval = 1;
8435                                 goto bailout;
8436                         } else if (optreturn == CC_OR_NOT_FOUND) {
8437                                 warnx("%s: option %s not found", __func__,
8438                                       optarg);
8439                                 usage(0);
8440                                 retval = 1;
8441                                 goto bailout;
8442                         }
8443                         break;
8444                 }
8445                 case 'p':
8446                         phy = atoi(optarg);
8447                         break;
8448                 case 'T':
8449                         pp_timeout_val = strtoul(optarg, NULL, 0);
8450                         if (pp_timeout_val > 15) {
8451                                 warnx("%s: invalid partial pathway timeout "
8452                                       "value %u, need a value less than 16",
8453                                       __func__, pp_timeout_val);
8454                                 retval = 1;
8455                                 goto bailout;
8456                         }
8457                         set_pp_timeout_val = 1;
8458                         break;
8459                 default:
8460                         break;
8461                 }
8462         }
8463
8464         if (phy == -1) {
8465                 warnx("%s: a PHY (-p phy) argument is required",__func__);
8466                 retval = 1;
8467                 goto bailout;
8468         }
8469
8470         if (((dev_name_set != 0)
8471           && (phy_operation != SMP_PC_PHY_OP_SET_ATT_DEV_NAME))
8472          || ((phy_operation == SMP_PC_PHY_OP_SET_ATT_DEV_NAME)
8473           && (dev_name_set == 0))) {
8474                 warnx("%s: -d name and -o setdevname arguments both "
8475                       "required to set device name", __func__);
8476                 retval = 1;
8477                 goto bailout;
8478         }
8479
8480         request = malloc(sizeof(*request));
8481         if (request == NULL) {
8482                 warn("%s: unable to allocate %zd bytes", __func__,
8483                      sizeof(*request));
8484                 retval = 1;
8485                 goto bailout;
8486         }
8487
8488         response = malloc(sizeof(*response));
8489         if (response == NULL) {
8490                 warn("%s: unable to allocate %zd bytes", __func__,
8491                      sizeof(*response));
8492                 retval = 1;
8493                 goto bailout;
8494         }
8495
8496         smp_phy_control(&ccb->smpio,
8497                         retry_count,
8498                         /*cbfcnp*/ NULL,
8499                         request,
8500                         sizeof(*request),
8501                         (uint8_t *)response,
8502                         sizeof(*response),
8503                         long_response,
8504                         /*expected_exp_change_count*/ 0,
8505                         phy,
8506                         phy_operation,
8507                         (set_pp_timeout_val != 0) ? 1 : 0,
8508                         attached_dev_name,
8509                         min_plr,
8510                         max_plr,
8511                         slumber_partial,
8512                         pp_timeout_val,
8513                         timeout);
8514
8515         if (((retval = cam_send_ccb(device, ccb)) < 0)
8516          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
8517                 const char warnstr[] = "error sending command";
8518
8519                 if (retval < 0)
8520                         warn(warnstr);
8521                 else
8522                         warnx(warnstr);
8523
8524                 if (arglist & CAM_ARG_VERBOSE) {
8525                         /*
8526                          * Use CAM_EPF_NORMAL so we only get one line of
8527                          * SMP command decoding.
8528                          */
8529                         cam_error_print(device, ccb, CAM_ESF_ALL,
8530                                         CAM_EPF_NORMAL, stderr);
8531                 }
8532                 retval = 1;
8533                 goto bailout;
8534         }
8535
8536         /* XXX KDM print out something here for success? */
8537 bailout:
8538         if (ccb != NULL)
8539                 cam_freeccb(ccb);
8540
8541         if (request != NULL)
8542                 free(request);
8543
8544         if (response != NULL)
8545                 free(response);
8546
8547         return (retval);
8548 }
8549
8550 static int
8551 smpmaninfo(struct cam_device *device, int argc, char **argv,
8552            char *combinedopt, int retry_count, int timeout)
8553 {
8554         union ccb *ccb;
8555         struct smp_report_manuf_info_request request;
8556         struct smp_report_manuf_info_response response;
8557         struct sbuf *sb = NULL;
8558         int long_response = 0;
8559         int retval = 0;
8560         int c;
8561
8562         /*
8563          * Note that at the moment we don't support sending SMP CCBs to
8564          * devices that aren't probed by CAM.
8565          */
8566         ccb = cam_getccb(device);
8567         if (ccb == NULL) {
8568                 warnx("%s: error allocating CCB", __func__);
8569                 return (1);
8570         }
8571
8572         while ((c = getopt(argc, argv, combinedopt)) != -1) {
8573                 switch (c) {
8574                 case 'l':
8575                         long_response = 1;
8576                         break;
8577                 default:
8578                         break;
8579                 }
8580         }
8581         bzero(&request, sizeof(request));
8582         bzero(&response, sizeof(response));
8583
8584         smp_report_manuf_info(&ccb->smpio,
8585                               retry_count,
8586                               /*cbfcnp*/ NULL,
8587                               &request,
8588                               sizeof(request),
8589                               (uint8_t *)&response,
8590                               sizeof(response),
8591                               long_response,
8592                               timeout);
8593
8594         if (((retval = cam_send_ccb(device, ccb)) < 0)
8595          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
8596                 const char warnstr[] = "error sending command";
8597
8598                 if (retval < 0)
8599                         warn(warnstr);
8600                 else
8601                         warnx(warnstr);
8602
8603                 if (arglist & CAM_ARG_VERBOSE) {
8604                         cam_error_print(device, ccb, CAM_ESF_ALL,
8605                                         CAM_EPF_ALL, stderr);
8606                 }
8607                 retval = 1;
8608                 goto bailout;
8609         }
8610
8611         sb = sbuf_new_auto();
8612         if (sb == NULL) {
8613                 warnx("%s: error allocating sbuf", __func__);
8614                 goto bailout;
8615         }
8616
8617         smp_report_manuf_info_sbuf(&response, sizeof(response), sb);
8618
8619         if (sbuf_finish(sb) != 0) {
8620                 warnx("%s: sbuf_finish", __func__);
8621                 goto bailout;
8622         }
8623
8624         printf("%s", sbuf_data(sb));
8625
8626 bailout:
8627
8628         if (ccb != NULL)
8629                 cam_freeccb(ccb);
8630
8631         if (sb != NULL)
8632                 sbuf_delete(sb);
8633
8634         return (retval);
8635 }
8636
8637 static int
8638 getdevid(struct cam_devitem *item)
8639 {
8640         int retval = 0;
8641         union ccb *ccb = NULL;
8642
8643         struct cam_device *dev;
8644
8645         dev = cam_open_btl(item->dev_match.path_id,
8646                            item->dev_match.target_id,
8647                            item->dev_match.target_lun, O_RDWR, NULL);
8648
8649         if (dev == NULL) {
8650                 warnx("%s", cam_errbuf);
8651                 retval = 1;
8652                 goto bailout;
8653         }
8654
8655         item->device_id_len = 0;
8656
8657         ccb = cam_getccb(dev);
8658         if (ccb == NULL) {
8659                 warnx("%s: error allocating CCB", __func__);
8660                 retval = 1;
8661                 goto bailout;
8662         }
8663
8664         /*
8665          * On the first try, we just probe for the size of the data, and
8666          * then allocate that much memory and try again.
8667          */
8668 retry:
8669         ccb->ccb_h.func_code = XPT_DEV_ADVINFO;
8670         ccb->ccb_h.flags = CAM_DIR_IN;
8671         ccb->cdai.flags = CDAI_FLAG_NONE;
8672         ccb->cdai.buftype = CDAI_TYPE_SCSI_DEVID;
8673         ccb->cdai.bufsiz = item->device_id_len;
8674         if (item->device_id_len != 0)
8675                 ccb->cdai.buf = (uint8_t *)item->device_id;
8676
8677         if (cam_send_ccb(dev, ccb) < 0) {
8678                 warn("%s: error sending XPT_GDEV_ADVINFO CCB", __func__);
8679                 retval = 1;
8680                 goto bailout;
8681         }
8682
8683         if (ccb->ccb_h.status != CAM_REQ_CMP) {
8684                 warnx("%s: CAM status %#x", __func__, ccb->ccb_h.status);
8685                 retval = 1;
8686                 goto bailout;
8687         }
8688
8689         if (item->device_id_len == 0) {
8690                 /*
8691                  * This is our first time through.  Allocate the buffer,
8692                  * and then go back to get the data.
8693                  */
8694                 if (ccb->cdai.provsiz == 0) {
8695                         warnx("%s: invalid .provsiz field returned with "
8696                              "XPT_GDEV_ADVINFO CCB", __func__);
8697                         retval = 1;
8698                         goto bailout;
8699                 }
8700                 item->device_id_len = ccb->cdai.provsiz;
8701                 item->device_id = malloc(item->device_id_len);
8702                 if (item->device_id == NULL) {
8703                         warn("%s: unable to allocate %d bytes", __func__,
8704                              item->device_id_len);
8705                         retval = 1;
8706                         goto bailout;
8707                 }
8708                 ccb->ccb_h.status = CAM_REQ_INPROG;
8709                 goto retry;
8710         }
8711
8712 bailout:
8713         if (dev != NULL)
8714                 cam_close_device(dev);
8715
8716         if (ccb != NULL)
8717                 cam_freeccb(ccb);
8718
8719         return (retval);
8720 }
8721
8722 /*
8723  * XXX KDM merge this code with getdevtree()?
8724  */
8725 static int
8726 buildbusdevlist(struct cam_devlist *devlist)
8727 {
8728         union ccb ccb;
8729         int bufsize, fd = -1;
8730         struct dev_match_pattern *patterns;
8731         struct cam_devitem *item = NULL;
8732         int skip_device = 0;
8733         int retval = 0;
8734
8735         if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
8736                 warn("couldn't open %s", XPT_DEVICE);
8737                 return (1);
8738         }
8739
8740         bzero(&ccb, sizeof(union ccb));
8741
8742         ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
8743         ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
8744         ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
8745
8746         ccb.ccb_h.func_code = XPT_DEV_MATCH;
8747         bufsize = sizeof(struct dev_match_result) * 100;
8748         ccb.cdm.match_buf_len = bufsize;
8749         ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
8750         if (ccb.cdm.matches == NULL) {
8751                 warnx("can't malloc memory for matches");
8752                 close(fd);
8753                 return (1);
8754         }
8755         ccb.cdm.num_matches = 0;
8756         ccb.cdm.num_patterns = 2;
8757         ccb.cdm.pattern_buf_len = sizeof(struct dev_match_pattern) *
8758                 ccb.cdm.num_patterns;
8759
8760         patterns = (struct dev_match_pattern *)malloc(ccb.cdm.pattern_buf_len);
8761         if (patterns == NULL) {
8762                 warnx("can't malloc memory for patterns");
8763                 retval = 1;
8764                 goto bailout;
8765         }
8766
8767         ccb.cdm.patterns = patterns;
8768         bzero(patterns, ccb.cdm.pattern_buf_len);
8769
8770         patterns[0].type = DEV_MATCH_DEVICE;
8771         patterns[0].pattern.device_pattern.flags = DEV_MATCH_PATH;
8772         patterns[0].pattern.device_pattern.path_id = devlist->path_id;
8773         patterns[1].type = DEV_MATCH_PERIPH;
8774         patterns[1].pattern.periph_pattern.flags = PERIPH_MATCH_PATH;
8775         patterns[1].pattern.periph_pattern.path_id = devlist->path_id;
8776
8777         /*
8778          * We do the ioctl multiple times if necessary, in case there are
8779          * more than 100 nodes in the EDT.
8780          */
8781         do {
8782                 unsigned int i;
8783
8784                 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
8785                         warn("error sending CAMIOCOMMAND ioctl");
8786                         retval = 1;
8787                         goto bailout;
8788                 }
8789
8790                 if ((ccb.ccb_h.status != CAM_REQ_CMP)
8791                  || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
8792                     && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
8793                         warnx("got CAM error %#x, CDM error %d\n",
8794                               ccb.ccb_h.status, ccb.cdm.status);
8795                         retval = 1;
8796                         goto bailout;
8797                 }
8798
8799                 for (i = 0; i < ccb.cdm.num_matches; i++) {
8800                         switch (ccb.cdm.matches[i].type) {
8801                         case DEV_MATCH_DEVICE: {
8802                                 struct device_match_result *dev_result;
8803
8804                                 dev_result =
8805                                      &ccb.cdm.matches[i].result.device_result;
8806
8807                                 if (dev_result->flags &
8808                                     DEV_RESULT_UNCONFIGURED) {
8809                                         skip_device = 1;
8810                                         break;
8811                                 } else
8812                                         skip_device = 0;
8813
8814                                 item = malloc(sizeof(*item));
8815                                 if (item == NULL) {
8816                                         warn("%s: unable to allocate %zd bytes",
8817                                              __func__, sizeof(*item));
8818                                         retval = 1;
8819                                         goto bailout;
8820                                 }
8821                                 bzero(item, sizeof(*item));
8822                                 bcopy(dev_result, &item->dev_match,
8823                                       sizeof(*dev_result));
8824                                 STAILQ_INSERT_TAIL(&devlist->dev_queue, item,
8825                                                    links);
8826
8827                                 if (getdevid(item) != 0) {
8828                                         retval = 1;
8829                                         goto bailout;
8830                                 }
8831                                 break;
8832                         }
8833                         case DEV_MATCH_PERIPH: {
8834                                 struct periph_match_result *periph_result;
8835
8836                                 periph_result =
8837                                       &ccb.cdm.matches[i].result.periph_result;
8838
8839                                 if (skip_device != 0)
8840                                         break;
8841                                 item->num_periphs++;
8842                                 item->periph_matches = realloc(
8843                                         item->periph_matches,
8844                                         item->num_periphs *
8845                                         sizeof(struct periph_match_result));
8846                                 if (item->periph_matches == NULL) {
8847                                         warn("%s: error allocating periph "
8848                                              "list", __func__);
8849                                         retval = 1;
8850                                         goto bailout;
8851                                 }
8852                                 bcopy(periph_result, &item->periph_matches[
8853                                       item->num_periphs - 1],
8854                                       sizeof(*periph_result));
8855                                 break;
8856                         }
8857                         default:
8858                                 fprintf(stderr, "%s: unexpected match "
8859                                         "type %d\n", __func__,
8860                                         ccb.cdm.matches[i].type);
8861                                 retval = 1;
8862                                 goto bailout;
8863                                 break; /*NOTREACHED*/
8864                         }
8865                 }
8866         } while ((ccb.ccb_h.status == CAM_REQ_CMP)
8867                 && (ccb.cdm.status == CAM_DEV_MATCH_MORE));
8868 bailout:
8869
8870         if (fd != -1)
8871                 close(fd);
8872
8873         free(patterns);
8874
8875         free(ccb.cdm.matches);
8876
8877         if (retval != 0)
8878                 freebusdevlist(devlist);
8879
8880         return (retval);
8881 }
8882
8883 static void
8884 freebusdevlist(struct cam_devlist *devlist)
8885 {
8886         struct cam_devitem *item, *item2;
8887
8888         STAILQ_FOREACH_SAFE(item, &devlist->dev_queue, links, item2) {
8889                 STAILQ_REMOVE(&devlist->dev_queue, item, cam_devitem,
8890                               links);
8891                 free(item->device_id);
8892                 free(item->periph_matches);
8893                 free(item);
8894         }
8895 }
8896
8897 static struct cam_devitem *
8898 findsasdevice(struct cam_devlist *devlist, uint64_t sasaddr)
8899 {
8900         struct cam_devitem *item;
8901
8902         STAILQ_FOREACH(item, &devlist->dev_queue, links) {
8903                 struct scsi_vpd_id_descriptor *idd;
8904
8905                 /*
8906                  * XXX KDM look for LUN IDs as well?
8907                  */
8908                 idd = scsi_get_devid(item->device_id,
8909                                            item->device_id_len,
8910                                            scsi_devid_is_sas_target);
8911                 if (idd == NULL)
8912                         continue;
8913
8914                 if (scsi_8btou64(idd->identifier) == sasaddr)
8915                         return (item);
8916         }
8917
8918         return (NULL);
8919 }
8920
8921 static int
8922 smpphylist(struct cam_device *device, int argc, char **argv,
8923            char *combinedopt, int retry_count, int timeout)
8924 {
8925         struct smp_report_general_request *rgrequest = NULL;
8926         struct smp_report_general_response *rgresponse = NULL;
8927         struct smp_discover_request *disrequest = NULL;
8928         struct smp_discover_response *disresponse = NULL;
8929         struct cam_devlist devlist;
8930         union ccb *ccb;
8931         int long_response = 0;
8932         int num_phys = 0;
8933         int quiet = 0;
8934         int retval;
8935         int i, c;
8936
8937         /*
8938          * Note that at the moment we don't support sending SMP CCBs to
8939          * devices that aren't probed by CAM.
8940          */
8941         ccb = cam_getccb(device);
8942         if (ccb == NULL) {
8943                 warnx("%s: error allocating CCB", __func__);
8944                 return (1);
8945         }
8946
8947         STAILQ_INIT(&devlist.dev_queue);
8948
8949         rgrequest = malloc(sizeof(*rgrequest));
8950         if (rgrequest == NULL) {
8951                 warn("%s: unable to allocate %zd bytes", __func__,
8952                      sizeof(*rgrequest));
8953                 retval = 1;
8954                 goto bailout;
8955         }
8956
8957         rgresponse = malloc(sizeof(*rgresponse));
8958         if (rgresponse == NULL) {
8959                 warn("%s: unable to allocate %zd bytes", __func__,
8960                      sizeof(*rgresponse));
8961                 retval = 1;
8962                 goto bailout;
8963         }
8964
8965         while ((c = getopt(argc, argv, combinedopt)) != -1) {
8966                 switch (c) {
8967                 case 'l':
8968                         long_response = 1;
8969                         break;
8970                 case 'q':
8971                         quiet = 1;
8972                         break;
8973                 default:
8974                         break;
8975                 }
8976         }
8977
8978         smp_report_general(&ccb->smpio,
8979                            retry_count,
8980                            /*cbfcnp*/ NULL,
8981                            rgrequest,
8982                            /*request_len*/ sizeof(*rgrequest),
8983                            (uint8_t *)rgresponse,
8984                            /*response_len*/ sizeof(*rgresponse),
8985                            /*long_response*/ long_response,
8986                            timeout);
8987
8988         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
8989
8990         if (((retval = cam_send_ccb(device, ccb)) < 0)
8991          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
8992                 const char warnstr[] = "error sending command";
8993
8994                 if (retval < 0)
8995                         warn(warnstr);
8996                 else
8997                         warnx(warnstr);
8998
8999                 if (arglist & CAM_ARG_VERBOSE) {
9000                         cam_error_print(device, ccb, CAM_ESF_ALL,
9001                                         CAM_EPF_ALL, stderr);
9002                 }
9003                 retval = 1;
9004                 goto bailout;
9005         }
9006
9007         num_phys = rgresponse->num_phys;
9008
9009         if (num_phys == 0) {
9010                 if (quiet == 0)
9011                         fprintf(stdout, "%s: No Phys reported\n", __func__);
9012                 retval = 1;
9013                 goto bailout;
9014         }
9015
9016         devlist.path_id = device->path_id;
9017
9018         retval = buildbusdevlist(&devlist);
9019         if (retval != 0)
9020                 goto bailout;
9021
9022         if (quiet == 0) {
9023                 fprintf(stdout, "%d PHYs:\n", num_phys);
9024                 fprintf(stdout, "PHY  Attached SAS Address\n");
9025         }
9026
9027         disrequest = malloc(sizeof(*disrequest));
9028         if (disrequest == NULL) {
9029                 warn("%s: unable to allocate %zd bytes", __func__,
9030                      sizeof(*disrequest));
9031                 retval = 1;
9032                 goto bailout;
9033         }
9034
9035         disresponse = malloc(sizeof(*disresponse));
9036         if (disresponse == NULL) {
9037                 warn("%s: unable to allocate %zd bytes", __func__,
9038                      sizeof(*disresponse));
9039                 retval = 1;
9040                 goto bailout;
9041         }
9042
9043         for (i = 0; i < num_phys; i++) {
9044                 struct cam_devitem *item;
9045                 struct device_match_result *dev_match;
9046                 char vendor[16], product[48], revision[16];
9047                 char tmpstr[256];
9048                 int j;
9049
9050                 CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
9051
9052                 ccb->ccb_h.status = CAM_REQ_INPROG;
9053                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
9054
9055                 smp_discover(&ccb->smpio,
9056                              retry_count,
9057                              /*cbfcnp*/ NULL,
9058                              disrequest,
9059                              sizeof(*disrequest),
9060                              (uint8_t *)disresponse,
9061                              sizeof(*disresponse),
9062                              long_response,
9063                              /*ignore_zone_group*/ 0,
9064                              /*phy*/ i,
9065                              timeout);
9066
9067                 if (((retval = cam_send_ccb(device, ccb)) < 0)
9068                  || (((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)
9069                   && (disresponse->function_result != SMP_FR_PHY_VACANT))) {
9070                         const char warnstr[] = "error sending command";
9071
9072                         if (retval < 0)
9073                                 warn(warnstr);
9074                         else
9075                                 warnx(warnstr);
9076
9077                         if (arglist & CAM_ARG_VERBOSE) {
9078                                 cam_error_print(device, ccb, CAM_ESF_ALL,
9079                                                 CAM_EPF_ALL, stderr);
9080                         }
9081                         retval = 1;
9082                         goto bailout;
9083                 }
9084
9085                 if (disresponse->function_result == SMP_FR_PHY_VACANT) {
9086                         if (quiet == 0)
9087                                 fprintf(stdout, "%3d  <vacant>\n", i);
9088                         continue;
9089                 }
9090
9091                 if (disresponse->attached_device == SMP_DIS_AD_TYPE_NONE) {
9092                         item = NULL;
9093                 } else {
9094                         item = findsasdevice(&devlist,
9095                             scsi_8btou64(disresponse->attached_sas_address));
9096                 }
9097
9098                 if ((quiet == 0)
9099                  || (item != NULL)) {
9100                         fprintf(stdout, "%3d  0x%016jx", i,
9101                                 (uintmax_t)scsi_8btou64(
9102                                 disresponse->attached_sas_address));
9103                         if (item == NULL) {
9104                                 fprintf(stdout, "\n");
9105                                 continue;
9106                         }
9107                 } else if (quiet != 0)
9108                         continue;
9109
9110                 dev_match = &item->dev_match;
9111
9112                 if (dev_match->protocol == PROTO_SCSI) {
9113                         cam_strvis(vendor, dev_match->inq_data.vendor,
9114                                    sizeof(dev_match->inq_data.vendor),
9115                                    sizeof(vendor));
9116                         cam_strvis(product, dev_match->inq_data.product,
9117                                    sizeof(dev_match->inq_data.product),
9118                                    sizeof(product));
9119                         cam_strvis(revision, dev_match->inq_data.revision,
9120                                    sizeof(dev_match->inq_data.revision),
9121                                    sizeof(revision));
9122                         sprintf(tmpstr, "<%s %s %s>", vendor, product,
9123                                 revision);
9124                 } else if ((dev_match->protocol == PROTO_ATA)
9125                         || (dev_match->protocol == PROTO_SATAPM)) {
9126                         cam_strvis(product, dev_match->ident_data.model,
9127                                    sizeof(dev_match->ident_data.model),
9128                                    sizeof(product));
9129                         cam_strvis(revision, dev_match->ident_data.revision,
9130                                    sizeof(dev_match->ident_data.revision),
9131                                    sizeof(revision));
9132                         sprintf(tmpstr, "<%s %s>", product, revision);
9133                 } else {
9134                         sprintf(tmpstr, "<>");
9135                 }
9136                 fprintf(stdout, "   %-33s ", tmpstr);
9137
9138                 /*
9139                  * If we have 0 periphs, that's a bug...
9140                  */
9141                 if (item->num_periphs == 0) {
9142                         fprintf(stdout, "\n");
9143                         continue;
9144                 }
9145
9146                 fprintf(stdout, "(");
9147                 for (j = 0; j < item->num_periphs; j++) {
9148                         if (j > 0)
9149                                 fprintf(stdout, ",");
9150
9151                         fprintf(stdout, "%s%d",
9152                                 item->periph_matches[j].periph_name,
9153                                 item->periph_matches[j].unit_number);
9154
9155                 }
9156                 fprintf(stdout, ")\n");
9157         }
9158 bailout:
9159         if (ccb != NULL)
9160                 cam_freeccb(ccb);
9161
9162         free(rgrequest);
9163
9164         free(rgresponse);
9165
9166         free(disrequest);
9167
9168         free(disresponse);
9169
9170         freebusdevlist(&devlist);
9171
9172         return (retval);
9173 }
9174
9175 static int
9176 atapm_proc_resp(struct cam_device *device, union ccb *ccb)
9177 {
9178         uint8_t error = 0, ata_device = 0, status = 0;
9179         uint16_t count = 0;
9180         uint64_t lba = 0;
9181         int retval;
9182
9183         retval = get_ata_status(device, ccb, &error, &count, &lba, &ata_device,
9184             &status);
9185         if (retval == 1) {
9186                 if (arglist & CAM_ARG_VERBOSE) {
9187                         cam_error_print(device, ccb, CAM_ESF_ALL,
9188                                         CAM_EPF_ALL, stderr);
9189                 }
9190                 warnx("Can't get ATA command status");
9191                 return (retval);
9192         }
9193
9194         if (status & ATA_STATUS_ERROR) {
9195                 cam_error_print(device, ccb, CAM_ESF_ALL,
9196                     CAM_EPF_ALL, stderr);
9197                 return (1);
9198         }
9199
9200         printf("%s%d: ", device->device_name, device->dev_unit_num);
9201         switch (count) {
9202         case 0x00:
9203                 printf("Standby mode\n");
9204                 break;
9205         case 0x01:
9206                 printf("Standby_y mode\n");
9207                 break;
9208         case 0x40:
9209                 printf("NV Cache Power Mode and the spindle is spun down or spinning down\n");
9210                 break;
9211         case 0x41:
9212                 printf("NV Cache Power Mode and the spindle is spun up or spinning up\n");
9213                 break;
9214         case 0x80:
9215                 printf("Idle mode\n");
9216                 break;
9217         case 0x81:
9218                 printf("Idle_a mode\n");
9219                 break;
9220         case 0x82:
9221                 printf("Idle_b mode\n");
9222                 break;
9223         case 0x83:
9224                 printf("Idle_c mode\n");
9225                 break;
9226         case 0xff:
9227                 printf("Active or Idle mode\n");
9228                 break;
9229         default:
9230                 printf("Unknown mode 0x%02x\n", count);
9231                 break;
9232         }
9233
9234         return (0);
9235 }
9236
9237 static int
9238 atapm(struct cam_device *device, int argc, char **argv,
9239                  char *combinedopt, int retry_count, int timeout)
9240 {
9241         union ccb *ccb;
9242         int retval = 0;
9243         int t = -1;
9244         int c;
9245         u_int8_t ata_flags = 0;
9246         u_char cmd, sc;
9247
9248         ccb = cam_getccb(device);
9249
9250         if (ccb == NULL) {
9251                 warnx("%s: error allocating ccb", __func__);
9252                 return (1);
9253         }
9254
9255         while ((c = getopt(argc, argv, combinedopt)) != -1) {
9256                 switch (c) {
9257                 case 't':
9258                         t = atoi(optarg);
9259                         break;
9260                 default:
9261                         break;
9262                 }
9263         }
9264         if (strcmp(argv[1], "idle") == 0) {
9265                 if (t == -1)
9266                         cmd = ATA_IDLE_IMMEDIATE;
9267                 else
9268                         cmd = ATA_IDLE_CMD;
9269         } else if (strcmp(argv[1], "standby") == 0) {
9270                 if (t == -1)
9271                         cmd = ATA_STANDBY_IMMEDIATE;
9272                 else
9273                         cmd = ATA_STANDBY_CMD;
9274         } else if (strcmp(argv[1], "powermode") == 0) {
9275                 cmd = ATA_CHECK_POWER_MODE;
9276                 ata_flags = AP_FLAG_CHK_COND;
9277                 t = -1;
9278         } else {
9279                 cmd = ATA_SLEEP;
9280                 t = -1;
9281         }
9282
9283         if (t < 0)
9284                 sc = 0;
9285         else if (t <= (240 * 5))
9286                 sc = (t + 4) / 5;
9287         else if (t <= (252 * 5))
9288                 /* special encoding for 21 minutes */
9289                 sc = 252;
9290         else if (t <= (11 * 30 * 60))
9291                 sc = (t - 1) / (30 * 60) + 241;
9292         else
9293                 sc = 253;
9294
9295         retval = ata_do_cmd(device,
9296             ccb,
9297             /*retries*/retry_count,
9298             /*flags*/CAM_DIR_NONE,
9299             /*protocol*/AP_PROTO_NON_DATA,
9300             /*ata_flags*/ata_flags,
9301             /*tag_action*/MSG_SIMPLE_Q_TAG,
9302             /*command*/cmd,
9303             /*features*/0,
9304             /*lba*/0,
9305             /*sector_count*/sc,
9306             /*data_ptr*/NULL,
9307             /*dxfer_len*/0,
9308             /*timeout*/timeout ? timeout : 30 * 1000,
9309             /*force48bit*/0);
9310
9311         cam_freeccb(ccb);
9312
9313         if (retval || cmd != ATA_CHECK_POWER_MODE)
9314                 return (retval);
9315
9316         return (atapm_proc_resp(device, ccb));
9317 }
9318
9319 static int
9320 ataaxm(struct cam_device *device, int argc, char **argv,
9321                  char *combinedopt, int retry_count, int timeout)
9322 {
9323         union ccb *ccb;
9324         int retval = 0;
9325         int l = -1;
9326         int c;
9327         u_char cmd, sc;
9328
9329         ccb = cam_getccb(device);
9330
9331         if (ccb == NULL) {
9332                 warnx("%s: error allocating ccb", __func__);
9333                 return (1);
9334         }
9335
9336         while ((c = getopt(argc, argv, combinedopt)) != -1) {
9337                 switch (c) {
9338                 case 'l':
9339                         l = atoi(optarg);
9340                         break;
9341                 default:
9342                         break;
9343                 }
9344         }
9345         sc = 0;
9346         if (strcmp(argv[1], "apm") == 0) {
9347                 if (l == -1)
9348                         cmd = 0x85;
9349                 else {
9350                         cmd = 0x05;
9351                         sc = l;
9352                 }
9353         } else /* aam */ {
9354                 if (l == -1)
9355                         cmd = 0xC2;
9356                 else {
9357                         cmd = 0x42;
9358                         sc = l;
9359                 }
9360         }
9361
9362         retval = ata_do_cmd(device,
9363             ccb,
9364             /*retries*/retry_count,
9365             /*flags*/CAM_DIR_NONE,
9366             /*protocol*/AP_PROTO_NON_DATA,
9367             /*ata_flags*/0,
9368             /*tag_action*/MSG_SIMPLE_Q_TAG,
9369             /*command*/ATA_SETFEATURES,
9370             /*features*/cmd,
9371             /*lba*/0,
9372             /*sector_count*/sc,
9373             /*data_ptr*/NULL,
9374             /*dxfer_len*/0,
9375             /*timeout*/timeout ? timeout : 30 * 1000,
9376             /*force48bit*/0);
9377
9378         cam_freeccb(ccb);
9379         return (retval);
9380 }
9381
9382 int
9383 scsigetopcodes(struct cam_device *device, int opcode_set, int opcode,
9384                int show_sa_errors, int sa_set, int service_action,
9385                int timeout_desc, int task_attr, int retry_count, int timeout,
9386                int verbosemode, uint32_t *fill_len, uint8_t **data_ptr)
9387 {
9388         union ccb *ccb = NULL;
9389         uint8_t *buf = NULL;
9390         uint32_t alloc_len = 0, num_opcodes;
9391         uint32_t valid_len = 0;
9392         uint32_t avail_len = 0;
9393         struct scsi_report_supported_opcodes_all *all_hdr;
9394         struct scsi_report_supported_opcodes_one *one;
9395         int options = 0;
9396         int retval = 0;
9397
9398         /*
9399          * Make it clear that we haven't yet allocated or filled anything.
9400          */
9401         *fill_len = 0;
9402         *data_ptr = NULL;
9403
9404         ccb = cam_getccb(device);
9405         if (ccb == NULL) {
9406                 warnx("couldn't allocate CCB");
9407                 retval = 1;
9408                 goto bailout;
9409         }
9410
9411         if (opcode_set != 0) {
9412                 options |= RSO_OPTIONS_OC;
9413                 num_opcodes = 1;
9414                 alloc_len = sizeof(*one) + CAM_MAX_CDBLEN;
9415         } else {
9416                 num_opcodes = 256;
9417                 alloc_len = sizeof(*all_hdr) + (num_opcodes *
9418                     sizeof(struct scsi_report_supported_opcodes_descr));
9419         }
9420
9421         if (timeout_desc != 0) {
9422                 options |= RSO_RCTD;
9423                 alloc_len += num_opcodes *
9424                     sizeof(struct scsi_report_supported_opcodes_timeout);
9425         }
9426
9427         if (sa_set != 0) {
9428                 options |= RSO_OPTIONS_OC_SA;
9429                 if (show_sa_errors != 0)
9430                         options &= ~RSO_OPTIONS_OC;
9431         }
9432
9433 retry_alloc:
9434         if (buf != NULL) {
9435                 free(buf);
9436                 buf = NULL;
9437         }
9438
9439         buf = malloc(alloc_len);
9440         if (buf == NULL) {
9441                 warn("Unable to allocate %u bytes", alloc_len);
9442                 retval = 1;
9443                 goto bailout;
9444         }
9445         bzero(buf, alloc_len);
9446
9447         scsi_report_supported_opcodes(&ccb->csio,
9448                                       /*retries*/ retry_count,
9449                                       /*cbfcnp*/ NULL,
9450                                       /*tag_action*/ task_attr,
9451                                       /*options*/ options,
9452                                       /*req_opcode*/ opcode,
9453                                       /*req_service_action*/ service_action,
9454                                       /*data_ptr*/ buf,
9455                                       /*dxfer_len*/ alloc_len,
9456                                       /*sense_len*/ SSD_FULL_SIZE,
9457                                       /*timeout*/ timeout ? timeout : 10000);
9458
9459         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
9460
9461         if (retry_count != 0)
9462                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
9463
9464         if (cam_send_ccb(device, ccb) < 0) {
9465                 warn("error sending REPORT SUPPORTED OPERATION CODES command");
9466                 retval = 1;
9467                 goto bailout;
9468         }
9469
9470         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
9471                 if (verbosemode != 0)
9472                         cam_error_print(device, ccb, CAM_ESF_ALL,
9473                                         CAM_EPF_ALL, stderr);
9474                 retval = 1;
9475                 goto bailout;
9476         }
9477
9478         valid_len = ccb->csio.dxfer_len - ccb->csio.resid;
9479
9480         if (((options & RSO_OPTIONS_MASK) == RSO_OPTIONS_ALL)
9481          && (valid_len >= sizeof(*all_hdr))) {
9482                 all_hdr = (struct scsi_report_supported_opcodes_all *)buf;
9483                 avail_len = scsi_4btoul(all_hdr->length) + sizeof(*all_hdr);
9484         } else if (((options & RSO_OPTIONS_MASK) != RSO_OPTIONS_ALL)
9485                 && (valid_len >= sizeof(*one))) {
9486                 uint32_t cdb_length;
9487
9488                 one = (struct scsi_report_supported_opcodes_one *)buf;
9489                 cdb_length = scsi_2btoul(one->cdb_length);
9490                 avail_len = sizeof(*one) + cdb_length;
9491                 if (one->support & RSO_ONE_CTDP) {
9492                         struct scsi_report_supported_opcodes_timeout *td;
9493
9494                         td = (struct scsi_report_supported_opcodes_timeout *)
9495                             &buf[avail_len];
9496                         if (valid_len >= (avail_len + sizeof(td->length))) {
9497                                 avail_len += scsi_2btoul(td->length) +
9498                                     sizeof(td->length);
9499                         } else {
9500                                 avail_len += sizeof(*td);
9501                         }
9502                 }
9503         }
9504
9505         /*
9506          * avail_len could be zero if we didn't get enough data back from
9507          * thet target to determine
9508          */
9509         if ((avail_len != 0)
9510          && (avail_len > valid_len)) {
9511                 alloc_len = avail_len;
9512                 goto retry_alloc;
9513         }
9514
9515         *fill_len = valid_len;
9516         *data_ptr = buf;
9517 bailout:
9518         if (retval != 0)
9519                 free(buf);
9520
9521         cam_freeccb(ccb);
9522
9523         return (retval);
9524 }
9525
9526 static int
9527 scsiprintoneopcode(struct cam_device *device, int req_opcode, int sa_set,
9528                    int req_sa, uint8_t *buf, uint32_t valid_len)
9529 {
9530         struct scsi_report_supported_opcodes_one *one;
9531         struct scsi_report_supported_opcodes_timeout *td;
9532         uint32_t cdb_len = 0, td_len = 0;
9533         const char *op_desc = NULL;
9534         unsigned int i;
9535         int retval = 0;
9536
9537         one = (struct scsi_report_supported_opcodes_one *)buf;
9538
9539         /*
9540          * If we don't have the full single opcode descriptor, no point in
9541          * continuing.
9542          */
9543         if (valid_len < __offsetof(struct scsi_report_supported_opcodes_one,
9544             cdb_length)) {
9545                 warnx("Only %u bytes returned, not enough to verify support",
9546                       valid_len);
9547                 retval = 1;
9548                 goto bailout;
9549         }
9550
9551         op_desc = scsi_op_desc(req_opcode, &device->inq_data);
9552
9553         printf("%s (0x%02x)", op_desc != NULL ? op_desc : "UNKNOWN",
9554                req_opcode);
9555         if (sa_set != 0)
9556                 printf(", SA 0x%x", req_sa);
9557         printf(": ");
9558
9559         switch (one->support & RSO_ONE_SUP_MASK) {
9560         case RSO_ONE_SUP_UNAVAIL:
9561                 printf("No command support information currently available\n");
9562                 break;
9563         case RSO_ONE_SUP_NOT_SUP:
9564                 printf("Command not supported\n");
9565                 retval = 1;
9566                 goto bailout;
9567                 break; /*NOTREACHED*/
9568         case RSO_ONE_SUP_AVAIL:
9569                 printf("Command is supported, complies with a SCSI standard\n");
9570                 break;
9571         case RSO_ONE_SUP_VENDOR:
9572                 printf("Command is supported, vendor-specific "
9573                        "implementation\n");
9574                 break;
9575         default:
9576                 printf("Unknown command support flags 0x%#x\n",
9577                        one->support & RSO_ONE_SUP_MASK);
9578                 break;
9579         }
9580
9581         /*
9582          * If we don't have the CDB length, it isn't exactly an error, the
9583          * command probably isn't supported.
9584          */
9585         if (valid_len < __offsetof(struct scsi_report_supported_opcodes_one,
9586             cdb_usage))
9587                 goto bailout;
9588
9589         cdb_len = scsi_2btoul(one->cdb_length);
9590
9591         /*
9592          * If our valid data doesn't include the full reported length,
9593          * return.  The caller should have detected this and adjusted his
9594          * allocation length to get all of the available data.
9595          */
9596         if (valid_len < sizeof(*one) + cdb_len) {
9597                 retval = 1;
9598                 goto bailout;
9599         }
9600
9601         /*
9602          * If all we have is the opcode, there is no point in printing out
9603          * the usage bitmap.
9604          */
9605         if (cdb_len <= 1) {
9606                 retval = 1;
9607                 goto bailout;
9608         }
9609
9610         printf("CDB usage bitmap:");
9611         for (i = 0; i < cdb_len; i++) {
9612                 printf(" %02x", one->cdb_usage[i]);
9613         }
9614         printf("\n");
9615
9616         /*
9617          * If we don't have a timeout descriptor, we're done.
9618          */
9619         if ((one->support & RSO_ONE_CTDP) == 0)
9620                 goto bailout;
9621
9622         /*
9623          * If we don't have enough valid length to include the timeout
9624          * descriptor length, we're done.
9625          */
9626         if (valid_len < (sizeof(*one) + cdb_len + sizeof(td->length)))
9627                 goto bailout;
9628
9629         td = (struct scsi_report_supported_opcodes_timeout *)
9630             &buf[sizeof(*one) + cdb_len];
9631         td_len = scsi_2btoul(td->length);
9632         td_len += sizeof(td->length);
9633
9634         /*
9635          * If we don't have the full timeout descriptor, we're done.
9636          */
9637         if (td_len < sizeof(*td))
9638                 goto bailout;
9639
9640         /*
9641          * If we don't have enough valid length to contain the full timeout
9642          * descriptor, we're done.
9643          */
9644         if (valid_len < (sizeof(*one) + cdb_len + td_len))
9645                 goto bailout;
9646
9647         printf("Timeout information:\n");
9648         printf("Command-specific:    0x%02x\n", td->cmd_specific);
9649         printf("Nominal timeout:     %u seconds\n",
9650                scsi_4btoul(td->nominal_time));
9651         printf("Recommended timeout: %u seconds\n",
9652                scsi_4btoul(td->recommended_time));
9653
9654 bailout:
9655         return (retval);
9656 }
9657
9658 static int
9659 scsiprintopcodes(struct cam_device *device, int td_req, uint8_t *buf,
9660                  uint32_t valid_len)
9661 {
9662         struct scsi_report_supported_opcodes_all *hdr;
9663         struct scsi_report_supported_opcodes_descr *desc;
9664         uint32_t avail_len = 0, used_len = 0;
9665         uint8_t *cur_ptr;
9666         int retval = 0;
9667
9668         if (valid_len < sizeof(*hdr)) {
9669                 warnx("%s: not enough returned data (%u bytes) opcode list",
9670                       __func__, valid_len);
9671                 retval = 1;
9672                 goto bailout;
9673         }
9674         hdr = (struct scsi_report_supported_opcodes_all *)buf;
9675         avail_len = scsi_4btoul(hdr->length);
9676         avail_len += sizeof(hdr->length);
9677         /*
9678          * Take the lesser of the amount of data the drive claims is
9679          * available, and the amount of data the HBA says was returned.
9680          */
9681         avail_len = MIN(avail_len, valid_len);
9682
9683         used_len = sizeof(hdr->length);
9684
9685         printf("%-6s %4s %8s ",
9686                "Opcode", "SA", "CDB len" );
9687
9688         if (td_req != 0)
9689                 printf("%5s %6s %6s ", "CS", "Nom", "Rec");
9690         printf(" Description\n");
9691
9692         while ((avail_len - used_len) > sizeof(*desc)) {
9693                 struct scsi_report_supported_opcodes_timeout *td;
9694                 uint32_t td_len;
9695                 const char *op_desc = NULL;
9696
9697                 cur_ptr = &buf[used_len];
9698                 desc = (struct scsi_report_supported_opcodes_descr *)cur_ptr;
9699
9700                 op_desc = scsi_op_desc(desc->opcode, &device->inq_data);
9701                 if (op_desc == NULL)
9702                         op_desc = "UNKNOWN";
9703
9704                 printf("0x%02x   %#4x %8u ", desc->opcode,
9705                        scsi_2btoul(desc->service_action),
9706                        scsi_2btoul(desc->cdb_length));
9707
9708                 used_len += sizeof(*desc);
9709
9710                 if ((desc->flags & RSO_CTDP) == 0) {
9711                         printf(" %s\n", op_desc);
9712                         continue;
9713                 }
9714
9715                 /*
9716                  * If we don't have enough space to fit a timeout
9717                  * descriptor, then we're done.
9718                  */
9719                 if (avail_len - used_len < sizeof(*td)) {
9720                         used_len = avail_len;
9721                         printf(" %s\n", op_desc);
9722                         continue;
9723                 }
9724                 cur_ptr = &buf[used_len];
9725                 td = (struct scsi_report_supported_opcodes_timeout *)cur_ptr;
9726                 td_len = scsi_2btoul(td->length);
9727                 td_len += sizeof(td->length);
9728
9729                 used_len += td_len;
9730                 /*
9731                  * If the given timeout descriptor length is less than what
9732                  * we understand, skip it.
9733                  */
9734                 if (td_len < sizeof(*td)) {
9735                         printf(" %s\n", op_desc);
9736                         continue;
9737                 }
9738
9739                 printf(" 0x%02x %6u %6u  %s\n", td->cmd_specific,
9740                        scsi_4btoul(td->nominal_time),
9741                        scsi_4btoul(td->recommended_time), op_desc);
9742         }
9743 bailout:
9744         return (retval);
9745 }
9746
9747 static int
9748 scsiopcodes(struct cam_device *device, int argc, char **argv,
9749             char *combinedopt, int task_attr, int retry_count, int timeout,
9750             int verbosemode)
9751 {
9752         int c;
9753         uint32_t opcode = 0, service_action = 0;
9754         int td_set = 0, opcode_set = 0, sa_set = 0;
9755         int show_sa_errors = 1;
9756         uint32_t valid_len = 0;
9757         uint8_t *buf = NULL;
9758         char *endptr;
9759         int retval = 0;
9760
9761         while ((c = getopt(argc, argv, combinedopt)) != -1) {
9762                 switch (c) {
9763                 case 'N':
9764                         show_sa_errors = 0;
9765                         break;
9766                 case 'o':
9767                         opcode = strtoul(optarg, &endptr, 0);
9768                         if (*endptr != '\0') {
9769                                 warnx("Invalid opcode \"%s\", must be a number",
9770                                       optarg);
9771                                 retval = 1;
9772                                 goto bailout;
9773                         }
9774                         if (opcode > 0xff) {
9775                                 warnx("Invalid opcode 0x%#x, must be between"
9776                                       "0 and 0xff inclusive", opcode);
9777                                 retval = 1;
9778                                 goto bailout;
9779                         }
9780                         opcode_set = 1;
9781                         break;
9782                 case 's':
9783                         service_action = strtoul(optarg, &endptr, 0);
9784                         if (*endptr != '\0') {
9785                                 warnx("Invalid service action \"%s\", must "
9786                                       "be a number", optarg);
9787                                 retval = 1;
9788                                 goto bailout;
9789                         }
9790                         if (service_action > 0xffff) {
9791                                 warnx("Invalid service action 0x%#x, must "
9792                                       "be between 0 and 0xffff inclusive",
9793                                       service_action);
9794                                 retval = 1;
9795                         }
9796                         sa_set = 1;
9797                         break;
9798                 case 'T':
9799                         td_set = 1;
9800                         break;
9801                 default:
9802                         break;
9803                 }
9804         }
9805
9806         if ((sa_set != 0)
9807          && (opcode_set == 0)) {
9808                 warnx("You must specify an opcode with -o if a service "
9809                       "action is given");
9810                 retval = 1;
9811                 goto bailout;
9812         }
9813         retval = scsigetopcodes(device, opcode_set, opcode, show_sa_errors,
9814                                 sa_set, service_action, td_set, task_attr,
9815                                 retry_count, timeout, verbosemode, &valid_len,
9816                                 &buf);
9817         if (retval != 0)
9818                 goto bailout;
9819
9820         if ((opcode_set != 0)
9821          || (sa_set != 0)) {
9822                 retval = scsiprintoneopcode(device, opcode, sa_set,
9823                                             service_action, buf, valid_len);
9824         } else {
9825                 retval = scsiprintopcodes(device, td_set, buf, valid_len);
9826         }
9827
9828 bailout:
9829         free(buf);
9830
9831         return (retval);
9832 }
9833
9834
9835 static int
9836 reprobe(struct cam_device *device)
9837 {
9838         union ccb *ccb;
9839         int retval = 0;
9840
9841         ccb = cam_getccb(device);
9842
9843         if (ccb == NULL) {
9844                 warnx("%s: error allocating ccb", __func__);
9845                 return (1);
9846         }
9847
9848         ccb->ccb_h.func_code = XPT_REPROBE_LUN;
9849
9850         if (cam_send_ccb(device, ccb) < 0) {
9851                 warn("error sending XPT_REPROBE_LUN CCB");
9852                 retval = 1;
9853                 goto bailout;
9854         }
9855
9856         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
9857                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
9858                 retval = 1;
9859                 goto bailout;
9860         }
9861
9862 bailout:
9863         cam_freeccb(ccb);
9864
9865         return (retval);
9866 }
9867
9868 void
9869 usage(int printlong)
9870 {
9871
9872         fprintf(printlong ? stdout : stderr,
9873 "usage:  camcontrol <command>  [device id][generic args][command args]\n"
9874 "        camcontrol devlist    [-b] [-v]\n"
9875 "        camcontrol periphlist [dev_id][-n dev_name] [-u unit]\n"
9876 "        camcontrol tur        [dev_id][generic args]\n"
9877 "        camcontrol inquiry    [dev_id][generic args] [-D] [-S] [-R]\n"
9878 "        camcontrol identify   [dev_id][generic args] [-v]\n"
9879 "        camcontrol reportluns [dev_id][generic args] [-c] [-l] [-r report]\n"
9880 "        camcontrol readcap    [dev_id][generic args] [-b] [-h] [-H] [-N]\n"
9881 "                              [-q] [-s] [-l]\n"
9882 "        camcontrol start      [dev_id][generic args]\n"
9883 "        camcontrol stop       [dev_id][generic args]\n"
9884 "        camcontrol load       [dev_id][generic args]\n"
9885 "        camcontrol eject      [dev_id][generic args]\n"
9886 "        camcontrol reprobe    [dev_id][generic args]\n"
9887 "        camcontrol rescan     <all | bus[:target:lun] | dev_id>\n"
9888 "        camcontrol reset      <all | bus[:target:lun] | dev_id>\n"
9889 "        camcontrol defects    [dev_id][generic args] <-f format> [-P][-G]\n"
9890 "                              [-q][-s][-S offset][-X]\n"
9891 "        camcontrol modepage   [dev_id][generic args] <-m page | -l>\n"
9892 "                              [-P pagectl][-e | -b][-d]\n"
9893 "        camcontrol cmd        [dev_id][generic args]\n"
9894 "                              <-a cmd [args] | -c cmd [args]>\n"
9895 "                              [-d] [-f] [-i len fmt|-o len fmt [args]] [-r fmt]\n"
9896 "        camcontrol smpcmd     [dev_id][generic args]\n"
9897 "                              <-r len fmt [args]> <-R len fmt [args]>\n"
9898 "        camcontrol smprg      [dev_id][generic args][-l]\n"
9899 "        camcontrol smppc      [dev_id][generic args] <-p phy> [-l]\n"
9900 "                              [-o operation][-d name][-m rate][-M rate]\n"
9901 "                              [-T pp_timeout][-a enable|disable]\n"
9902 "                              [-A enable|disable][-s enable|disable]\n"
9903 "                              [-S enable|disable]\n"
9904 "        camcontrol smpphylist [dev_id][generic args][-l][-q]\n"
9905 "        camcontrol smpmaninfo [dev_id][generic args][-l]\n"
9906 "        camcontrol debug      [-I][-P][-T][-S][-X][-c]\n"
9907 "                              <all|dev_id|bus[:target[:lun]]|off>\n"
9908 "        camcontrol tags       [dev_id][generic args] [-N tags] [-q] [-v]\n"
9909 "        camcontrol negotiate  [dev_id][generic args] [-a][-c]\n"
9910 "                              [-D <enable|disable>][-M mode][-O offset]\n"
9911 "                              [-q][-R syncrate][-v][-T <enable|disable>]\n"
9912 "                              [-U][-W bus_width]\n"
9913 "        camcontrol format     [dev_id][generic args][-q][-r][-w][-y]\n"
9914 "        camcontrol sanitize   [dev_id][generic args]\n"
9915 "                              [-a overwrite|block|crypto|exitfailure]\n"
9916 "                              [-c passes][-I][-P pattern][-q][-U][-r][-w]\n"
9917 "                              [-y]\n"
9918 "        camcontrol idle       [dev_id][generic args][-t time]\n"
9919 "        camcontrol standby    [dev_id][generic args][-t time]\n"
9920 "        camcontrol sleep      [dev_id][generic args]\n"
9921 "        camcontrol powermode  [dev_id][generic args]\n"
9922 "        camcontrol apm        [dev_id][generic args][-l level]\n"
9923 "        camcontrol aam        [dev_id][generic args][-l level]\n"
9924 "        camcontrol fwdownload [dev_id][generic args] <-f fw_image> [-q]\n"
9925 "                              [-s][-y]\n"
9926 "        camcontrol security   [dev_id][generic args]\n"
9927 "                              <-d pwd | -e pwd | -f | -h pwd | -k pwd>\n"
9928 "                              [-l <high|maximum>] [-q] [-s pwd] [-T timeout]\n"
9929 "                              [-U <user|master>] [-y]\n"
9930 "        camcontrol hpa        [dev_id][generic args] [-f] [-l] [-P] [-p pwd]\n"
9931 "                              [-q] [-s max_sectors] [-U pwd] [-y]\n"
9932 "        camcontrol ama        [dev_id][generic args] [-f] [-q] [-s max_sectors]\n"
9933 "        camcontrol persist    [dev_id][generic args] <-i action|-o action>\n"
9934 "                              [-a][-I tid][-k key][-K sa_key][-p][-R rtp]\n"
9935 "                              [-s scope][-S][-T type][-U]\n"
9936 "        camcontrol attrib     [dev_id][generic args] <-r action|-w attr>\n"
9937 "                              [-a attr_num][-c][-e elem][-F form1,form1]\n"
9938 "                              [-p part][-s start][-T type][-V vol]\n"
9939 "        camcontrol opcodes    [dev_id][generic args][-o opcode][-s SA]\n"
9940 "                              [-N][-T]\n"
9941 "        camcontrol zone       [dev_id][generic args]<-c cmd> [-a] [-l LBA]\n"
9942 "                              [-o rep_opts] [-P print_opts]\n"
9943 "        camcontrol epc        [dev_id][generic_args]<-c cmd> [-d] [-D] [-e]\n"
9944 "                              [-H] [-p power_cond] [-P] [-r rst_src] [-s]\n"
9945 "                              [-S power_src] [-T timer]\n"
9946 "        camcontrol timestamp  [dev_id][generic_args] <-r [-f format|-m|-U]>|\n"
9947 "                              <-s <-f format -T time | -U >>\n"
9948 "        camcontrol devtype    [dev_id]\n"
9949 "        camcontrol mmcsdcmd   [dev_id] [[-c mmc_opcode] [-a mmc_arg]\n"
9950 "                                  [-f mmc_flags] [-l data_len]\n"
9951 "                                  [-W [-b data_byte]]] |\n"
9952 "                              [-F frequency] |\n"
9953 "                              [-I]\n"
9954 "                              [-1 | -4]\n"
9955 "                              [-S high|normal]\n"
9956 "                              \n"
9957 "        camcontrol help\n");
9958         if (!printlong)
9959                 return;
9960         fprintf(stdout,
9961 "Specify one of the following options:\n"
9962 "devlist     list all CAM devices\n"
9963 "periphlist  list all CAM peripheral drivers attached to a device\n"
9964 "tur         send a test unit ready to the named device\n"
9965 "inquiry     send a SCSI inquiry command to the named device\n"
9966 "identify    send a ATA identify command to the named device\n"
9967 "reportluns  send a SCSI report luns command to the device\n"
9968 "readcap     send a SCSI read capacity command to the device\n"
9969 "start       send a Start Unit command to the device\n"
9970 "stop        send a Stop Unit command to the device\n"
9971 "load        send a Start Unit command to the device with the load bit set\n"
9972 "eject       send a Stop Unit command to the device with the eject bit set\n"
9973 "reprobe     update capacity information of the given device\n"
9974 "rescan      rescan all buses, the given bus, bus:target:lun or device\n"
9975 "reset       reset all buses, the given bus, bus:target:lun or device\n"
9976 "defects     read the defect list of the specified device\n"
9977 "modepage    display or edit (-e) the given mode page\n"
9978 "cmd         send the given SCSI command, may need -i or -o as well\n"
9979 "smpcmd      send the given SMP command, requires -o and -i\n"
9980 "smprg       send the SMP Report General command\n"
9981 "smppc       send the SMP PHY Control command, requires -p\n"
9982 "smpphylist  display phys attached to a SAS expander\n"
9983 "smpmaninfo  send the SMP Report Manufacturer Info command\n"
9984 "debug       turn debugging on/off for a bus, target, or lun, or all devices\n"
9985 "tags        report or set the number of transaction slots for a device\n"
9986 "negotiate   report or set device negotiation parameters\n"
9987 "format      send the SCSI FORMAT UNIT command to the named device\n"
9988 "sanitize    send the SCSI SANITIZE command to the named device\n"
9989 "idle        send the ATA IDLE command to the named device\n"
9990 "standby     send the ATA STANDBY command to the named device\n"
9991 "sleep       send the ATA SLEEP command to the named device\n"
9992 "powermode   send the ATA CHECK POWER MODE command to the named device\n"
9993 "fwdownload  program firmware of the named device with the given image\n"
9994 "security    report or send ATA security commands to the named device\n"
9995 "persist     send the SCSI PERSISTENT RESERVE IN or OUT commands\n"
9996 "attrib      send the SCSI READ or WRITE ATTRIBUTE commands\n"
9997 "opcodes     send the SCSI REPORT SUPPORTED OPCODES command\n"
9998 "zone        manage Zoned Block (Shingled) devices\n"
9999 "epc         send ATA Extended Power Conditions commands\n"
10000 "timestamp   report or set the device's timestamp\n"
10001 "devtype     report the type of device\n"
10002 "mmcsdcmd    send the given MMC command, needs -c and -a as well\n"
10003 "help        this message\n"
10004 "Device Identifiers:\n"
10005 "bus:target        specify the bus and target, lun defaults to 0\n"
10006 "bus:target:lun    specify the bus, target and lun\n"
10007 "deviceUNIT        specify the device name, like \"da4\" or \"cd2\"\n"
10008 "Generic arguments:\n"
10009 "-v                be verbose, print out sense information\n"
10010 "-t timeout        command timeout in seconds, overrides default timeout\n"
10011 "-n dev_name       specify device name, e.g. \"da\", \"cd\"\n"
10012 "-u unit           specify unit number, e.g. \"0\", \"5\"\n"
10013 "-E                have the kernel attempt to perform SCSI error recovery\n"
10014 "-C count          specify the SCSI command retry count (needs -E to work)\n"
10015 "-Q task_attr      specify ordered, simple or head tag type for SCSI cmds\n"
10016 "modepage arguments:\n"
10017 "-l                list all available mode pages\n"
10018 "-m page           specify the mode page to view or edit\n"
10019 "-e                edit the specified mode page\n"
10020 "-b                force view to binary mode\n"
10021 "-d                disable block descriptors for mode sense\n"
10022 "-P pgctl          page control field 0-3\n"
10023 "defects arguments:\n"
10024 "-f format         specify defect list format (block, bfi or phys)\n"
10025 "-G                get the grown defect list\n"
10026 "-P                get the permanent defect list\n"
10027 "inquiry arguments:\n"
10028 "-D                get the standard inquiry data\n"
10029 "-S                get the serial number\n"
10030 "-R                get the transfer rate, etc.\n"
10031 "reportluns arguments:\n"
10032 "-c                only report a count of available LUNs\n"
10033 "-l                only print out luns, and not a count\n"
10034 "-r <reporttype>   specify \"default\", \"wellknown\" or \"all\"\n"
10035 "readcap arguments\n"
10036 "-b                only report the blocksize\n"
10037 "-h                human readable device size, base 2\n"
10038 "-H                human readable device size, base 10\n"
10039 "-N                print the number of blocks instead of last block\n"
10040 "-q                quiet, print numbers only\n"
10041 "-s                only report the last block/device size\n"
10042 "cmd arguments:\n"
10043 "-c cdb [args]     specify the SCSI CDB\n"
10044 "-i len fmt        specify input data and input data format\n"
10045 "-o len fmt [args] specify output data and output data fmt\n"
10046 "smpcmd arguments:\n"
10047 "-r len fmt [args] specify the SMP command to be sent\n"
10048 "-R len fmt [args] specify SMP response format\n"
10049 "smprg arguments:\n"
10050 "-l                specify the long response format\n"
10051 "smppc arguments:\n"
10052 "-p phy            specify the PHY to operate on\n"
10053 "-l                specify the long request/response format\n"
10054 "-o operation      specify the phy control operation\n"
10055 "-d name           set the attached device name\n"
10056 "-m rate           set the minimum physical link rate\n"
10057 "-M rate           set the maximum physical link rate\n"
10058 "-T pp_timeout     set the partial pathway timeout value\n"
10059 "-a enable|disable enable or disable SATA slumber\n"
10060 "-A enable|disable enable or disable SATA partial phy power\n"
10061 "-s enable|disable enable or disable SAS slumber\n"
10062 "-S enable|disable enable or disable SAS partial phy power\n"
10063 "smpphylist arguments:\n"
10064 "-l                specify the long response format\n"
10065 "-q                only print phys with attached devices\n"
10066 "smpmaninfo arguments:\n"
10067 "-l                specify the long response format\n"
10068 "debug arguments:\n"
10069 "-I                CAM_DEBUG_INFO -- scsi commands, errors, data\n"
10070 "-T                CAM_DEBUG_TRACE -- routine flow tracking\n"
10071 "-S                CAM_DEBUG_SUBTRACE -- internal routine command flow\n"
10072 "-c                CAM_DEBUG_CDB -- print out SCSI CDBs only\n"
10073 "tags arguments:\n"
10074 "-N tags           specify the number of tags to use for this device\n"
10075 "-q                be quiet, don't report the number of tags\n"
10076 "-v                report a number of tag-related parameters\n"
10077 "negotiate arguments:\n"
10078 "-a                send a test unit ready after negotiation\n"
10079 "-c                report/set current negotiation settings\n"
10080 "-D <arg>          \"enable\" or \"disable\" disconnection\n"
10081 "-M mode           set ATA mode\n"
10082 "-O offset         set command delay offset\n"
10083 "-q                be quiet, don't report anything\n"
10084 "-R syncrate       synchronization rate in MHz\n"
10085 "-T <arg>          \"enable\" or \"disable\" tagged queueing\n"
10086 "-U                report/set user negotiation settings\n"
10087 "-W bus_width      set the bus width in bits (8, 16 or 32)\n"
10088 "-v                also print a Path Inquiry CCB for the controller\n"
10089 "format arguments:\n"
10090 "-q                be quiet, don't print status messages\n"
10091 "-r                run in report only mode\n"
10092 "-w                don't send immediate format command\n"
10093 "-y                don't ask any questions\n"
10094 "sanitize arguments:\n"
10095 "-a operation      operation mode: overwrite, block, crypto or exitfailure\n"
10096 "-c passes         overwrite passes to perform (1 to 31)\n"
10097 "-I                invert overwrite pattern after each pass\n"
10098 "-P pattern        path to overwrite pattern file\n"
10099 "-q                be quiet, don't print status messages\n"
10100 "-r                run in report only mode\n"
10101 "-U                run operation in unrestricted completion exit mode\n"
10102 "-w                don't send immediate sanitize command\n"
10103 "-y                don't ask any questions\n"
10104 "idle/standby arguments:\n"
10105 "-t <arg>          number of seconds before respective state.\n"
10106 "fwdownload arguments:\n"
10107 "-f fw_image       path to firmware image file\n"
10108 "-q                don't print informational messages, only errors\n"
10109 "-s                run in simulation mode\n"
10110 "-v                print info for every firmware segment sent to device\n"
10111 "-y                don't ask any questions\n"
10112 "security arguments:\n"
10113 "-d pwd            disable security using the given password for the selected\n"
10114 "                  user\n"
10115 "-e pwd            erase the device using the given pwd for the selected user\n"
10116 "-f                freeze the security configuration of the specified device\n"
10117 "-h pwd            enhanced erase the device using the given pwd for the\n"
10118 "                  selected user\n"
10119 "-k pwd            unlock the device using the given pwd for the selected\n"
10120 "                  user\n"
10121 "-l <high|maximum> specifies which security level to set: high or maximum\n"
10122 "-q                be quiet, do not print any status messages\n"
10123 "-s pwd            password the device (enable security) using the given\n"
10124 "                  pwd for the selected user\n"
10125 "-T timeout        overrides the timeout (seconds) used for erase operation\n"
10126 "-U <user|master>  specifies which user to set: user or master\n"
10127 "-y                don't ask any questions\n"
10128 "hpa arguments:\n"
10129 "-f                freeze the HPA configuration of the device\n"
10130 "-l                lock the HPA configuration of the device\n"
10131 "-P                make the HPA max sectors persist\n"
10132 "-p pwd            Set the HPA configuration password required for unlock\n"
10133 "                  calls\n"
10134 "-q                be quiet, do not print any status messages\n"
10135 "-s sectors        configures the maximum user accessible sectors of the\n"
10136 "                  device\n"
10137 "-U pwd            unlock the HPA configuration of the device\n"
10138 "-y                don't ask any questions\n"
10139 "ama arguments:\n"
10140 "-f                freeze the AMA configuration of the device\n"
10141 "-q                be quiet, do not print any status messages\n"
10142 "-s sectors        configures the maximum user accessible sectors of the\n"
10143 "                  device\n"
10144 "persist arguments:\n"
10145 "-i action         specify read_keys, read_reservation, report_cap, or\n"
10146 "                  read_full_status\n"
10147 "-o action         specify register, register_ignore, reserve, release,\n"
10148 "                  clear, preempt, preempt_abort, register_move, replace_lost\n"
10149 "-a                set the All Target Ports (ALL_TG_PT) bit\n"
10150 "-I tid            specify a Transport ID, e.g.: sas,0x1234567812345678\n"
10151 "-k key            specify the Reservation Key\n"
10152 "-K sa_key         specify the Service Action Reservation Key\n"
10153 "-p                set the Activate Persist Through Power Loss bit\n"
10154 "-R rtp            specify the Relative Target Port\n"
10155 "-s scope          specify the scope: lun, extent, element or a number\n"
10156 "-S                specify Transport ID for register, requires -I\n"
10157 "-T res_type       specify the reservation type: read_shared, wr_ex, rd_ex,\n"
10158 "                  ex_ac, wr_ex_ro, ex_ac_ro, wr_ex_ar, ex_ac_ar\n"
10159 "-U                unregister the current initiator for register_move\n"
10160 "attrib arguments:\n"
10161 "-r action         specify attr_values, attr_list, lv_list, part_list, or\n"
10162 "                  supp_attr\n"
10163 "-w attr           specify an attribute to write, one -w argument per attr\n"
10164 "-a attr_num       only display this attribute number\n"
10165 "-c                get cached attributes\n"
10166 "-e elem_addr      request attributes for the given element in a changer\n"
10167 "-F form1,form2    output format, comma separated list: text_esc, text_raw,\n"
10168 "                  nonascii_esc, nonascii_trim, nonascii_raw, field_all,\n"
10169 "                  field_none, field_desc, field_num, field_size, field_rw\n"
10170 "-p partition      request attributes for the given partition\n"
10171 "-s start_attr     request attributes starting at the given number\n"
10172 "-T elem_type      specify the element type (used with -e)\n"
10173 "-V logical_vol    specify the logical volume ID\n"
10174 "opcodes arguments:\n"
10175 "-o opcode         specify the individual opcode to list\n"
10176 "-s service_action specify the service action for the opcode\n"
10177 "-N                do not return SCSI error for unsupported SA\n"
10178 "-T                request nominal and recommended timeout values\n"
10179 "zone arguments:\n"
10180 "-c cmd            required: rz, open, close, finish, or rwp\n"
10181 "-a                apply the action to all zones\n"
10182 "-l LBA            specify the zone starting LBA\n"
10183 "-o rep_opts       report zones options: all, empty, imp_open, exp_open,\n"
10184 "                  closed, full, ro, offline, reset, nonseq, nonwp\n"
10185 "-P print_opt      report zones printing:  normal, summary, script\n"
10186 "epc arguments:\n"
10187 "-c cmd            required: restore, goto, timer, state, enable, disable,\n"
10188 "                  source, status, list\n"
10189 "-d                disable power mode (timer, state)\n"
10190 "-D                delayed entry (goto)\n"
10191 "-e                enable power mode (timer, state)\n"
10192 "-H                hold power mode (goto)\n"
10193 "-p power_cond     Idle_a, Idle_b, Idle_c, Standby_y, Standby_z (timer,\n"
10194 "                  state, goto)\n"
10195 "-P                only display power mode (status)\n"
10196 "-r rst_src        restore settings from: default, saved (restore)\n"
10197 "-s                save mode (timer, state, restore)\n"
10198 "-S power_src      set power source: battery, nonbattery (source)\n"
10199 "-T timer          set timer, seconds, .1 sec resolution (timer)\n"
10200 "timestamp arguments:\n"
10201 "-r                report the timestamp of the device\n"
10202 "-f format         report the timestamp of the device with the given\n"
10203 "                  strftime(3) format string\n"
10204 "-m                report the timestamp of the device as milliseconds since\n"
10205 "                  January 1st, 1970\n"
10206 "-U                report the time with UTC instead of the local time zone\n"
10207 "-s                set the timestamp of the device\n"
10208 "-f format         the format of the time string passed into strptime(3)\n"
10209 "-T time           the time value passed into strptime(3)\n"
10210 "-U                set the timestamp of the device to UTC time\n"
10211 "mmcsdcmd arguments:\n"
10212 "-c mmc_cmd        MMC command to send to the card\n"
10213 "-a mmc_arg        Argument for the MMC command\n"
10214 "-f mmc_flag       Flags to set for the MMC command\n"
10215 "-l data_len       Expect data_len bytes of data in reply and display them\n"
10216 "-W                Fill the data buffer before invoking the MMC command\n"
10217 "-b data_byte      One byte of data to fill the data buffer with\n"
10218 "-F frequency      Operating frequency to set on the controller\n"
10219 "-4                Set bus width to 4 bit\n"
10220 "-1                Set bus width to 8 bit\n"
10221 "-S high | std     Set high-speed or standard timing\n"
10222 "-I                Display various card and host controller information\n"
10223 );
10224 }
10225
10226 int
10227 main(int argc, char **argv)
10228 {
10229         int c;
10230         char *device = NULL;
10231         int unit = 0;
10232         struct cam_device *cam_dev = NULL;
10233         int timeout = 0, retry_count = 1;
10234         camcontrol_optret optreturn;
10235         char *tstr;
10236         const char *mainopt = "C:En:Q:t:u:v";
10237         const char *subopt = NULL;
10238         char combinedopt[256];
10239         int error = 0, optstart = 2;
10240         int task_attr = MSG_SIMPLE_Q_TAG;
10241         int devopen = 1;
10242         cam_cmd cmdlist;
10243         path_id_t bus;
10244         target_id_t target;
10245         lun_id_t lun;
10246
10247         cmdlist = CAM_CMD_NONE;
10248         arglist = CAM_ARG_NONE;
10249
10250         if (argc < 2) {
10251                 usage(0);
10252                 exit(1);
10253         }
10254
10255         /*
10256          * Get the base option.
10257          */
10258         optreturn = getoption(option_table,argv[1], &cmdlist, &arglist,&subopt);
10259
10260         if (optreturn == CC_OR_AMBIGUOUS) {
10261                 warnx("ambiguous option %s", argv[1]);
10262                 usage(0);
10263                 exit(1);
10264         } else if (optreturn == CC_OR_NOT_FOUND) {
10265                 warnx("option %s not found", argv[1]);
10266                 usage(0);
10267                 exit(1);
10268         }
10269
10270         /*
10271          * Ahh, getopt(3) is a pain.
10272          *
10273          * This is a gross hack.  There really aren't many other good
10274          * options (excuse the pun) for parsing options in a situation like
10275          * this.  getopt is kinda braindead, so you end up having to run
10276          * through the options twice, and give each invocation of getopt
10277          * the option string for the other invocation.
10278          *
10279          * You would think that you could just have two groups of options.
10280          * The first group would get parsed by the first invocation of
10281          * getopt, and the second group would get parsed by the second
10282          * invocation of getopt.  It doesn't quite work out that way.  When
10283          * the first invocation of getopt finishes, it leaves optind pointing
10284          * to the argument _after_ the first argument in the second group.
10285          * So when the second invocation of getopt comes around, it doesn't
10286          * recognize the first argument it gets and then bails out.
10287          *
10288          * A nice alternative would be to have a flag for getopt that says
10289          * "just keep parsing arguments even when you encounter an unknown
10290          * argument", but there isn't one.  So there's no real clean way to
10291          * easily parse two sets of arguments without having one invocation
10292          * of getopt know about the other.
10293          *
10294          * Without this hack, the first invocation of getopt would work as
10295          * long as the generic arguments are first, but the second invocation
10296          * (in the subfunction) would fail in one of two ways.  In the case
10297          * where you don't set optreset, it would fail because optind may be
10298          * pointing to the argument after the one it should be pointing at.
10299          * In the case where you do set optreset, and reset optind, it would
10300          * fail because getopt would run into the first set of options, which
10301          * it doesn't understand.
10302          *
10303          * All of this would "sort of" work if you could somehow figure out
10304          * whether optind had been incremented one option too far.  The
10305          * mechanics of that, however, are more daunting than just giving
10306          * both invocations all of the expect options for either invocation.
10307          *
10308          * Needless to say, I wouldn't mind if someone invented a better
10309          * (non-GPL!) command line parsing interface than getopt.  I
10310          * wouldn't mind if someone added more knobs to getopt to make it
10311          * work better.  Who knows, I may talk myself into doing it someday,
10312          * if the standards weenies let me.  As it is, it just leads to
10313          * hackery like this and causes people to avoid it in some cases.
10314          *
10315          * KDM, September 8th, 1998
10316          */
10317         if (subopt != NULL)
10318                 sprintf(combinedopt, "%s%s", mainopt, subopt);
10319         else
10320                 sprintf(combinedopt, "%s", mainopt);
10321
10322         /*
10323          * For these options we do not parse optional device arguments and
10324          * we do not open a passthrough device.
10325          */
10326         if ((cmdlist == CAM_CMD_RESCAN)
10327          || (cmdlist == CAM_CMD_RESET)
10328          || (cmdlist == CAM_CMD_DEVTREE)
10329          || (cmdlist == CAM_CMD_USAGE)
10330          || (cmdlist == CAM_CMD_DEBUG))
10331                 devopen = 0;
10332
10333         if ((devopen == 1)
10334          && (argc > 2 && argv[2][0] != '-')) {
10335                 char name[30];
10336                 int rv;
10337
10338                 if (isdigit(argv[2][0])) {
10339                         /* device specified as bus:target[:lun] */
10340                         rv = parse_btl(argv[2], &bus, &target, &lun, &arglist);
10341                         if (rv < 2)
10342                                 errx(1, "numeric device specification must "
10343                                      "be either bus:target, or "
10344                                      "bus:target:lun");
10345                         /* default to 0 if lun was not specified */
10346                         if ((arglist & CAM_ARG_LUN) == 0) {
10347                                 lun = 0;
10348                                 arglist |= CAM_ARG_LUN;
10349                         }
10350                         optstart++;
10351                 } else {
10352                         if (cam_get_device(argv[2], name, sizeof name, &unit)
10353                             == -1)
10354                                 errx(1, "%s", cam_errbuf);
10355                         device = strdup(name);
10356                         arglist |= CAM_ARG_DEVICE | CAM_ARG_UNIT;
10357                         optstart++;
10358                 }
10359         }
10360         /*
10361          * Start getopt processing at argv[2/3], since we've already
10362          * accepted argv[1..2] as the command name, and as a possible
10363          * device name.
10364          */
10365         optind = optstart;
10366
10367         /*
10368          * Now we run through the argument list looking for generic
10369          * options, and ignoring options that possibly belong to
10370          * subfunctions.
10371          */
10372         while ((c = getopt(argc, argv, combinedopt))!= -1){
10373                 switch(c) {
10374                         case 'C':
10375                                 retry_count = strtol(optarg, NULL, 0);
10376                                 if (retry_count < 0)
10377                                         errx(1, "retry count %d is < 0",
10378                                              retry_count);
10379                                 arglist |= CAM_ARG_RETRIES;
10380                                 break;
10381                         case 'E':
10382                                 arglist |= CAM_ARG_ERR_RECOVER;
10383                                 break;
10384                         case 'n':
10385                                 arglist |= CAM_ARG_DEVICE;
10386                                 tstr = optarg;
10387                                 while (isspace(*tstr) && (*tstr != '\0'))
10388                                         tstr++;
10389                                 device = (char *)strdup(tstr);
10390                                 break;
10391                         case 'Q': {
10392                                 char *endptr;
10393                                 int table_entry = 0;
10394
10395                                 tstr = optarg;
10396                                 while (isspace(*tstr) && (*tstr != '\0'))
10397                                         tstr++;
10398                                 if (isdigit(*tstr)) {
10399                                         task_attr = strtol(tstr, &endptr, 0);
10400                                         if (*endptr != '\0') {
10401                                                 errx(1, "Invalid queue option "
10402                                                     "%s", tstr);
10403                                         }
10404                                 } else {
10405                                         size_t table_size;
10406                                         scsi_nv_status status;
10407
10408                                         table_size = sizeof(task_attrs) /
10409                                                      sizeof(task_attrs[0]);
10410                                         status = scsi_get_nv(task_attrs,
10411                                             table_size, tstr, &table_entry,
10412                                             SCSI_NV_FLAG_IG_CASE);
10413                                         if (status == SCSI_NV_FOUND)
10414                                                 task_attr = task_attrs[
10415                                                     table_entry].value;
10416                                         else {
10417                                                 errx(1, "%s option %s",
10418                                                   (status == SCSI_NV_AMBIGUOUS)?
10419                                                     "ambiguous" : "invalid",
10420                                                     tstr);
10421                                         }
10422                                 }
10423                                 break;
10424                         }
10425                         case 't':
10426                                 timeout = strtol(optarg, NULL, 0);
10427                                 if (timeout < 0)
10428                                         errx(1, "invalid timeout %d", timeout);
10429                                 /* Convert the timeout from seconds to ms */
10430                                 timeout *= 1000;
10431                                 arglist |= CAM_ARG_TIMEOUT;
10432                                 break;
10433                         case 'u':
10434                                 arglist |= CAM_ARG_UNIT;
10435                                 unit = strtol(optarg, NULL, 0);
10436                                 break;
10437                         case 'v':
10438                                 arglist |= CAM_ARG_VERBOSE;
10439                                 break;
10440                         default:
10441                                 break;
10442                 }
10443         }
10444
10445         /*
10446          * For most commands we'll want to open the passthrough device
10447          * associated with the specified device.  In the case of the rescan
10448          * commands, we don't use a passthrough device at all, just the
10449          * transport layer device.
10450          */
10451         if (devopen == 1) {
10452                 if (((arglist & (CAM_ARG_BUS|CAM_ARG_TARGET)) == 0)
10453                  && (((arglist & CAM_ARG_DEVICE) == 0)
10454                   || ((arglist & CAM_ARG_UNIT) == 0))) {
10455                         errx(1, "subcommand \"%s\" requires a valid device "
10456                              "identifier", argv[1]);
10457                 }
10458
10459                 if ((cam_dev = ((arglist & (CAM_ARG_BUS | CAM_ARG_TARGET))?
10460                                 cam_open_btl(bus, target, lun, O_RDWR, NULL) :
10461                                 cam_open_spec_device(device,unit,O_RDWR,NULL)))
10462                      == NULL)
10463                         errx(1,"%s", cam_errbuf);
10464         }
10465
10466         /*
10467          * Reset optind to 2, and reset getopt, so these routines can parse
10468          * the arguments again.
10469          */
10470         optind = optstart;
10471         optreset = 1;
10472
10473         switch(cmdlist) {
10474         case CAM_CMD_DEVLIST:
10475                 error = getdevlist(cam_dev);
10476                 break;
10477         case CAM_CMD_HPA:
10478                 error = atahpa(cam_dev, retry_count, timeout,
10479                                argc, argv, combinedopt);
10480                 break;
10481         case CAM_CMD_AMA:
10482                 error = ataama(cam_dev, retry_count, timeout,
10483                                argc, argv, combinedopt);
10484                 break;
10485         case CAM_CMD_DEVTREE:
10486                 error = getdevtree(argc, argv, combinedopt);
10487                 break;
10488         case CAM_CMD_DEVTYPE:
10489                 error = getdevtype(cam_dev);
10490                 break;
10491         case CAM_CMD_TUR:
10492                 error = testunitready(cam_dev, task_attr, retry_count,
10493                     timeout, 0);
10494                 break;
10495         case CAM_CMD_INQUIRY:
10496                 error = scsidoinquiry(cam_dev, argc, argv, combinedopt,
10497                                       task_attr, retry_count, timeout);
10498                 break;
10499         case CAM_CMD_IDENTIFY:
10500                 error = identify(cam_dev, retry_count, timeout);
10501                 break;
10502         case CAM_CMD_STARTSTOP:
10503                 error = scsistart(cam_dev, arglist & CAM_ARG_START_UNIT,
10504                                   arglist & CAM_ARG_EJECT, task_attr,
10505                                   retry_count, timeout);
10506                 break;
10507         case CAM_CMD_RESCAN:
10508                 error = dorescan_or_reset(argc, argv, 1);
10509                 break;
10510         case CAM_CMD_RESET:
10511                 error = dorescan_or_reset(argc, argv, 0);
10512                 break;
10513         case CAM_CMD_READ_DEFECTS:
10514                 error = readdefects(cam_dev, argc, argv, combinedopt,
10515                                     task_attr, retry_count, timeout);
10516                 break;
10517         case CAM_CMD_MODE_PAGE:
10518                 modepage(cam_dev, argc, argv, combinedopt,
10519                          task_attr, retry_count, timeout);
10520                 break;
10521         case CAM_CMD_SCSI_CMD:
10522                 error = scsicmd(cam_dev, argc, argv, combinedopt,
10523                                 task_attr, retry_count, timeout);
10524                 break;
10525         case CAM_CMD_MMCSD_CMD:
10526                 error = mmcsdcmd(cam_dev, argc, argv, combinedopt,
10527                                         retry_count, timeout);
10528                 break;
10529         case CAM_CMD_SMP_CMD:
10530                 error = smpcmd(cam_dev, argc, argv, combinedopt,
10531                                retry_count, timeout);
10532                 break;
10533         case CAM_CMD_SMP_RG:
10534                 error = smpreportgeneral(cam_dev, argc, argv,
10535                                          combinedopt, retry_count,
10536                                          timeout);
10537                 break;
10538         case CAM_CMD_SMP_PC:
10539                 error = smpphycontrol(cam_dev, argc, argv, combinedopt,
10540                                       retry_count, timeout);
10541                 break;
10542         case CAM_CMD_SMP_PHYLIST:
10543                 error = smpphylist(cam_dev, argc, argv, combinedopt,
10544                                    retry_count, timeout);
10545                 break;
10546         case CAM_CMD_SMP_MANINFO:
10547                 error = smpmaninfo(cam_dev, argc, argv, combinedopt,
10548                                    retry_count, timeout);
10549                 break;
10550         case CAM_CMD_DEBUG:
10551                 error = camdebug(argc, argv, combinedopt);
10552                 break;
10553         case CAM_CMD_TAG:
10554                 error = tagcontrol(cam_dev, argc, argv, combinedopt);
10555                 break;
10556         case CAM_CMD_RATE:
10557                 error = ratecontrol(cam_dev, task_attr, retry_count,
10558                                     timeout, argc, argv, combinedopt);
10559                 break;
10560         case CAM_CMD_FORMAT:
10561                 error = scsiformat(cam_dev, argc, argv,
10562                                    combinedopt, task_attr, retry_count,
10563                                    timeout);
10564                 break;
10565         case CAM_CMD_REPORTLUNS:
10566                 error = scsireportluns(cam_dev, argc, argv,
10567                                        combinedopt, task_attr,
10568                                        retry_count, timeout);
10569                 break;
10570         case CAM_CMD_READCAP:
10571                 error = scsireadcapacity(cam_dev, argc, argv,
10572                                          combinedopt, task_attr,
10573                                          retry_count, timeout);
10574                 break;
10575         case CAM_CMD_IDLE:
10576         case CAM_CMD_STANDBY:
10577         case CAM_CMD_SLEEP:
10578         case CAM_CMD_POWER_MODE:
10579                 error = atapm(cam_dev, argc, argv,
10580                               combinedopt, retry_count, timeout);
10581                 break;
10582         case CAM_CMD_APM:
10583         case CAM_CMD_AAM:
10584                 error = ataaxm(cam_dev, argc, argv,
10585                               combinedopt, retry_count, timeout);
10586                 break;
10587         case CAM_CMD_SECURITY:
10588                 error = atasecurity(cam_dev, retry_count, timeout,
10589                                     argc, argv, combinedopt);
10590                 break;
10591         case CAM_CMD_DOWNLOAD_FW:
10592                 error = fwdownload(cam_dev, argc, argv, combinedopt,
10593                     arglist & CAM_ARG_VERBOSE, task_attr, retry_count,
10594                     timeout);
10595                 break;
10596         case CAM_CMD_SANITIZE:
10597                 error = sanitize(cam_dev, argc, argv, combinedopt, task_attr,
10598                                  retry_count, timeout);
10599                 break;
10600         case CAM_CMD_PERSIST:
10601                 error = scsipersist(cam_dev, argc, argv, combinedopt,
10602                     task_attr, retry_count, timeout,
10603                     arglist & CAM_ARG_VERBOSE,
10604                     arglist & CAM_ARG_ERR_RECOVER);
10605                 break;
10606         case CAM_CMD_ATTRIB:
10607                 error = scsiattrib(cam_dev, argc, argv, combinedopt,
10608                     task_attr, retry_count, timeout,
10609                     arglist & CAM_ARG_VERBOSE,
10610                     arglist & CAM_ARG_ERR_RECOVER);
10611                 break;
10612         case CAM_CMD_OPCODES:
10613                 error = scsiopcodes(cam_dev, argc, argv, combinedopt,
10614                     task_attr, retry_count, timeout,
10615                     arglist & CAM_ARG_VERBOSE);
10616                 break;
10617         case CAM_CMD_REPROBE:
10618                 error = reprobe(cam_dev);
10619                 break;
10620         case CAM_CMD_ZONE:
10621                 error = zone(cam_dev, argc, argv, combinedopt,
10622                     task_attr, retry_count, timeout,
10623                     arglist & CAM_ARG_VERBOSE);
10624                 break;
10625         case CAM_CMD_EPC:
10626                 error = epc(cam_dev, argc, argv, combinedopt,
10627                     retry_count, timeout, arglist & CAM_ARG_VERBOSE);
10628                 break;
10629         case CAM_CMD_TIMESTAMP:
10630                 error = timestamp(cam_dev, argc, argv, combinedopt,
10631                     task_attr, retry_count, timeout,
10632                     arglist & CAM_ARG_VERBOSE);
10633                 break;
10634         case CAM_CMD_USAGE:
10635                 usage(1);
10636                 break;
10637         default:
10638                 usage(0);
10639                 error = 1;
10640                 break;
10641         }
10642
10643         if (cam_dev != NULL)
10644                 cam_close_device(cam_dev);
10645
10646         exit(error);
10647 }