/*-
 * Copyright (c) 2016 Spectra Logic Corporation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    substantially similar to the "NO WARRANTY" disclaimer below
 *    ("Disclaimer") and any redistribution must be conditioned upon
 *    including a substantially similar Disclaimer requirement for further
 *    binary redistribution.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
 * Authors: Ken Merry           (Spectra Logic Corporation)
 */
/*
 * ATA Extended Power Conditions (EPC) support
 */

#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/stdint.h>
#include <sys/endian.h>
#include <sys/sbuf.h>
#include <sys/queue.h>
#include <sys/ata.h>

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <fcntl.h>
#include <ctype.h>
#include <limits.h>
#include <err.h>
#include <locale.h>

#include <cam/cam.h>
#include <cam/cam_debug.h>
#include <cam/cam_ccb.h>
#include <cam/scsi/scsi_all.h>
#include <cam/scsi/scsi_da.h>
#include <cam/scsi/scsi_pass.h>
#include <cam/scsi/scsi_message.h>
#include <camlib.h>
#include "camcontrol.h"

typedef enum {
	EPC_ACTION_NONE		= 0x00,
	EPC_ACTION_LIST		= 0x01,
	EPC_ACTION_TIMER_SET	= 0x02,
	EPC_ACTION_IMMEDIATE	= 0x03,
	EPC_ACTION_GETMODE	= 0x04
} epc_action;

static struct scsi_nv epc_flags[] = {
	{ "Supported", ATA_PCL_COND_SUPPORTED },
	{ "Saveable", ATA_PCL_COND_SUPPORTED },
	{ "Changeable", ATA_PCL_COND_CHANGEABLE },
	{ "Default Timer Enabled", ATA_PCL_DEFAULT_TIMER_EN },
	{ "Saved Timer Enabled", ATA_PCL_SAVED_TIMER_EN },
	{ "Current Timer Enabled", ATA_PCL_CURRENT_TIMER_EN },
	{ "Hold Power Condition Not Supported", ATA_PCL_HOLD_PC_NOT_SUP }
};

static struct scsi_nv epc_power_cond_map[] = {
	{ "Standby_z", ATA_EPC_STANDBY_Z },
	{ "z", ATA_EPC_STANDBY_Z },
	{ "Standby_y", ATA_EPC_STANDBY_Y },
	{ "y", ATA_EPC_STANDBY_Y },
	{ "Idle_a", ATA_EPC_IDLE_A },
	{ "a", ATA_EPC_IDLE_A },
	{ "Idle_b", ATA_EPC_IDLE_B },
	{ "b", ATA_EPC_IDLE_B },
	{ "Idle_c", ATA_EPC_IDLE_C },
	{ "c", ATA_EPC_IDLE_C }
};

static struct scsi_nv epc_rst_val[] = {
	{ "default", ATA_SF_EPC_RST_DFLT },
	{ "saved", 0}
};

static struct scsi_nv epc_ps_map[] = {
	{ "unknown", ATA_SF_EPC_SRC_UNKNOWN },
	{ "battery", ATA_SF_EPC_SRC_BAT },
	{ "notbattery", ATA_SF_EPC_SRC_NOT_BAT }
};

/*
 * These aren't subcommands of the EPC SET FEATURES subcommand, but rather
 * commands that determine the current capabilities and status of the drive.
 * The EPC subcommands are limited to 4 bits, so we won't collide with any
 * future values.
 */
#define	CCTL_EPC_GET_STATUS	0x8001
#define	CCTL_EPC_LIST		0x8002

static struct scsi_nv epc_cmd_map[] = {
	{ "restore", ATA_SF_EPC_RESTORE },
	{ "goto", ATA_SF_EPC_GOTO },
	{ "timer", ATA_SF_EPC_SET_TIMER },
	{ "state", ATA_SF_EPC_SET_STATE },
	{ "enable", ATA_SF_EPC_ENABLE },
	{ "disable", ATA_SF_EPC_DISABLE },
	{ "source", ATA_SF_EPC_SET_SOURCE },
	{ "status", CCTL_EPC_GET_STATUS },
	{ "list", CCTL_EPC_LIST }
};

