sata.c revision f39c049be37ba5b8f96704f41d6532332ae16318
2N/A * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
2N/A * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
2N/Aint sata_debug_flags = 0;
2N/Aint sata_func_enable =
2N/Astatic int sata_current_max_qdepth;
2N/Aint sata_auto_online = 0;
2N/A#ifdef SATA_DEBUG
2N/A#ifdef SATA_INJECT_FAULTS
2N/A * SATA HBA interface functions are defined in sata_hba.h header file
2N/Astatic void sata_event_daemon(void *);
2N/Astatic void sata_event_thread_control(int);
2N/A sata_address_t *);
2N/A sata_address_t *);
2N/A sata_address_t *);
2N/A sata_pkt_txlate_t *, int);
2N/A sata_address_t *);
2N/A sata_device_t *);
2N/A ddi_dma_attr_t *);
2N/A struct scsi_inquiry *);
2N/A struct mode_cache_scsi3 *, int, int *, int *, int *);
2N/A struct mode_info_excpt_page *, int, int *, int *, int *);
2N/A struct mode_acoustic_management *, int, int *, int *, int *);
2N/A sata_hba_inst_t *);
2N/A sata_hba_inst_t *);
2N/A sata_hba_inst_t *);
2N/A struct smart_data *);
2N/A struct smart_selftest_log *);
2N/A struct read_log_ext_directory *);
2N/A struct scsi_extended_sense *);
2N/Astatic int sata_check_modser(char *, int);
2N/Astatic int sata_event_thread_terminate = 0;
2N/Astatic int sata_event_pending = 0;
2N/Astatic int sata_event_thread_active = 0;
2N/A#ifdef SATA_DEBUG
2N/A#ifdef SATA_DEBUG
return (rval);
int hba_attach_state = 0;
return (DDI_FAILURE);
return (DDI_FAILURE);
return (DDI_FAILURE);
return (DDI_FAILURE);
#ifdef SATA_DEBUG
goto fail;
goto fail;
sizeof (taskq_name));
#ifdef SATA_DEBUG
goto fail;
* controller/port/multipliers/device configuration and will create
return (DDI_SUCCESS);
fail:
sizeof (struct sata_hba_inst));
return (DDI_FAILURE);
int ncport;
switch (cmd) {
case DDI_DETACH:
return (DDI_FAILURE);
return (DDI_FAILURE);
return (DDI_FAILURE);
ncport++) {
ncport);
NDI_DEVI_REMOVE) !=
NDI_SUCCESS) {
return (DDI_FAILURE);
ncport++) {
sdinfo =
sizeof (sata_drive_info_t));
sizeof (sata_cport_info_t));
sizeof (struct sata_hba_inst));
return (DDI_SUCCESS);
case DDI_SUSPEND:
return (DDI_FAILURE);
return (DDI_FAILURE);
#ifndef __lock_lint
int rv = 0;
return (EINVAL);
return (ENXIO);
return (ENXIO);
return (ENXIO);
return (rv);
#ifndef __lock_lint
return (EINVAL);
return (ENXIO);
return (ENXIO);
return (ENXIO);
int *rvalp)
#ifndef __lock_lint
int rv = 0;
return (ENXIO);
return (ENXIO);
return (ENXIO);
return (ENXIO);
switch (cmd) {
case DEVCTL_DEVICE_GETSTATE:
case DEVCTL_DEVICE_ONLINE:
case DEVCTL_DEVICE_OFFLINE:
case DEVCTL_DEVICE_REMOVE:
case DEVCTL_BUS_GETSTATE:
return (EFAULT);
if (dcp)
return (EINVAL);
qual) != 0) {
return (EINVAL);
return (EBUSY);
switch (cmd) {
case DEVCTL_AP_DISCONNECT:
case DEVCTL_AP_UNCONFIGURE:
case DEVCTL_AP_CONNECT:
case DEVCTL_AP_CONFIGURE:
case DEVCTL_AP_GETSTATE:
case DEVCTL_AP_CONTROL:
#ifdef _MULTI_DATAMODEL
mode) != 0) {
return (EFAULT);
return (EINVAL);
return (EINVAL);
return (EBUSY);
case SATA_CFGA_RESET_PORT:
case SATA_CFGA_RESET_DEVICE:
&sata_device);
case SATA_CFGA_RESET_ALL:
return (rv);
case SATA_CFGA_PORT_ACTIVATE:
case SATA_CFGA_PORT_SELF_TEST:
&sata_device);
case SATA_CFGA_GET_AP_TYPE:
case SATA_CFGA_GET_MODEL_INFO:
if (rval != 0) {
if (dcp) {
return (rv);
int pkt_type)
return (NULL);
return (NULL);
switch (pkt_type) {
return (spkt);
return (spkt);
return (NULL);
#ifndef __lock_lint
&sata_device) != 0)
return (DDI_FAILURE);
return (DDI_FAILURE);
#ifdef _LITTLE_ENDIAN
if (i < SATA_ID_MODEL_LEN) {
if (vid)
if (pid)
return (DDI_SUCCESS);
int rval;
return (rval);
#ifndef __lock_lint
&sata_device) != 0)
static struct scsi_pkt *
int rval;
return (NULL);
return (NULL);
return (pkt);
* Packet was preallocated/initialized by previous call
return (pkt);
switch (rval) {
case DDI_DMA_NORESOURCES:
case DDI_DMA_NOMAPPING:
case DDI_DMA_BADATTR:
case DDI_DMA_TOOBIG:
return (NULL);
return (pkt);
int cport;
int rval;
B_FALSE ||
return (TRAN_BUSY);
return (TRAN_ACCEPT);
return (TRAN_FATAL_ERROR);
return (rval);
case SCMD_INQUIRY:
case SCMD_TEST_UNIT_READY:
case SCMD_START_STOP:
case SCMD_READ_CAPACITY:
case SCMD_REQUEST_SENSE:
case SCMD_LOG_SENSE_G1:
case SCMD_LOG_SELECT_G1:
case SCMD_MODE_SENSE:
case SCMD_MODE_SENSE_G1:
case SCMD_MODE_SELECT:
case SCMD_MODE_SELECT_G1:
case SCMD_SYNCHRONIZE_CACHE:
case SCMD_READ:
case SCMD_READ_G1:
case SCMD_READ_G4:
case SCMD_READ_G5:
case SCMD_WRITE_BUFFER:
case SCMD_WRITE:
case SCMD_WRITE_G1:
case SCMD_WRITE_G4:
case SCMD_WRITE_G5:
case SCMD_SEEK:
return (rval);
SATA_SUCCESS) {
int val;
} else if (val == 0 &&
int rval;
NULL) {
case SCSI_CAP_ARQ:
case SCSI_CAP_SECTOR_SIZE:
case SCSI_CAP_UNTAGGED_QING:
case SCSI_CAP_TAGGED_QING:
case SCSI_CAP_DMA_MAX:
&adj_dma_attr);
return (rval);
int rval;
case SCSI_CAP_ARQ:
case SCSI_CAP_SECTOR_SIZE:
case SCSI_CAP_DMA_MAX:
rval = 0;
case SCSI_CAP_UNTAGGED_QING:
} else if (value == 0) {
rval = 0;
case SCSI_CAP_TAGGED_QING:
} else if (value == 0) {
rval = 0;
return (rval);
sizeof (ddi_dma_cookie_t));
#ifndef __lock_lint
sizeof (ddi_dma_cookie_t));
#ifndef __lock_lint
int rval;
int direction;
return (TRAN_BADPKT);
return (TRAN_BUSY);
return (TRAN_ACCEPT);
return (TRAN_FATAL_ERROR);
if (!ddi_in_panic() &&
SATA_APCTL_LOCK_PORT_BUSY) == 0)) {
return (TRAN_BUSY);
SATA_APCTL_LOCK_PORT_BUSY) != 0) {
return (TRAN_ACCEPT);
#ifdef _LITTLE_ENDIAN
return (TRAN_BUSY);
return (TRAN_ACCEPT);
int rval;
int reason;
return (rval);
return (TRAN_BUSY);
return (TRAN_ACCEPT);
int count;
uint8_t *p;
return (rval);
goto done;
unsigned int bufsize;
sizeof (struct scsi_inquiry));
case INQUIRY_SUP_VPD_PAGE:
case INQUIRY_USN_PAGE:
#ifdef _LITTLE_ENDIAN
goto done;
done:
return (TRAN_BUSY);
return (TRAN_ACCEPT);
return (rval);
sizeof (struct scsi_extended_sense));
return (TRAN_BUSY);
return (TRAN_ACCEPT);
int power_state;
return (rval);
switch (power_state) {
case SATA_PWRMODE_ACTIVE:
case SATA_PWRMODE_IDLE:
return (TRAN_BUSY);
return (TRAN_ACCEPT);
int synch;
return (rval);
return (TRAN_BUSY);
return (TRAN_ACCEPT);
return (rval);
if (synch) {
return (TRAN_ACCEPT);
return (rval);
return (TRAN_BUSY);
return (TRAN_ACCEPT);
return (rval);
len = 0;
bdlen = 0;
#ifndef __lock_lint
case MODEPAGE_RW_ERRRECOV:
case MODEPAGE_CACHING:
goto done;
case MODEPAGE_INFO_EXCPT:
goto err;
case MODEPAGE_POWER_COND:
case MODEPAGE_ACOUSTIC_MANAG:
case MODEPAGE_ALLPAGES:
err:
goto done;
done:
return (TRAN_BUSY);
return (TRAN_ACCEPT);
int dmod = 0;
return (rval);
goto done;
while (pllen > 0) {
case MODEPAGE_CACHING:
goto done;
case MODEPAGE_INFO_EXCPT:
case MODEPAGE_ACOUSTIC_MANAG:
(struct mode_acoustic_management *)
goto done;
done:
if (dmod != 0) {
int rv = 0;
&new_sdinfo);
if (rv == 0) {
return (TRAN_BUSY);
return (rval);
return (rval);
switch (pc) {
case PC_CUMULATIVE_VALUES:
goto done;
switch (page_code) {
goto done;
len = 0;
switch (page_code) {
goto done;
goto done;
goto done;
goto done;
goto done;
goto no_header;
goto done;
done:
return (TRAN_BUSY);
return (TRAN_ACCEPT);
int synch;
return (rval);
case SCMD_READ:
case SCMD_READ_G1:
case SCMD_READ_G5:
case SCMD_READ_G4:
#ifndef __lock_lint
SATA_DEV_F_NCQ) &&
SATA_CTLF_NCQ)) {
SATA_DEV_F_TCQ) &&
SATA_CTLF_QCMD)) {
if (using_queuing) {
* satacmd_flags.sata_max_queue_depth.
return (rval);
if (synch) {
return (TRAN_ACCEPT);
int synch;
return (rval);
case SCMD_WRITE:
case SCMD_WRITE_G1:
case SCMD_WRITE_G5:
case SCMD_WRITE_G4:
#ifndef __lock_lint
SATA_DEV_F_NCQ) &&
SATA_CTLF_NCQ)) {
SATA_DEV_F_TCQ) &&
SATA_CTLF_QCMD)) {
if (using_queuing) {
* satacmd_flags.sata_max_queue_depth.
return (rval);
if (synch) {
return (TRAN_ACCEPT);
return (rval);
switch (mode) {
goto bad_param;
goto bad_param;
return (rval);
case SATA_PKT_PORT_ERROR:
case SATA_PKT_DEV_ERROR:
case SATA_PKT_TIMEOUT:
case SATA_PKT_ABORTED:
case SATA_PKT_RESET:
return (TRAN_ACCEPT);
TQ_SLEEP) == 0) {
return (rval);
int rval;
int retry_cnt;
for (retry_cnt = 0;
retry_cnt++) {
&sata_device);
SATA_SUCCESS) {
sdinfo);
int synch;
return (rval);
return (rval);
if (synch) {
return (TRAN_ACCEPT);
switch (stat) {
case SATA_TRAN_ACCEPTED:
case SATA_TRAN_QUEUE_FULL:
case SATA_TRAN_PORT_ERROR:
* Communication/link with device or general port error
case SATA_TRAN_BUSY:
cmd);
cmd);
return (TRAN_BUSY);
return (TRAN_ACCEPT);
* Extract error LBA from sata_pkt.satapkt_cmd register fields
*lba = 0;
static struct scsi_extended_sense *
return (sense);
return (TRAN_BUSY);
return (TRAN_ACCEPT);
int rval;
case SATA_PKT_PORT_ERROR:
case SATA_PKT_DEV_ERROR:
case SATAC_READ_DMA:
case SATAC_READ_DMA_EXT:
case SATAC_READ_DMA_QUEUED:
case SATAC_READ_FPDMA_QUEUED:
case SATAC_WRITE_DMA:
case SATAC_WRITE_DMA_EXT:
case SATAC_WRITE_DMA_QUEUED:
case SATAC_WRITE_FPDMA_QUEUED:
case SATA_PKT_TIMEOUT:
case SATA_PKT_ABORTED:
case SATA_PKT_RESET:
case SATA_PKT_PORT_ERROR:
case SATA_PKT_DEV_ERROR:
case SATA_PKT_TIMEOUT:
case SATA_PKT_ABORTED:
case SATA_PKT_RESET:
#ifndef __lock_lint
return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
sizeof (struct mode_page));
switch (pcntrl) {
case P_CNTRL_DEFAULT:
case P_CNTRL_CURRENT:
case P_CNTRL_SAVED:
#ifdef _LITTLE_ENDIAN
case P_CNTRL_CHANGEABLE:
return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
sizeof (struct mode_page));
#ifndef __lock_lint
*dmod = 0;
return (SATA_FAILURE);
return (SATA_SUCCESS);
wce = 0;
return (SATA_SUCCESS);
if (dra == 0)
return (SATA_FAILURE);
return (SATA_FAILURE);
goto failure;
return (SATA_SUCCESS);
return (SATA_FAILURE);
int parmlen,
int *pagelen,
int *rval,
int *dmod)
*dmod = 0;
return (SATA_FAILURE);
return (SATA_FAILURE);
return (SATA_SUCCESS);
return (SATA_FAILURE);
return (SATA_SUCCESS);
return (SATA_FAILURE);
*dmod = 0;
return (SATA_FAILURE);
sizeof (struct mode_page);
return (SATA_FAILURE);
return (SATA_FAILURE);
return (SATA_SUCCESS);
int rval;
ext_selftest_log, 0);
if (rval == 0) {
int count;
if (index == 0)
goto out;
if (block_num != 0) {
if (rval != 0)
goto out;
entry =
++count) {
--entry;
--index;
sizeof (empty)) == 0)
goto out;
goto out;
if (only_one_block &&
goto out;
switch (status) {
add_sense_code_qual = 0;
if (status != 0) {
if (index < 0) {
if (block_num > 0) {
--block_num;
struct read_log_ext_directory
rval =
&logdir);
goto out;
goto out;
--block_num;
(block_num == 0);
if (rval != 0)
goto out;
index =
out:
sizeof (struct smart_ext_selftest_log));
KM_SLEEP);
if (rval == 0) {
int index;
int count;
if (index == 0)
goto done;
++count) {
goto done;
switch (status) {
if (status != 0) {
if (index < 0) {
index =
done:
int rval;
/* Now get the SMART status w.r.t. threshold exceeded */
switch (rval) {
#if defined(SATA_DEBUG)
temp = 0;
int rval;
return (sizeof (struct smart_data));
int cdblen;
int synch;
return (rval);
return (TRAN_BADPKT);
case SCMD_READ:
case SCMD_READ_G1:
case SCMD_READ_G5:
case SCMD_READ_G4:
case SCMD_WRITE:
case SCMD_WRITE_G1:
case SCMD_WRITE_G5:
case SCMD_WRITE_G4:
* scmd->satacmd_flags.sata_data_direction default -
#ifdef SATA_DEBUG
return (rval);
if (synch) {
return (TRAN_ACCEPT);
int rval;
#ifdef SATA_DEBUG
#ifdef SATA_DEBUG
case SATA_PKT_PORT_ERROR:
case SATA_PKT_TIMEOUT:
case SATA_PKT_ABORTED:
case SATA_PKT_RESET:
return (SATA_FAILURE);
return (SATA_SUCCESS);
SATA_ATAPI_ID_DMADIR_REQ) != 0) {
#ifdef SATA_DEBUG
uint8_t *p;
if (count != 0) {
int rval;
#ifdef SATA_DEBUG
return (SATA_FAILURE);
return (SATA_FAILURE);
goto cleanup;
goto cleanup;
sizeof (struct scsi_inquiry));
#ifdef SATA_DEBUG
#ifdef SATA_DEBUG
case SATA_PKT_PORT_ERROR:
case SATA_PKT_TIMEOUT:
case SATA_PKT_ABORTED:
case SATA_PKT_RESET:
return (rval);
#ifdef SATA_DEBUG
int rval;
goto cleanup;
case SATA_PKT_PORT_ERROR:
case SATA_PKT_TIMEOUT:
case SATA_PKT_ABORTED:
case SATA_PKT_RESET:
return (SATA_FAILURE);
return (SATA_FAILURE);
NULL) {
return (SATA_SUCCESS);
#ifdef SATA_DEBUG
if (sata_hba_list) {
if (sata_hba_list_tail) {
int rval;
DDI_SUCCESS) {
ncport);
KM_SLEEP);
SATA_SUCCESS) {
goto reprobe_cport;
KM_SLEEP);
NULL);
for (npmport = 0;
npmport++) {
0) != DDI_SUCCESS) {
&sata_device);
sizeof (sata_drive_info_t),
KM_SLEEP);
goto reprobe_pmport;
int pmport)
int rval;
return (SATA_FAILURE);
return (SATA_SUCCESS);
return (SATA_SUCCESS);
return (SATA_SUCCESS);
return (SATA_FAILURE);
return (SATA_SUCCESS);
return (SATA_SUCCESS);
return (SATA_SUCCESS);
static dev_info_t *
int rval;
int ncompatible;
int target;
target));
return (NULL);
return (NULL);
#ifdef SATA_DEBUG
target);
for (i = 0; i < ncompatible; i++) {
return (NULL);
goto fail;
goto fail;
goto fail;
goto fail;
(void *)cdip));
goto fail;
return (cdip);
return (NULL);
fail:
return (NULL);
int flag)
int prev_device_settings = 0;
int prev_device_state = 0;
int rval;
return (SATA_FAILURE);
return (SATA_SUCCESS);
return (SATA_SUCCESS);
return (SATA_SUCCESS);
return (SATA_SUCCESS);
return (rval);
return (SATA_SUCCESS);
if (retry) {
goto retry_probe;
return (SATA_SUCCESS);
int rval;
SATA_VALIDINFO_88) != 0 &&
SATA_MDMA_SEL_MASK) != 0) {
return (rval);
else if (sata_write_cache == 0)
else if (sata_atapicdvd_write_cache == 0)
goto invalid_address;
goto invalid_address;
goto invalid_address;
goto out;
goto out;
goto out;
SATA_VALID_DEV_TYPE) == 0) {
goto out;
goto out;
NULL ||
goto out;
pmport);
goto out;
goto out;
out:
return (rval);
static dev_info_t *
#ifndef __lock_lint
return (NULL);
return (dip);
int rval;
return (SATA_FAILURE);
return (SATA_FAILURE);
return (SATA_SUCCESS);
return (rval);
static sata_drive_info_t *
return (NULL);
return (NULL);
return (NULL);
return (NULL);
return (NULL);
return (NULL);
return (NULL);
int rval;
sdinfo)) != 0)
goto fail_unknown;
SATA_ATAPI_TYPE) &&
goto fail_unknown;
goto fail_unknown;
return (SATA_SUCCESS);
return (rval);
int valid_version;
#ifdef SATA_DEBUG
valid_version = i;
if (!(sata_func_enable &
#ifdef __i386
static uint64_t
return (capacity);
static struct buf *
return (bp);
static sata_pkt_t *
int kmsflag;
return (NULL);
return (spkt);
* If a device is being probed/initialized, there are
int rval;
rval));
return (rval);
&bufsz,
(void) ddi_dma_free_handle(
#ifdef SATA_DEBUG
return (rval);
#ifdef SATA_DEBUG
mbuf_count++;
NULL,
switch (rval) {
case DDI_DMA_PARTIAL_MAP:
(void) ddi_dma_unbind_handle(
(void) ddi_dma_free_handle(
return (DDI_FAILURE);
case DDI_DMA_MAPPED:
return (rval);
return (DDI_SUCCESS);
sizeof (ddi_dma_cookie_t));
KM_SLEEP);
return (DDI_DMA_NORESOURCES);
return (DDI_SUCCESS);
int rval;
#ifdef SATA_INJECT_FAULTS
goto fail;
sizeof (sata_id_t));
fail:
return (rval);
int i, mode;
return (SATA_FAILURE);
if (i >= mode)
return (SATA_SUCCESS);
if (i >= mode)
return (SATA_SUCCESS);
return (SATA_SUCCESS);
goto done;
done:
return (rval);
int cache_op)
char *infop;
goto failure;
switch (cache_op) {
return (rval);
int state)
char *infop;
goto failure;
if (state == 0)
if (state == 0)
return (rval);
static int32_t
port));
return (port);
static dev_info_t *
int ncport;
int circ;
return (cdip);
static dev_info_t *
int circ;
return (cdip);
* is inserted/re-inserted. The event daemon will repeatedly try to unconfigure
int rv = 0;
return (EINVAL);
return (EIO);
cport));
NULL;
return (rv);
int rv = 0;
return (EINVAL);
return (EIO);
return (rv);
int rv = 0;
return (rv);
int rval;
return (ENXIO);
return (ENXIO);
return (EIO);
return (EIO);
return (ENXIO);
cport);
return (EIO);
return (EIO);
return (EIO);
return (ENOTSUP);
SATA_VALID_DEV_TYPE) != 0)
NDI_SUCCESS) {
return (rv);
return (ENOTSUP);
return (EIO);
cport);
int rv = 0;
return (ENOTSUP);
return (rv);
int rv = 0;
return (ENOTSUP);
return (EINVAL);
* or port disconnect/connect and re-probing is
return (rv);
int rv = 0;
int tcport;
int tpmport = 0;
return (ENOTSUP);
if (rv == 0) {
return (EIO);
tcport++) {
return (rv);
int rv = 0;
return (ENOTSUP);
return (EIO);
return (rv);
int port_state;
case SATA_DTYPE_NONE:
case SATA_DTYPE_UNKNOWN:
case SATA_DTYPE_ATAPINONCD:
case SATA_DTYPE_ATADISK:
case SATA_DTYPE_ATAPICD:
int circ;
cport));
cport);
SATA_DSTATE_FAILED) != 0)
cport));
return (EINVAL);
mode) != 0)
return (EFAULT);
return (EINVAL);
mode) != 0)
return (EFAULT);
const char *ap_type;
int dev_type;
switch (dev_type) {
case SATA_DTYPE_NONE:
case SATA_DTYPE_ATADISK:
case SATA_DTYPE_ATAPICD:
case SATA_DTYPE_PMULT:
case SATA_DTYPE_UNKNOWN:
mode) != 0)
return (EFAULT);
return (EINVAL);
return (EFAULT);
return (EINVAL);
#ifdef _LITTLE_ENDIAN
mode) != 0)
return (EFAULT);
return (EINVAL);
mode) != 0)
return (EFAULT);
return (EINVAL);
#ifdef _LITTLE_ENDIAN
mode) != 0)
return (EFAULT);
return (EINVAL);
mode) != 0)
return (EFAULT);
return (EINVAL);
#ifdef _LITTLE_ENDIAN
mode) != 0)
return (EFAULT);
return (EINVAL);
mode) != 0)
return (EFAULT);
* This function is derived from cmdk_devid_setup() function in cmdk.c.
char *hwid;
int modlen;
int serlen;
int rval;
if (modlen == 0)
goto err;
if (serlen == 0)
goto err;
/* initialize/register devid */
err:
int tb;
char ch;
s = buf;
for (i = 0; i < buf_len; i++) {
ch = *s++;
* In such case the explicit port disconnect/connect or physical device
char *finfox;
int cache_op;
return (SATA_FAILURE);
SATA_SUCCESS) {
return (SATA_FAILURE);
SATA_RM_STATUS_NOTIFIC))) ||
SATA_SUCCESS) {
goto update_sdinfo;
goto update_sdinfo;
return (rval);
int rval;
goto fail;
goto fail;
rval = 0;
goto fail;
fail:
return (rval);
int rval;
#if ! defined(lint)
sizeof (struct smart_data));
goto fail;
sizeof (struct smart_data));
fail:
return (rval);
int rval;
#if ! defined(lint)
sizeof (struct smart_ext_selftest_log));
goto fail;
sizeof (struct smart_ext_selftest_log));
rval = 0;
fail:
return (rval);
int rval;
#if ! defined(lint)
sizeof (struct smart_selftest_log));
goto fail;
sizeof (struct smart_selftest_log));
rval = 0;
fail:
return (rval);
int rval;
goto fail;
rval = 0;
fail:
return (rval);
int rval;
#if ! defined(lint)
sizeof (struct read_log_ext_directory));
goto fail;
sizeof (struct read_log_ext_directory));
rval = 0;
fail:
return (rval);
#ifndef __lock_lint
sizeof (struct sata_ncq_error_recovery_page));
return (SATA_FAILURE);
return (SATA_SUCCESS);
case SATA_PKT_PORT_ERROR:
case SATA_PKT_DEV_ERROR:
case SATA_PKT_TIMEOUT:
case SATA_PKT_ABORTED:
case SATA_PKT_RESET:
pathname[0] = 0;
if (sata_debug_flags == 0)
} else if (sata_msg) {
static int sata_event_thread_terminating = 0;
static int sata_event_thread_starting = 0;
#ifdef SATA_DEBUG
(void (*)())sata_event_daemon,
#ifdef SATA_DEBUG
char *lcp;
static char *err_msg_evnt_1 =
static char *err_msg_evnt_2 =
int linkevent;
goto event_info;
pstats =
pstats =
if (linkevent) {
linkevent = 0;
goto event_info;
if (sata_event_thread_active == 0)
#ifndef __lock_lint
loop:
SATA_EVNT_SKIP) != 0) {
goto loop;
#ifdef SATA_DEBUG
if (sata_event_thread_active != 0) {
goto loop;
int ncport;
NULL);
if ((event_flags &
saddr);
saddr);
saddr);
if (event_flags &
saddr);
saddr);
SATA_DTYPE_NONE) &&
saddr);
int rval;
SATA_VALID_DEV_TYPE) == 0) {
#ifdef SATA_DEBUG
#ifdef SATA_DEBUG
SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
SATA_FAILURE) {
SATA_VALID_DEV_TYPE) != 0 &&
int rval;
goto linklost;
NULL);
SATA_VALID_DEV_TYPE) != 0) {
goto done;
#ifdef SATA_DEBUG
if ((cur_time -
done:
if (event_flags != 0) {
int rval;
sizeof (sata_drive_info_t));
int rval;
sizeof (sata_drive_info_t));
if ((cur_time -
cportinfo));
&new_sdinfo);
#ifdef SATA_DEBUG
if (sata_auto_online != 0) {
if (event_flags != 0) {
NDI_SUCCESS) {
int hint)
int err;
if (err != 0) {
if (err != 0) {
if (err != 0) {
int circ;
static boolean_t
return (B_TRUE);
return (B_FALSE);
#ifdef SATA_INJECT_FAULTS
int fault)
if (fault == 0)
if (sata_inject_fault_count == 0)
sata_fault_count = 0;
if (sata_fault_suspend_count == 0)
if (sata_fault_count != 0)
switch (fault) {
case SATA_PKT_BUSY:
case SATA_PKT_QUEUE_FULL:
case SATA_PKT_CMD_UNSUPPORTED:
case SATA_PKT_PORT_ERROR:
case SATA_PKT_DEV_ERROR:
case SATA_PKT_ABORTED:
case SATA_PKT_TIMEOUT:
case SATA_PKT_RESET: