/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*

 * SATA Framework

 * Generic SATA Host Adapter Implementation

 */

#include <sys/conf.h>

#include <sys/file.h>

#include <sys/ddi.h>

#include <sys/sunddi.h>

#include <sys/modctl.h>

#include <sys/cmn_err.h>

#include <sys/errno.h>

#include <sys/thread.h>

#include <sys/kstat.h>

#include <sys/note.h>

#include <sys/sysevent.h>

#include <sys/sysevent/eventdefs.h>

#include <sys/sysevent/dr.h>

#include <sys/taskq.h>

#include <sys/disp.h>

#include <sys/sata/impl/sata.h>

#include <sys/sata/sata_hba.h>

#include <sys/sata/sata_defs.h>

#include <sys/sata/sata_cfgadm.h>

/* Debug flags - defined in sata.h */

int	sata_debug_flags = 0;

int	sata_msg = 0;

/*

 * Flags enabling selected SATA HBA framework functionality

 */

#define	SATA_ENABLE_QUEUING		1

#define	SATA_ENABLE_NCQ			2

#define	SATA_ENABLE_PROCESS_EVENTS	4

int sata_func_enable =

	SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ;

/*

 * Global variable setting default maximum queue depth (NCQ or TCQ)

 * Note:minimum queue depth is 1

 */

int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */

/*

 * Currently used default NCQ/TCQ queue depth. It is set-up during the driver

 * initialization, using value from sata_max_queue_depth

 * It is adjusted to minimum supported by the controller and by the device,

 * if queueing is enabled.

 */

static	int sata_current_max_qdepth;

/*

 * Global variable determining the default behavior after device hotpluggin.

 * If non-zero, the hotplugged device is onlined (if possible) without explicit

 * IOCTL request (AP_CONFIGURE).

 * If zero, hotplugged device is identified, but not onlined.

 * Enabling (AP_CONNECT) device port with an attached device does not result

 * in device onlining regardless of the flag setting

 */

int sata_auto_online = 0;

#ifdef SATA_DEBUG

#define	SATA_LOG_D(args)	sata_log args

uint64_t mbuf_count = 0;

uint64_t mbuffail_count = 0;

sata_atapi_cmd_t sata_atapi_trace[64];

uint32_t sata_atapi_trace_index = 0;

int sata_atapi_trace_save = 1;

static	void sata_save_atapi_trace(sata_pkt_txlate_t *, int);

#define	SATAATAPITRACE(spx, count)	if (sata_atapi_trace_save) \

    sata_save_atapi_trace(spx, count);

#else

#define	SATA_LOG_D(args)	sata_trace_log args

#define	SATAATAPITRACE(spx, count)

#endif

#if 0

static void

sata_test_atapi_packet_command(sata_hba_inst_t *, int);

#endif

#ifdef SATA_INJECT_FAULTS

#define		SATA_INJECT_PKT_FAULT	1

uint32_t	sata_inject_fault = 0;

uint32_t	sata_inject_fault_count = 0;

uint32_t	sata_inject_fault_pause_count = 0;

uint32_t	sata_fault_type = 0;

uint32_t	sata_fault_cmd = 0;

dev_info_t	*sata_fault_ctrl = NULL;

sata_device_t	sata_fault_device;

static	void sata_inject_pkt_fault(sata_pkt_t *, int *, int);

#endif

#define	LEGACY_HWID_LEN	64	/* Model (40) + Serial (20) + pad */

static char sata_rev_tag[] = {"1.43"};

/*

 * SATA cb_ops functions

 */

static 	int sata_hba_open(dev_t *, int, int, cred_t *);

static 	int sata_hba_close(dev_t, int, int, cred_t *);

static 	int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *,	int *);

/*

 * SCSA required entry points

 */

static	int sata_scsi_tgt_init(dev_info_t *, dev_info_t *,

    scsi_hba_tran_t *, struct scsi_device *);

static	int sata_scsi_tgt_probe(struct scsi_device *,

    int (*callback)(void));

static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *,

    scsi_hba_tran_t *, struct scsi_device *);

static 	int sata_scsi_start(struct scsi_address *, struct scsi_pkt *);