static int epc_list(struct cam_device *device, camcontrol_devtype devtype,
		    union ccb *ccb, int retry_count, int timeout);
static void epc_print_pcl_desc(struct ata_power_cond_log_desc *desc,
			       const char *prefix);
static int epc_getmode(struct cam_device *device, camcontrol_devtype devtype,
		       union ccb *ccb, int retry_count, int timeout,
		       int power_only);
static int epc_set_features(struct cam_device *device,
			    camcontrol_devtype devtype, union ccb *ccb,
			    int retry_count, int timeout, int action,
			    int power_cond, int timer, int enable, int save,
			    int delayed_entry, int hold, int power_src,
			    int restore_src);

static void
epc_print_pcl_desc(struct ata_power_cond_log_desc *desc, const char *prefix)
{
	int first;
	unsigned int i,	num_printed, max_chars;

	first = 1;
	max_chars = 75;

	num_printed = printf("%sFlags: ", prefix);
	for (i = 0; i < nitems(epc_flags); i++) {
		if ((desc->flags & epc_flags[i].value) == 0)
			continue;
		if (first == 0) {
			num_printed += printf(", ");
		}
		if ((num_printed + strlen(epc_flags[i].name)) > max_chars) {
			printf("\n");
			num_printed = printf("%s       ", prefix);
		}
		num_printed += printf("%s", epc_flags[i].name);
		first = 0;
	}
	if (first != 0)
		printf("None");
	printf("\n");

	printf("%sDefault timer setting: %.1f sec\n", prefix,
	    (double)(le32dec(desc->default_timer) / 10));
	printf("%sSaved timer setting: %.1f sec\n", prefix,
	    (double)(le32dec(desc->saved_timer) / 10));
	printf("%sCurrent timer setting: %.1f sec\n", prefix,
	    (double)(le32dec(desc->current_timer) / 10));
	printf("%sNominal time to active: %.1f sec\n", prefix,
	    (double)(le32dec(desc->nom_time_to_active) / 10));
	printf("%sMinimum timer: %.1f sec\n", prefix,
	    (double)(le32dec(desc->min_timer) / 10));
	printf("%sMaximum timer: %.1f sec\n", prefix,
	    (double)(le32dec(desc->max_timer) / 10));
	printf("%sNumber of transitions to power condition: %u\n", prefix,
	    le32dec(desc->num_transitions_to_pc));
	printf("%sHours in power condition: %u\n", prefix,
	    le32dec(desc->hours_in_pc));
}

static int
epc_list(struct cam_device *device, camcontrol_devtype devtype, union ccb *ccb,
	 int retry_count, int timeout)
{
	struct ata_power_cond_log_idle *idle_log;
	struct ata_power_cond_log_standby *standby_log;
	uint8_t log_buf[sizeof(*idle_log) + sizeof(*standby_log)];
	uint16_t log_addr = ATA_POWER_COND_LOG;
	uint16_t page_number = ATA_PCL_IDLE;
	uint64_t lba;
	int error = 0;

	lba = (((uint64_t)page_number & 0xff00) << 32) |
	      ((page_number & 0x00ff) << 8) |
	      (log_addr & 0xff);

	error = build_ata_cmd(ccb,
	    /*retry_count*/ retry_count,
	    /*flags*/ CAM_DIR_IN | CAM_DEV_QFRZDIS,
	    /*tag_action*/ MSG_SIMPLE_Q_TAG,
	    /*protocol*/ AP_PROTO_DMA | AP_EXTEND,
	    /*ata_flags*/ AP_FLAG_BYT_BLOK_BLOCKS |
			  AP_FLAG_TLEN_SECT_CNT |
			  AP_FLAG_TDIR_FROM_DEV,
	    /*features*/ 0,
	    /*sector_count*/ 2,
	    /*lba*/ lba,
	    /*command*/ ATA_READ_LOG_DMA_EXT,
	    /*auxiliary*/ 0,
	    /*data_ptr*/ log_buf,
	    /*dxfer_len*/ sizeof(log_buf),
	    /*cdb_storage*/ NULL,
	    /*cdb_storage_len*/ 0,
	    /*sense_len*/ SSD_FULL_SIZE,
	    /*timeout*/ timeout ? timeout : 60000,
	    /*is48bit*/ 1,
	    /*devtype*/ devtype);

	if (error != 0) {
		warnx("%s: build_ata_cmd() failed, likely programmer error",
		    __func__);
		goto bailout;
	}

	if (retry_count > 0)
		ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;

	error = cam_send_ccb(device, ccb);
	if (error != 0) {
		warn("error sending ATA READ LOG EXT CCB");
		error = 1;
		goto bailout;
	}

	if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
		cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL,stderr);
		error = 1;
		goto bailout;
	}

	idle_log = (struct ata_power_cond_log_idle *)log_buf;
	standby_log =
	    (struct ata_power_cond_log_standby *)&log_buf[sizeof(*idle_log)];

	printf("ATA Power Conditions Log:\n");
	printf("  Idle power conditions page:\n");
	printf("    Idle A condition:\n");
	epc_print_pcl_desc(&idle_log->idle_a_desc, "      ");
	printf("    Idle B condition:\n");
	epc_print_pcl_desc(&idle_log->idle_b_desc, "      ");
	printf("    Idle C condition:\n");
	epc_print_pcl_desc(&idle_log->idle_c_desc, "      ");
	printf("  Standby power conditions page:\n");
	printf("    Standby Y condition:\n");
	epc_print_pcl_desc(&standby_log->standby_y_desc, "      ");
	printf("    Standby Z condition:\n");
	epc_print_pcl_desc(&standby_log->standby_z_desc, "      ");
