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