static 	int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *);

static 	int sata_scsi_reset(struct scsi_address *, int);

static 	int sata_scsi_getcap(struct scsi_address *, char *, int);

static 	int sata_scsi_setcap(struct scsi_address *, char *, int, int);

static 	struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *,

    struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t),

    caddr_t);

static 	void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *);

static 	void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);

static 	void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *);

/*

 * SATA HBA interface functions are defined in sata_hba.h header file

 */

/* Event processing functions */

static	void sata_event_daemon(void *);

static	void sata_event_thread_control(int);

static	void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst);

static	void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *);

static	void sata_process_port_failed_event(sata_hba_inst_t *,

    sata_address_t *);

static	void sata_process_port_link_events(sata_hba_inst_t *,

    sata_address_t *);

static	void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *);

static	void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *);

static	void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *);

static	void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *);

static	void sata_process_target_node_cleanup(sata_hba_inst_t *,

    sata_address_t *);

static	void sata_process_device_autoonline(sata_hba_inst_t *,

    sata_address_t *saddr);

/*

 * Local translation functions

 */

static	int sata_txlt_inquiry(sata_pkt_txlate_t *);

static	int sata_txlt_test_unit_ready(sata_pkt_txlate_t *);

static	int sata_txlt_start_stop_unit(sata_pkt_txlate_t *);

static	int sata_txlt_read_capacity(sata_pkt_txlate_t *);

static	int sata_txlt_request_sense(sata_pkt_txlate_t *);

static	int sata_txlt_read(sata_pkt_txlate_t *);

static	int sata_txlt_write(sata_pkt_txlate_t *);

static	int sata_txlt_log_sense(sata_pkt_txlate_t *);

static	int sata_txlt_log_select(sata_pkt_txlate_t *);

static	int sata_txlt_mode_sense(sata_pkt_txlate_t *);

static	int sata_txlt_mode_select(sata_pkt_txlate_t *);

static	int sata_txlt_synchronize_cache(sata_pkt_txlate_t *);

static	int sata_txlt_write_buffer(sata_pkt_txlate_t *);

static	int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *);

static	int sata_hba_start(sata_pkt_txlate_t *, int *);

static	int sata_txlt_invalid_command(sata_pkt_txlate_t *);

static	int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t);

static	int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *);

static	void sata_txlt_rw_completion(sata_pkt_t *);

static	void sata_txlt_nodata_cmd_completion(sata_pkt_t *);

static	void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *);

static	int sata_emul_rw_completion(sata_pkt_txlate_t *);

static	struct scsi_extended_sense *sata_immediate_error_response(

    sata_pkt_txlate_t *, int);

static	struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *);

static	int sata_txlt_atapi(sata_pkt_txlate_t *);

static	void sata_txlt_atapi_completion(sata_pkt_t *);

/*

 * Local functions for ioctl

 */

static	int32_t sata_get_port_num(sata_hba_inst_t *,  struct devctl_iocdata *);

static	void sata_cfgadm_state(sata_hba_inst_t *, int32_t,

    devctl_ap_state_t *);

static	dev_info_t *sata_get_target_dip(dev_info_t *, int32_t);

static	dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *);

static	dev_info_t *sata_devt_to_devinfo(dev_t);

static	int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *);

static	int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *);

static	int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *);

static	int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *);

static	int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *);

static	int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *);

static	int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *);

static	int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *);

static	int sata_ioctl_reset_all(sata_hba_inst_t *);

static	int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *);

static	int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *,

    sata_ioctl_data_t *, int mode);

static	int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *,

    sata_ioctl_data_t *, int mode);

static	int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *,

    sata_ioctl_data_t *, int mode);

static	int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *,

    sata_ioctl_data_t *, int mode);

static	int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *,

    sata_device_t *, sata_ioctl_data_t *, int mode);

/*

 * Local functions

 */

static 	void sata_remove_hba_instance(dev_info_t *);

static 	int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *);

static 	void sata_probe_ports(sata_hba_inst_t *);

static 	int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int);

static 	int sata_add_device(dev_info_t *, sata_hba_inst_t *, int cport,

    int pmport);