bailout:
	return (error);
}

static int
epc_getmode(struct cam_device *device, camcontrol_devtype devtype,
	    union ccb *ccb, int retry_count, int timeout, int power_only)
{
	struct ata_params *ident = NULL;
	struct ata_identify_log_sup_cap sup_cap;
	const char *mode_name = NULL;
	uint8_t error = 0, ata_device = 0, status = 0;
	uint16_t count = 0;
	uint64_t lba = 0;
	uint32_t page_number, log_address;
	uint64_t caps = 0;
	int avail_bytes = 0;
	int res_available = 0;
	int retval;

	retval = 0;

	if (power_only != 0)
		goto check_power_mode;

	/*
	 * Get standard ATA Identify data.
	 */
	retval = ata_do_identify(device, retry_count, timeout, ccb, &ident);
	if (retval != 0) {
		warnx("Couldn't get identify data");
		goto bailout;
	}

	/*
	 * Get the ATA Identify Data Log (0x30),
	 * Supported Capabilities Page (0x03).
	 */
	log_address = ATA_IDENTIFY_DATA_LOG;
	page_number = ATA_IDL_SUP_CAP;
	lba = (((uint64_t)page_number & 0xff00) << 32) |
	       ((page_number & 0x00ff) << 8) |
	       (log_address & 0xff);

	bzero(&sup_cap, sizeof(sup_cap));
	/*
	 * XXX KDM check the supported protocol.
	 */
	retval = build_ata_cmd(ccb,
	    /*retry_count*/ retry_count,
	    /*flags*/ CAM_DIR_IN | CAM_DEV_QFRZDIS,
	    /*tag_action*/ MSG_SIMPLE_Q_TAG,
	    /*protocol*/ AP_PROTO_DMA |
			 AP_EXTEND,
	    /*ata_flags*/ AP_FLAG_BYT_BLOK_BLOCKS |
			  AP_FLAG_TLEN_SECT_CNT |
			  AP_FLAG_TDIR_FROM_DEV,
	    /*features*/ 0,
	    /*sector_count*/ 1,
	    /*lba*/ lba,
	    /*command*/ ATA_READ_LOG_DMA_EXT,
	    /*auxiliary*/ 0,
	    /*data_ptr*/ (uint8_t *)&sup_cap,
	    /*dxfer_len*/ sizeof(sup_cap), 
	    /*cdb_storage*/ NULL,
	    /*cdb_storage_len*/ 0,
	    /*sense_len*/ SSD_FULL_SIZE,
	    /*timeout*/ timeout ? timeout : 60000,
	    /*is48bit*/ 1,
	    /*devtype*/ devtype);

