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