sbin/camcontrol/camcontrol.c

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