	if (retval != 0) {
		warnx("%s: build_ata_cmd() failed, likely a programmer error",
		    __func__);
		goto bailout;
	}

	if (retry_count > 0)
		ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;

	retval = cam_send_ccb(device, ccb);
	if (retval != 0) {
		warn("error sending ATA READ LOG CCB");
		retval = 1;
		goto bailout;
	}

	if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
		cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL,stderr);
		retval = 1;
		goto bailout;
	}

	if (ccb->ccb_h.func_code == XPT_SCSI_IO) {
		avail_bytes = ccb->csio.dxfer_len - ccb->csio.resid;
	} else {
		avail_bytes = ccb->ataio.dxfer_len - ccb->ataio.resid;
	}
	if (avail_bytes < (int)sizeof(sup_cap)) {
		warnx("Couldn't get enough of the ATA Supported "
		    "Capabilities log, %d bytes returned", avail_bytes);
		retval = 1;
		goto bailout;
	}
	caps = le64dec(sup_cap.sup_cap);
	if ((caps & ATA_SUP_CAP_VALID) == 0) {
		warnx("Supported capabilities bits are not valid");
		retval = 1;
		goto bailout;
	}

	printf("APM: %sSupported, %sEnabled\n",
	    (ident->support.command2 & ATA_SUPPORT_APM) ? "" : "NOT ",
	    (ident->enabled.command2 & ATA_SUPPORT_APM) ? "" : "NOT ");
	printf("EPC: %sSupported, %sEnabled\n",
	    (ident->support2 & ATA_SUPPORT_EPC) ? "" : "NOT ",
	    (ident->enabled2 & ATA_ENABLED_EPC) ? "" : "NOT ");
	printf("Low Power Standby %sSupported\n",
	    (caps & ATA_SC_LP_STANDBY_SUP) ? "" : "NOT ");
	printf("Set EPC Power Source %sSupported\n",
	    (caps & ATA_SC_SET_EPC_PS_SUP) ? "" : "NOT ");
	

