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