sbin/camcontrol/camcontrol.c

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