check_power_mode:

	retval = build_ata_cmd(ccb,
	    /*retry_count*/ retry_count,
	    /*flags*/ CAM_DIR_NONE | CAM_DEV_QFRZDIS,
	    /*tag_action*/ MSG_SIMPLE_Q_TAG,
	    /*protocol*/ AP_PROTO_NON_DATA |
			 AP_EXTEND,
	    /*ata_flags*/ AP_FLAG_BYT_BLOK_BLOCKS |
			  AP_FLAG_TLEN_NO_DATA |
			  AP_FLAG_CHK_COND,
	    /*features*/ ATA_SF_EPC,
	    /*sector_count*/ 0,
	    /*lba*/ 0,
	    /*command*/ ATA_CHECK_POWER_MODE,
	    /*auxiliary*/ 0,
	    /*data_ptr*/ NULL,
	    /*dxfer_len*/ 0, 
	    /*cdb_storage*/ NULL,
	    /*cdb_storage_len*/ 0,
	    /*sense_len*/ SSD_FULL_SIZE,
	    /*timeout*/ timeout ? timeout : 60000,
	    /*is48bit*/ 0,
	    /*devtype*/ devtype);

	if (retval != 0) {
		warnx("%s: build_ata_cmd() failed, likely a programmer error",
		    __func__);
		goto bailout;
	}

	if (retry_count > 0)
		ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;

	retval = cam_send_ccb(device, ccb);
	if (retval != 0) {
		warn("error sending ATA CHECK POWER MODE CCB");
		retval = 1;
		goto bailout;
	}

	/*
	 * Check to see whether we got the requested ATA result if this
	 * is an SCSI ATA PASS-THROUGH command.
	 */
	if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_SCSI_STATUS_ERROR)
	 && (ccb->csio.scsi_status == SCSI_STATUS_CHECK_COND)) {
		int error_code, sense_key, asc, ascq;

		retval = scsi_extract_sense_ccb(ccb, &error_code,
		    &sense_key, &asc, &ascq);
		if (retval == 0) {
			cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL,
			    stderr);
			retval = 1;
			goto bailout;
		}
		if ((sense_key == SSD_KEY_RECOVERED_ERROR)
		 && (asc == 0x00)
		 && (ascq == 0x1d)) {
			res_available = 1;
		}
		
	}
	if (((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)
	 && (res_available == 0)) {
		cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL,stderr);
		retval = 1;
		goto bailout;
	}

	retval = get_ata_status(device, ccb, &error, &count, &lba, &ata_device,
	    &status);
	if (retval != 0) {
		warnx("Unable to get ATA CHECK POWER MODE result");
		retval = 1;
		goto bailout;
	}

	mode_name = scsi_nv_to_str(epc_power_cond_map,
	    nitems(epc_power_cond_map), count);
	printf("Current power state: ");
	/* Note: ident can be null in power_only mode */
	if ((ident == NULL)
	 || (ident->enabled2 & ATA_ENABLED_EPC)) {
		if (mode_name != NULL)
			printf("%s", mode_name);
		else if (count == ATA_PM_ACTIVE_IDLE) {
			printf("PM0:Active or PM1:Idle");
		}
	} else {
		switch (count) {
		case ATA_PM_STANDBY:
			printf("PM2:Standby");
			break;
		case ATA_PM_IDLE:
			printf("PM1:Idle");
			break;
		case ATA_PM_ACTIVE_IDLE:
			printf("PM0:Active or PM1:Idle");
			break;
		}
	}
	printf("(0x%02x)\n", count);

	if (power_only != 0)
		goto bailout;

	if (caps & ATA_SC_LP_STANDBY_SUP) {
		uint32_t wait_mode;

		wait_mode = (lba >> 20) & 0xff;
		if (wait_mode == 0xff) {
			printf("Device not waiting to enter lower power "
			    "condition");
		} else {
			mode_name = scsi_nv_to_str(epc_power_cond_map,
			    sizeof(epc_power_cond_map) /
			    sizeof(epc_power_cond_map[0]), wait_mode);
			printf("Device waiting to enter mode %s (0x%02x)\n",
			    (mode_name != NULL) ? mode_name : "Unknown",
			    wait_mode);
		}
		printf("Device is %sheld in the current power condition\n",
		    (lba & 0x80000) ? "" : "NOT ");
	}
bailout:
	return (retval);

}

static int
epc_set_features(struct cam_device *device, camcontrol_devtype devtype,
		 union ccb *ccb, int retry_count, int timeout, int action,
		 int power_cond, int timer, int enable, int save,
		 int delayed_entry, int hold, int power_src, int restore_src)
{
	uint64_t lba;
	uint16_t count = 0;
	int error;

	error = 0;

	lba = action;

	switch (action) {
	case ATA_SF_EPC_SET_TIMER:
		lba |= ((timer << ATA_SF_EPC_TIMER_SHIFT) &
			 ATA_SF_EPC_TIMER_MASK);
		/* FALLTHROUGH */
	case ATA_SF_EPC_SET_STATE:
		lba |= (enable ? ATA_SF_EPC_TIMER_EN : 0) |
		       (save ? ATA_SF_EPC_TIMER_SAVE : 0);
		count = power_cond;
		break;
	case ATA_SF_EPC_GOTO:
		count = power_cond;
		lba |= (delayed_entry ? ATA_SF_EPC_GOTO_DELAY : 0) |
		       (hold ? ATA_SF_EPC_GOTO_HOLD : 0);
		break;
	case ATA_SF_EPC_RESTORE:
		lba |= restore_src |
		       (save ? ATA_SF_EPC_RST_SAVE : 0);
		break;
	case ATA_SF_EPC_ENABLE:
	case ATA_SF_EPC_DISABLE:
		break;
	case ATA_SF_EPC_SET_SOURCE:
		count = power_src;
		break;
	}

	error = build_ata_cmd(ccb,
	    /*retry_count*/ retry_count,
	    /*flags*/ CAM_DIR_NONE | CAM_DEV_QFRZDIS,
	    /*tag_action*/ MSG_SIMPLE_Q_TAG,
	    /*protocol*/ AP_PROTO_NON_DATA | AP_EXTEND,
	    /*ata_flags*/ AP_FLAG_BYT_BLOK_BLOCKS |
			  AP_FLAG_TLEN_NO_DATA |
			  AP_FLAG_TDIR_FROM_DEV,
	    /*features*/ ATA_SF_EPC,
	    /*sector_count*/ count,
	    /*lba*/ lba,
	    /*command*/ ATA_SETFEATURES,
	    /*auxiliary*/ 0,
	    /*data_ptr*/ NULL,
	    /*dxfer_len*/ 0, 
	    /*cdb_storage*/ NULL,
	    /*cdb_storage_len*/ 0,
	    /*sense_len*/ SSD_FULL_SIZE,
	    /*timeout*/ timeout ? timeout : 60000,
	    /*is48bit*/ 1,
	    /*devtype*/ devtype);

	if (error != 0) {
		warnx("%s: build_ata_cmd() failed, likely a programmer error",
		    __func__);
		goto bailout;
	}

	if (retry_count > 0)
		ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;

	error = cam_send_ccb(device, ccb);
	if (error != 0) {
		warn("error sending ATA SET FEATURES CCB");
		error = 1;
		goto bailout;
	}

	if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
		cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL,stderr);
		error = 1;
		goto bailout;
	}