static 	dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *,

    sata_address_t *);

static 	int sata_validate_scsi_address(sata_hba_inst_t *,

    struct scsi_address *, sata_device_t *);

static 	int sata_validate_sata_address(sata_hba_inst_t *, int, int, int);

static	sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t));

static	void sata_pkt_free(sata_pkt_txlate_t *);

static	int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t),

    caddr_t, ddi_dma_attr_t *);

static	void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *);

static	int sata_probe_device(sata_hba_inst_t *, sata_device_t *);

static	sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *,

    sata_device_t *);

static 	int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *);

static	void sata_reidentify_device(sata_pkt_txlate_t *);

static	struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int);

static 	void sata_free_local_buffer(sata_pkt_txlate_t *);

static 	uint64_t sata_check_capacity(sata_drive_info_t *);

void 	sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *,

    ddi_dma_attr_t *);

static 	int sata_fetch_device_identify_data(sata_hba_inst_t *,

    sata_drive_info_t *);

static	void sata_update_port_info(sata_hba_inst_t *, sata_device_t *);

static	void sata_update_port_scr(sata_port_scr_t *, sata_device_t *);

static	int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *);

static	int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int);

static	int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int);

static	int sata_set_drive_features(sata_hba_inst_t *,

    sata_drive_info_t *, int flag);

static	void sata_init_write_cache_mode(sata_drive_info_t *sdinfo);

static	int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *);

static	void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *,

    uint8_t *);

static	int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *,

    struct scsi_inquiry *);

static	int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *);

static	int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *);

static	int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *);

static	int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *);

static	int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *);

static	int sata_mode_select_page_8(sata_pkt_txlate_t *,

    struct mode_cache_scsi3 *, int, int *, int *, int *);

static	int sata_mode_select_page_1a(sata_pkt_txlate_t *,

    struct mode_info_power_cond *, int, int *, int *, int *);

static	int sata_mode_select_page_1c(sata_pkt_txlate_t *,

    struct mode_info_excpt_page *, int, int *, int *, int *);

static	int sata_mode_select_page_30(sata_pkt_txlate_t *,

    struct mode_acoustic_management *, int, int *, int *, int *);

static	int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *);

static	int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *,

    sata_hba_inst_t *);

static	int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *,

    sata_hba_inst_t *);

static	int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *,

    sata_hba_inst_t *);

static	int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *,

    sata_pkt_txlate_t *);

static	void sata_set_arq_data(sata_pkt_t *);

static	void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t);

static	void sata_build_generic_cmd(sata_cmd_t *, uint8_t);

static	uint8_t sata_get_standby_timer(uint8_t *timer);

static	void sata_save_drive_settings(sata_drive_info_t *);

static	void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *);

static	void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...);

static	void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...);

static	int sata_fetch_smart_return_status(sata_hba_inst_t *,

    sata_drive_info_t *);

static	int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *,

    struct smart_data *);

static	int sata_smart_selftest_log(sata_hba_inst_t *,

    sata_drive_info_t *,

    struct smart_selftest_log *);

static	int sata_ext_smart_selftest_read_log(sata_hba_inst_t *,

    sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t);

static	int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *,

    uint8_t *, uint8_t, uint8_t);

static	int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *,

    struct read_log_ext_directory *);

static	void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int);

static	void sata_xlate_errors(sata_pkt_txlate_t *);

static	void sata_decode_device_error(sata_pkt_txlate_t *,

    struct scsi_extended_sense *);

static	void sata_set_device_removed(dev_info_t *);

static	boolean_t sata_check_device_removed(dev_info_t *);

static	void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *);

static	int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *,

    sata_drive_info_t *);

static	int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *,

    sata_drive_info_t *);

static	void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *);

static	void sata_fixed_sense_data_preset(struct scsi_extended_sense *);

static  void sata_target_devid_register(dev_info_t *, sata_drive_info_t *);

static  int sata_check_modser(char *, int);

/*

 * SATA Framework will ignore SATA HBA driver cb_ops structure and

 * register following one with SCSA framework.

 * Open & close are provided, so scsi framework will not use its own

 */

static struct cb_ops sata_cb_ops = {

	sata_hba_open,			/* open */

	sata_hba_close,			/* close */

	nodev,				/* strategy */

	nodev,				/* print */

	nodev,				/* dump */

	nodev,				/* read */

	nodev,				/* write */

	sata_hba_ioctl,			/* ioctl */

	nodev,				/* devmap */

	nodev,				/* mmap */

	nodev,				/* segmap */

	nochpoll,			/* chpoll */

	ddi_prop_op,			/* cb_prop_op */

	0,				/* streamtab */

	D_NEW | D_MP,			/* cb_flag */

	CB_REV,				/* rev */

	nodev,				/* aread */

	nodev				/* awrite */

};

extern struct mod_ops mod_miscops;

extern uchar_t	scsi_cdb_size[];

static struct modlmisc modlmisc = {

	&mod_miscops,			/* Type of module */

	"SATA Module"			/* module name */

};

static struct modlinkage modlinkage = {

	MODREV_1,

	(void *)&modlmisc,

	NULL

};

/*

 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero,

 * i.e. when scsi_pkt has not timeout specified.

 */

static int sata_default_pkt_time = 60;	/* 60 seconds */

/*

 * Intermediate buffer device access attributes - they are required,

 * but not necessarily used.

 */

static ddi_device_acc_attr_t sata_acc_attr = {

	DDI_DEVICE_ATTR_V0,

	DDI_STRUCTURE_LE_ACC,

	DDI_STRICTORDER_ACC

};

/*

 * Mutexes protecting structures in multithreaded operations.

 * Because events are relatively rare, a single global mutex protecting

 * data structures should be sufficient. To increase performance, add

 * separate mutex per each sata port and use global mutex only to protect

 * common data structures.

 */

static	kmutex_t sata_mutex;		/* protects sata_hba_list */

static	kmutex_t sata_log_mutex;	/* protects log */

static 	char sata_log_buf[256];

/*

 * sata trace debug

 */

static	sata_trace_rbuf_t *sata_debug_rbuf;

static	sata_trace_dmsg_t *sata_trace_dmsg_alloc(void);

static	void sata_trace_dmsg_free(void);

static	void sata_trace_rbuf_alloc(void);

static	void sata_trace_rbuf_free(void);

int	dmsg_ring_size = DMSG_RING_SIZE;

/* Default write cache setting for SATA hard disks */

int	sata_write_cache = 1;		/* enabled */

/* Default write cache setting for SATA ATAPI CD/DVD */

int	sata_atapicdvd_write_cache = 1; /* enabled */

/* Default write cache setting for SATA ATAPI tape */

int	sata_atapitape_write_cache = 1; /* enabled */

/* Default write cache setting for SATA ATAPI disk */

int	sata_atapidisk_write_cache = 1;	/* enabled */

/*

 * Linked list of HBA instances

 */

static 	sata_hba_inst_t *sata_hba_list = NULL;

static 	sata_hba_inst_t *sata_hba_list_tail = NULL;

/*

 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran

 * structure and in sata soft state.

 */

/*

 * Event daemon related variables

 */

static 	kmutex_t sata_event_mutex;

static 	kcondvar_t sata_event_cv;

static 	kthread_t *sata_event_thread = NULL;

static 	int sata_event_thread_terminate = 0;

static 	int sata_event_pending = 0;

static 	int sata_event_thread_active = 0;

extern 	pri_t minclsyspri;

/*

 * NCQ error recovery command

 */

static const sata_cmd_t sata_rle_cmd = {

	SATA_CMD_REV,

	NULL,

	{

		SATA_DIR_READ

	},

	ATA_ADDR_LBA48,

	0,

	0,

	0,

	0,

	0,

	1,

	READ_LOG_EXT_NCQ_ERROR_RECOVERY,

	0,

	0,

	0,

	SATAC_READ_LOG_EXT,

	0,

	0,

	0,

};

/*

 * ATAPI error recovery CDB

 */

static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = {

	SCMD_REQUEST_SENSE,

	0,			/* Only fixed RQ format is supported */

	0,