bailout:
	return (error);
}

int
epc(struct cam_device *device, int argc, char **argv, char *combinedopt,
    int retry_count, int timeout, int verbosemode __unused)
{
	union ccb *ccb = NULL;
	int error = 0;
	int c;
	int action = -1;
	camcontrol_devtype devtype;
	double timer_val = -1;
	int timer_tenths = 0, power_cond = -1;
	int delayed_entry = 0, hold = 0;
	int enable = -1, save = 0;
	int restore_src = -1;
	int power_src = -1;
	int power_only = 0;


	ccb = cam_getccb(device);
	if (ccb == NULL) {
		warnx("%s: error allocating CCB", __func__);
		error = 1;
		goto bailout;
	}

	while ((c = getopt(argc, argv, combinedopt)) != -1) {
		switch (c) {
		case 'c': {
			scsi_nv_status status;
			int entry_num;

			status = scsi_get_nv(epc_cmd_map,
			    nitems(epc_cmd_map),
			    optarg, &entry_num, SCSI_NV_FLAG_IG_CASE);
			if (status == SCSI_NV_FOUND)
				action = epc_cmd_map[entry_num].value;
			else {
				warnx("%s: %s: %s option %s", __func__,
				    (status == SCSI_NV_AMBIGUOUS) ?
				    "ambiguous" : "invalid", "epc command",
				    optarg);
				error = 1;
				goto bailout;
			}
			break;
		}
		case 'd':
			enable = 0;
			break;
		case 'D':
			delayed_entry = 1;
			break;
		case 'e':
			enable = 1;
			break;
		case 'H':
			hold = 1;
			break;
		case 'p': {
			scsi_nv_status status;
			int entry_num;

			status = scsi_get_nv(epc_power_cond_map,
			    (sizeof(epc_power_cond_map) /
			     sizeof(epc_power_cond_map[0])), optarg,
			     &entry_num, SCSI_NV_FLAG_IG_CASE);
			if (status == SCSI_NV_FOUND)
				power_cond =epc_power_cond_map[entry_num].value;
			else {
				warnx("%s: %s: %s option %s", __func__,
				    (status == SCSI_NV_AMBIGUOUS) ?
				    "ambiguous" : "invalid", "power condition",
				    optarg);
				error = 1;
				goto bailout;
			}
			break;
		}
		case 'P':
			power_only = 1;
			break;
		case 'r': {
			scsi_nv_status status;
			int entry_num;

			status = scsi_get_nv(epc_rst_val,
			    (sizeof(epc_rst_val) /
			     sizeof(epc_rst_val[0])), optarg,
			     &entry_num, SCSI_NV_FLAG_IG_CASE);
			if (status == SCSI_NV_FOUND)
				restore_src = epc_rst_val[entry_num].value;
			else {
				warnx("%s: %s: %s option %s", __func__,
				    (status == SCSI_NV_AMBIGUOUS) ?
				    "ambiguous" : "invalid",
				    "restore value source", optarg);
				error = 1;
				goto bailout;
			}
			break;
		}
		case 's':
			save = 1;
			break;
		case 'S': {
			scsi_nv_status status;
			int entry_num;
			
			status = scsi_get_nv(epc_ps_map,
			    nitems(epc_ps_map),
			    optarg, &entry_num, SCSI_NV_FLAG_IG_CASE);
			if (status == SCSI_NV_FOUND)
				power_src = epc_ps_map[entry_num].value;
			else {
				warnx("%s: %s: %s option %s", __func__,
				    (status == SCSI_NV_AMBIGUOUS) ?
				    "ambiguous" : "invalid", "power source",
				    optarg);
				error = 1;
				goto bailout;
			}
			break;
		}
		case 'T': {
			char *endptr;

			timer_val = strtod(optarg, &endptr);
			if (timer_val < 0) {
				warnx("Invalid timer value %f", timer_val);
				error = 1;
				goto bailout;
			} else if (*endptr != '\0') {
				warnx("Invalid timer value %s", optarg);
				error = 1;
				goto bailout;
			}
			timer_tenths = timer_val * 10;
			break;
		}
		default:
			break;
		}
	}

	if (action == -1) {
		warnx("Must specify an action");
		error = 1;
		goto bailout;
	}
	
	error = get_device_type(device, retry_count, timeout,
	    /*printerrors*/ 1, &devtype);
	if (error != 0)
		errx(1, "Unable to determine device type");

	switch (devtype) {
	case CC_DT_ATA:
	case CC_DT_SATL:
		break;
	default:
		warnx("The epc subcommand only works with ATA protocol "
		    "devices");
		error = 1;
		goto bailout;
		break; /*NOTREACHED*/
	}

	switch (action) {
	case ATA_SF_EPC_SET_TIMER:
		if (timer_val == -1) {
			warnx("Must specify a timer value (-T time)");
			error = 1;
		}
		/* FALLTHROUGH */
	case ATA_SF_EPC_SET_STATE:
		if (enable == -1) {
			warnx("Must specify enable (-e) or disable (-d)");
			error = 1;
		}
		/* FALLTHROUGH */
	case ATA_SF_EPC_GOTO:
		if (power_cond == -1) {
			warnx("Must specify a power condition with -p");
			error = 1;
		}
		if (error != 0)
			goto bailout;
		break;
	case ATA_SF_EPC_SET_SOURCE:
		if (power_src == -1) {
			warnx("Must specify a power source (-S battery or "
			    "-S notbattery) value");
			error = 1;
			goto bailout;
		}
		break;
	case ATA_SF_EPC_RESTORE:
		if (restore_src == -1) {
			warnx("Must specify a source for restored value, "
			    "-r default or -r saved");
			error = 1;
			goto bailout;
		}
		break;
	case ATA_SF_EPC_ENABLE:
	case ATA_SF_EPC_DISABLE:
	case CCTL_EPC_GET_STATUS:
	case CCTL_EPC_LIST:
	default:
		break;
	}

	switch (action) {
	case CCTL_EPC_GET_STATUS:
		error = epc_getmode(device, devtype, ccb, retry_count, timeout,
		    power_only);
		break;
	case CCTL_EPC_LIST:
		error = epc_list(device, devtype, ccb, retry_count, timeout);
		break;
	case ATA_SF_EPC_RESTORE:
	case ATA_SF_EPC_GOTO:
	case ATA_SF_EPC_SET_TIMER:
	case ATA_SF_EPC_SET_STATE:
	case ATA_SF_EPC_ENABLE:
	case ATA_SF_EPC_DISABLE:
	case ATA_SF_EPC_SET_SOURCE:
		error = epc_set_features(device, devtype, ccb, retry_count,
		    timeout, action, power_cond, timer_tenths, enable, save,
		    delayed_entry, hold, power_src, restore_src);
		break;
	default:
		warnx("Not implemented yet");
		error = 1;
		goto bailout;
		break;
	}


bailout:
	if (ccb != NULL)
		cam_freeccb(ccb);

	return (error);
}