diff options
Diffstat (limited to 'scsiata.cpp')
| -rw-r--r-- | scsiata.cpp | 1548 |
1 files changed, 1548 insertions, 0 deletions
diff --git a/scsiata.cpp b/scsiata.cpp new file mode 100644 index 0000000..3ad6e6b --- /dev/null +++ b/scsiata.cpp @@ -0,0 +1,1548 @@ +/* + * scsiata.cpp + * + * Home page of code is: https://www.smartmontools.org + * + * Copyright (C) 2006-15 Douglas Gilbert <dgilbert@interlog.com> + * Copyright (C) 2009-23 Christian Franke + * + * SPDX-License-Identifier: GPL-2.0-or-later + * + * The code in this file is based on the SCSI to ATA Translation (SAT) + * draft found at http://www.t10.org . The original draft used for this + * code is sat-r08.pdf which is not too far away from becoming a + * standard. The SAT commands of interest to smartmontools are the + * ATA PASS THROUGH SCSI (16) and ATA PASS THROUGH SCSI (12) defined in + * section 12 of that document. + * + * sat-r09.pdf is the most recent, easily accessible draft prior to the + * original SAT standard (ANSI INCITS 431-2007). By mid-2009 the second + * version of the SAT standard (SAT-2) is nearing standardization. In + * their wisdom an incompatible change has been introduced in draft + * sat2r08a.pdf in the area of the ATA RETURN DESCRIPTOR. A new "fixed + * format" ATA RETURN buffer has been defined (sat2r08b.pdf section + * 12.2.7) for the case when DSENSE=0 in the Control mode page. + * Unfortunately this is the normal case. If the change stands our + * code will need to be extended for this case. + * + * With more transports "hiding" SATA disks (and other S-ATAPI devices) + * behind a SCSI command set, accessing special features like SMART + * information becomes a challenge. The SAT standard offers ATA PASS + * THROUGH commands for special usages. Note that the SAT layer may + * be inside a generic OS layer (e.g. libata in linux), in a host + * adapter (HA or HBA) firmware, or somewhere on the interconnect + * between the host computer and the SATA devices (e.g. a RAID made + * of SATA disks and the RAID talks "SCSI" to the host computer). + * Note that in the latter case, this code does not solve the + * addressing issue (i.e. which SATA disk to address behind the logical + * SCSI (RAID) interface). + * + */ + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <ctype.h> +#include <errno.h> + +#include "config.h" + +#include "scsicmds.h" +#include "atacmds.h" // ataReadHDIdentity() +#include "knowndrives.h" // lookup_usb_device() +#include "utility.h" +#include "dev_interface.h" +#include "dev_ata_cmd_set.h" // ata_device_with_command_set +#include "dev_tunnelled.h" // tunnelled_device<> +#include "sg_unaligned.h" + +const char * scsiata_cpp_cvsid = "$Id: scsiata.cpp 5482 2023-06-25 16:46:49Z chrfranke $"; + +/* This is a slightly stretched SCSI sense "descriptor" format header. + The addition is to allow the 0x70 and 0x71 response codes. The idea + is to place the salient data of both "fixed" and "descriptor" sense + format into one structure to ease application processing. + The original sense buffer should be kept around for those cases + in which more information is required (e.g. the LBA of a MEDIUM ERROR). */ +/// Abridged SCSI sense data +struct sg_scsi_sense_hdr { + unsigned char response_code; /* permit: 0x0, 0x70, 0x71, 0x72, 0x73 */ + unsigned char sense_key; + unsigned char asc; + unsigned char ascq; + unsigned char byte4; + unsigned char byte5; + unsigned char byte6; + unsigned char additional_length; +}; + +/* Maps the salient data from a sense buffer which is in either fixed or + descriptor format into a structure mimicking a descriptor format + header (i.e. the first 8 bytes of sense descriptor format). + If zero response code returns 0. Otherwise returns 1 and if 'sshp' is + non-NULL then zero all fields and then set the appropriate fields in + that structure. sshp::additional_length is always 0 for response + codes 0x70 and 0x71 (fixed format). */ +static int sg_scsi_normalize_sense(const unsigned char * sensep, int sb_len, + struct sg_scsi_sense_hdr * sshp); + +#define SAT_ATA_PASSTHROUGH_12LEN 12 +#define SAT_ATA_PASSTHROUGH_16LEN 16 + +#define DEF_SAT_ATA_PASSTHRU_SIZE 16 +#define ATA_RETURN_DESCRIPTOR 9 + + +namespace sat { // no need to publish anything, name provided for Doxygen + +/// SAT support. +/// Implements ATA by tunnelling through SCSI. + +class sat_device +: public tunnelled_device< + /*implements*/ ata_device + /*by tunnelling through a*/, scsi_device + >, + virtual public /*implements*/ scsi_device +{ +public: + enum sat_scsi_mode { + sat_always, + sat_auto, + scsi_always + }; + enum sat_variant { + sat_standard, + sat_asm1352r, // ASM1352R port 0 or 1 + }; + + sat_device(smart_interface * intf, scsi_device * scsidev, + const char * req_type, sat_scsi_mode mode = sat_always, int passthrulen = 0, + sat_variant variant = sat_standard, int port = 0); + + virtual ~sat_device(); + + virtual smart_device * autodetect_open() override; + + virtual bool ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out) override; + + virtual bool scsi_pass_through(scsi_cmnd_io * iop) override; + +private: + int m_passthrulen; + sat_scsi_mode m_mode; + sat_variant m_variant; + int m_port; +}; + + +sat_device::sat_device(smart_interface * intf, scsi_device * scsidev, + const char * req_type, sat_scsi_mode mode /* = sat_always */, + int passthrulen /* = 0 */, sat_variant variant /* = sat_standard */, int port /* = 0 */) +: smart_device(intf, scsidev->get_dev_name(), + (mode == sat_always ? "sat" : mode == sat_auto ? "sat,auto" : "scsi"), req_type), + tunnelled_device<ata_device, scsi_device>(scsidev), + m_passthrulen(passthrulen), + m_mode(mode), + m_variant(variant), m_port(port) +{ + if (mode != sat_always) + hide_ata(); // Start as SCSI, switch to ATA in autodetect_open() + else + hide_scsi(); // ATA always + if (strcmp(scsidev->get_dev_type(), "scsi")) + set_info().dev_type += strprintf("+%s", scsidev->get_dev_type()); + + set_info().info_name = strprintf("%s [%s]", scsidev->get_info_name(), + (variant == sat_standard ? + (mode == sat_always ? "SAT" : mode == sat_auto ? "SCSI/SAT" : "SCSI") : + (port == 0 ? "ASM1352R_0" : "ASM1352R_1") )); +} + +sat_device::~sat_device() +{ +} + + +// cdb[0]: ATA PASS THROUGH (16) SCSI command opcode byte (0x85) +// cdb[1]: multiple_count, protocol + extend +// cdb[2]: offline, ck_cond, t_dir, byte_block + t_length +// cdb[3]: features (15:8) +// cdb[4]: features (7:0) +// cdb[5]: sector_count (15:8) +// cdb[6]: sector_count (7:0) +// cdb[7]: lba_low (15:8) +// cdb[8]: lba_low (7:0) +// cdb[9]: lba_mid (15:8) +// cdb[10]: lba_mid (7:0) +// cdb[11]: lba_high (15:8) +// cdb[12]: lba_high (7:0) +// cdb[13]: device +// cdb[14]: (ata) command +// cdb[15]: control (SCSI, leave as zero) +// +// 24 bit lba (from MSB): cdb[12] cdb[10] cdb[8] +// 48 bit lba (from MSB): cdb[11] cdb[9] cdb[7] cdb[12] cdb[10] cdb[8] +// +// +// cdb[0]: ATA PASS THROUGH (12) SCSI command opcode byte (0xa1) +// cdb[1]: multiple_count, protocol + extend +// cdb[2]: offline, ck_cond, t_dir, byte_block + t_length +// cdb[3]: features (7:0) +// cdb[4]: sector_count (7:0) +// cdb[5]: lba_low (7:0) +// cdb[6]: lba_mid (7:0) +// cdb[7]: lba_high (7:0) +// cdb[8]: device +// cdb[9]: (ata) command +// cdb[10]: reserved +// cdb[11]: control (SCSI, leave as zero) +// +// +// ATA Return Descriptor (component of descriptor sense data) +// des[0]: descriptor code (0x9) +// des[1]: additional descriptor length (0xc) +// des[2]: extend (bit 0) +// des[3]: error +// des[4]: sector_count (15:8) +// des[5]: sector_count (7:0) +// des[6]: lba_low (15:8) +// des[7]: lba_low (7:0) +// des[8]: lba_mid (15:8) +// des[9]: lba_mid (7:0) +// des[10]: lba_high (15:8) +// des[11]: lba_high (7:0) +// des[12]: device +// des[13]: status +// +// +// ATA registers returned via fixed format sense (allowed >= SAT-2) +// fxs[0]: info_valid (bit 7); response_code (6:0) +// fxs[1]: (obsolete) +// fxs[2]: sense_key (3:0) --> recovered error (formerly 'no sense') +// fxs[3]: information (31:24) --> ATA Error register +// fxs[4]: information (23:16) --> ATA Status register +// fxs[5]: information (15:8) --> ATA Device register +// fxs[6]: information (7:0) --> ATA Count (7:0) +// fxs[7]: additional sense length [should be >= 10] +// fxs[8]: command specific info (31:24) --> Extend (7), count_upper_nonzero +// (6), lba_upper_nonzero(5), log_index (3:0) +// fxs[9]: command specific info (23:16) --> ATA LBA (7:0) +// fxs[10]: command specific info (15:8) --> ATA LBA (15:8) +// fxs[11]: command specific info (7:0) --> ATA LBA (23:16) +// fxs[12]: additional sense code (asc) --> 0x0 +// fxs[13]: additional sense code qualifier (ascq) --> 0x1d +// asc,ascq = 0x0,0x1d --> 'ATA pass through information available' + + + +// PURPOSE +// This interface routine takes ATA SMART commands and packages +// them in the SAT-defined ATA PASS THROUGH SCSI commands. There are +// two available SCSI commands: a 12 byte and 16 byte variant; the +// one used is chosen via this->m_passthrulen . +// DETAILED DESCRIPTION OF ARGUMENTS +// device: is the file descriptor provided by (a SCSI dvice type) open() +// command: defines the different ATA operations. +// select: additional input data if needed (which log, which type of +// self-test). +// data: location to write output data, if needed (512 bytes). +// Note: not all commands use all arguments. +// RETURN VALUES +// -1 if the command failed +// 0 if the command succeeded, +// STATUS_CHECK routine: +// -1 if the command failed +// 0 if the command succeeded and disk SMART status is "OK" +// 1 if the command succeeded and disk SMART status is "FAILING" + +bool sat_device::ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out) +{ + if (!ata_cmd_is_supported(in, + ata_device::supports_data_out | + ata_device::supports_output_regs | + ata_device::supports_multi_sector | + ata_device::supports_48bit, + "SAT") + ) + return false; + + struct scsi_cmnd_io io_hdr = {}; + struct scsi_sense_disect sinfo; + struct sg_scsi_sense_hdr ssh; + unsigned char cdb[SAT_ATA_PASSTHROUGH_16LEN] = {}; + unsigned char sense[32] = {}; + const unsigned char * ardp; + int ard_len, have_sense; + int extend = 0; + int ck_cond = 0; /* set to 1 to read register(s) back */ + int protocol = 3; /* non-data */ + int t_dir = 1; /* 0 -> to device, 1 -> from device */ + int byte_block = 1; /* 0 -> bytes, 1 -> 512 byte blocks */ + int t_length = 0; /* 0 -> no data transferred */ + int passthru_size = DEF_SAT_ATA_PASSTHRU_SIZE; + bool sense_descriptor = true; + + // Set data direction + // TODO: This works only for commands where sector_count holds count! + switch (in.direction) { + case ata_cmd_in::no_data: + break; + case ata_cmd_in::data_in: + protocol = 4; // PIO data-in + t_length = 2; // sector_count holds count + break; + case ata_cmd_in::data_out: + protocol = 5; // PIO data-out + t_length = 2; // sector_count holds count + t_dir = 0; // to device + break; + default: + return set_err(EINVAL, "sat_device::ata_pass_through: invalid direction=%d", + (int)in.direction); + } + + // The ASM1352R uses reserved values for 'protocol' field to select drive + if (m_variant == sat_asm1352r) { + if (in.direction == ata_cmd_in::no_data) + return set_err(ENOSYS, "NO DATA ATA commands not implemented [ASM1352R]"); + protocol = (m_port == 0 ? 0xd : 0xe); + } + + // Check condition if any output register needed + if (in.out_needed.is_set()) + ck_cond = 1; + + if ((SAT_ATA_PASSTHROUGH_12LEN == m_passthrulen) || + (SAT_ATA_PASSTHROUGH_16LEN == m_passthrulen)) + passthru_size = m_passthrulen; + + // Set extend bit on 48-bit ATA command + if (in.in_regs.is_48bit_cmd()) { + if (passthru_size != SAT_ATA_PASSTHROUGH_16LEN) + return set_err(ENOSYS, "48-bit ATA commands require SAT ATA PASS-THROUGH (16)"); + extend = 1; + } + + cdb[0] = (SAT_ATA_PASSTHROUGH_12LEN == passthru_size) ? + SAT_ATA_PASSTHROUGH_12 : SAT_ATA_PASSTHROUGH_16; + + cdb[1] = (protocol << 1) | extend; + cdb[2] = (ck_cond << 5) | (t_dir << 3) | + (byte_block << 2) | t_length; + + if (passthru_size == SAT_ATA_PASSTHROUGH_12LEN) { + // ATA PASS-THROUGH (12) + const ata_in_regs & lo = in.in_regs; + cdb[3] = lo.features; + cdb[4] = lo.sector_count; + cdb[5] = lo.lba_low; + cdb[6] = lo.lba_mid; + cdb[7] = lo.lba_high; + cdb[8] = lo.device; + cdb[9] = lo.command; + } + else { + // ATA PASS-THROUGH (16) + const ata_in_regs & lo = in.in_regs; + const ata_in_regs & hi = in.in_regs.prev; + // Note: all 'in.in_regs.prev.*' are always zero for 28-bit commands + cdb[ 3] = hi.features; + cdb[ 4] = lo.features; + cdb[ 5] = hi.sector_count; + cdb[ 6] = lo.sector_count; + cdb[ 7] = hi.lba_low; + cdb[ 8] = lo.lba_low; + cdb[ 9] = hi.lba_mid; + cdb[10] = lo.lba_mid; + cdb[11] = hi.lba_high; + cdb[12] = lo.lba_high; + cdb[13] = lo.device; + cdb[14] = lo.command; + } + + if (0 == t_length) { + io_hdr.dxfer_dir = DXFER_NONE; + io_hdr.dxfer_len = 0; + } else if (t_dir) { /* from device */ + io_hdr.dxfer_dir = DXFER_FROM_DEVICE; + io_hdr.dxfer_len = in.size; + io_hdr.dxferp = (unsigned char *)in.buffer; + memset(in.buffer, 0, in.size); // prefill with zeroes + } else { /* to device */ + io_hdr.dxfer_dir = DXFER_TO_DEVICE; + io_hdr.dxfer_len = in.size; + io_hdr.dxferp = (unsigned char *)in.buffer; + } + io_hdr.cmnd = cdb; + io_hdr.cmnd_len = passthru_size; + io_hdr.sensep = sense; + io_hdr.max_sense_len = sizeof(sense); + io_hdr.timeout = SCSI_TIMEOUT_DEFAULT; + + scsi_device * scsidev = get_tunnel_dev(); + if (!scsidev->scsi_pass_through(&io_hdr)) { + if (scsi_debugmode > 0) + pout("sat_device::ata_pass_through: scsi_pass_through() failed, " + "errno=%d [%s]\n", scsidev->get_errno(), scsidev->get_errmsg()); + return set_err(scsidev->get_err()); + } + ardp = NULL; + ard_len = 0; + have_sense = sg_scsi_normalize_sense(io_hdr.sensep, io_hdr.resp_sense_len, + &ssh); + if (have_sense) { + sense_descriptor = ssh.response_code >= 0x72; + if (sense_descriptor) { + /* look for SAT ATA Return Descriptor */ + ardp = sg_scsi_sense_desc_find(io_hdr.sensep, + io_hdr.resp_sense_len, + ATA_RETURN_DESCRIPTOR); + if (ardp) { + ard_len = ardp[1] + 2; + if (ard_len < 12) + ard_len = 12; + else if (ard_len > 14) + ard_len = 14; + } + } + scsi_do_sense_disect(&io_hdr, &sinfo); + int status = scsiSimpleSenseFilter(&sinfo); + + // Workaround for bogus sense_key in sense data with SAT ATA Return Descriptor + if ( status && ck_cond && ardp && ard_len > 13 + && (ardp[13] & 0xc1) == 0x40 /* !BSY && DRDY && !ERR */) { + if (scsi_debugmode > 0) + pout("ATA status (0x%02x) indicates success, ignoring SCSI sense_key\n", + ardp[13]); + status = 0; + } + + if (0 != status) { /* other than no_sense and recovered_error */ + if (scsi_debugmode > 0) { + pout("sat_device::ata_pass_through: scsi error: %s\n", + scsiErrString(status)); + if (ardp && (scsi_debugmode > 1)) { + pout("Values from ATA Return Descriptor are:\n"); + dStrHex((const uint8_t *)ardp, ard_len, 1); + } + } + if (t_dir && (t_length > 0) && (in.direction == ata_cmd_in::data_in)) + memset(in.buffer, 0, in.size); + return set_err(EIO, "scsi error %s", scsiErrString(status)); + } + } + if (ck_cond) { /* expecting SAT specific sense data */ + if (have_sense) { + if (ardp) { + if (scsi_debugmode > 1) { + pout("Values from ATA Return Descriptor are:\n"); + dStrHex((const uint8_t *)ardp, ard_len, 1); + } + // Set output registers + ata_out_regs & lo = out.out_regs; + lo.error = ardp[ 3]; + lo.sector_count = ardp[ 5]; + lo.lba_low = ardp[ 7]; + lo.lba_mid = ardp[ 9]; + lo.lba_high = ardp[11]; + lo.device = ardp[12]; + lo.status = ardp[13]; + if (in.in_regs.is_48bit_cmd()) { + ata_out_regs & hi = out.out_regs.prev; + hi.sector_count = ardp[ 4]; + hi.lba_low = ardp[ 6]; + hi.lba_mid = ardp[ 8]; + hi.lba_high = ardp[10]; + } + } else if ((! sense_descriptor) && + (0 == ssh.asc) && + (SCSI_ASCQ_ATA_PASS_THROUGH == ssh.ascq) && + (0 != io_hdr.sensep[4] /* Some ATA STATUS bit must be set */)) { + /* in SAT-2 and later, ATA registers may be passed back via + * fixed format sense data [ref: sat3r07 section 12.2.2.7] */ + ata_out_regs & lo = out.out_regs; + lo.error = io_hdr.sensep[ 3]; + lo.status = io_hdr.sensep[ 4]; + lo.device = io_hdr.sensep[ 5]; + lo.sector_count = io_hdr.sensep[ 6]; + lo.lba_low = io_hdr.sensep[ 9]; + lo.lba_mid = io_hdr.sensep[10]; + lo.lba_high = io_hdr.sensep[11]; + if (in.in_regs.is_48bit_cmd()) { + if (0 == (0x60 & io_hdr.sensep[8])) { + ata_out_regs & hi = out.out_regs.prev; + hi.sector_count = 0; + hi.lba_low = 0; + hi.lba_mid = 0; + hi.lba_high = 0; + } else { + /* getting the "hi." values when either + * count_upper_nonzero or lba_upper_nonzero are set + * involves fetching the SCSI ATA PASS-THROUGH + * Results log page and decoding the descriptor with + * the matching log_index field. Painful. */ + } + } + } + } + } else { /* ck_cond == 0 */ + if (have_sense) { + if (((SCSI_SK_NO_SENSE == ssh.sense_key) || + (SCSI_SK_RECOVERED_ERR == ssh.sense_key)) && + (0 == ssh.asc) && + (SCSI_ASCQ_ATA_PASS_THROUGH == ssh.ascq)) { + if (scsi_debugmode > 0) { + if (sense_descriptor && ardp) { + pout("Values from ATA Return Descriptor are:\n"); + dStrHex((const uint8_t *)ardp, ard_len, 1); + } else if (! sense_descriptor) { + pout("Values from ATA fixed format sense are:\n"); + pout(" Error: 0x%x\n", io_hdr.sensep[3]); + pout(" Status: 0x%x\n", io_hdr.sensep[4]); + pout(" Device: 0x%x\n", io_hdr.sensep[5]); + pout(" Count: 0x%x\n", io_hdr.sensep[6]); + } + } + } + return set_err(EIO, "SAT command failed"); + } + } + return true; +} + +bool sat_device::scsi_pass_through(scsi_cmnd_io * iop) +{ + scsi_device * scsidev = get_tunnel_dev(); + if (!scsidev->scsi_pass_through(iop)) + return set_err(scsidev->get_err()); + return true; +} + +smart_device * sat_device::autodetect_open() +{ + if (!open() || m_mode != sat_auto) + return this; + + scsi_device * scsidev = get_tunnel_dev(); + + unsigned char inqdata[36] = {0, }; + if (scsiStdInquiry(scsidev, inqdata, sizeof(inqdata))) { + smart_device::error_info err = scsidev->get_err(); + close(); + set_err(err.no, "INQUIRY [SAT]: %s", err.msg.c_str()); + return this; + } + + // Check for SAT "VENDOR" + int inqsize = inqdata[4] + 5; + bool sat = (inqsize >= 36 && !memcmp(inqdata + 8, "ATA ", 8)); + + // Change interface + hide_ata(!sat); + hide_scsi(sat); + + set_info().dev_type = (sat ? "sat" : scsidev->get_dev_type()); + set_info().info_name = strprintf("%s [%s]", scsidev->get_info_name(), + (sat ? "SAT" : "SCSI")); + return this; +} + +} // namespace + +///////////////////////////////////////////////////////////////////////////// + +/* Attempt an IDENTIFY DEVICE ATA command via SATL when packet_interface + is false otherwise attempt IDENTIFY PACKET DEVICE. If successful + return true, else false */ + +static bool has_sat_pass_through(ata_device * dev, bool packet_interface = false) +{ + /* Note: malloc() ensures the read buffer lands on a single + page. This avoids some bugs seen on LSI controllers under + FreeBSD */ + char *data = (char *)malloc(512); + ata_cmd_in in; + in.in_regs.command = (packet_interface ? ATA_IDENTIFY_PACKET_DEVICE : ATA_IDENTIFY_DEVICE); + in.set_data_in(data, 1); + bool ret = dev->ata_pass_through(in); + free(data); + return ret; +} + +///////////////////////////////////////////////////////////////////////////// + +/* Next two functions are borrowed from sg_lib.c in the sg3_utils + package. Same copyrght owner, same license as this file. */ +static int sg_scsi_normalize_sense(const unsigned char * sensep, int sb_len, + struct sg_scsi_sense_hdr * sshp) +{ + if (sshp) + memset(sshp, 0, sizeof(struct sg_scsi_sense_hdr)); + if ((NULL == sensep) || (0 == sb_len) || (0x70 != (0x70 & sensep[0]))) + return 0; + if (sshp) { + sshp->response_code = (0x7f & sensep[0]); + if (sshp->response_code >= 0x72) { /* descriptor format */ + if (sb_len > 1) + sshp->sense_key = (0xf & sensep[1]); + if (sb_len > 2) + sshp->asc = sensep[2]; + if (sb_len > 3) + sshp->ascq = sensep[3]; + if (sb_len > 7) + sshp->additional_length = sensep[7]; + } else { /* fixed format */ + if (sb_len > 2) + sshp->sense_key = (0xf & sensep[2]); + if (sb_len > 7) { + sb_len = (sb_len < (sensep[7] + 8)) ? sb_len : + (sensep[7] + 8); + if (sb_len > 12) + sshp->asc = sensep[12]; + if (sb_len > 13) + sshp->ascq = sensep[13]; + } + } + } + return 1; +} + +///////////////////////////////////////////////////////////////////////////// + +namespace sat { + +/// Cypress USB Bridge support. + +class usbcypress_device +: public tunnelled_device< + /*implements*/ ata_device_with_command_set + /*by tunnelling through a*/, scsi_device + > +{ +public: + usbcypress_device(smart_interface * intf, scsi_device * scsidev, + const char * req_type, unsigned char signature); + + virtual ~usbcypress_device(); + +protected: + virtual int ata_command_interface(smart_command_set command, int select, char * data) override; + + unsigned char m_signature; +}; + + +usbcypress_device::usbcypress_device(smart_interface * intf, scsi_device * scsidev, + const char * req_type, unsigned char signature) +: smart_device(intf, scsidev->get_dev_name(), "usbcypress", req_type), + tunnelled_device<ata_device_with_command_set, scsi_device>(scsidev), + m_signature(signature) +{ + set_info().info_name = strprintf("%s [USB Cypress]", scsidev->get_info_name()); +} + +usbcypress_device::~usbcypress_device() +{ +} + + +/* see cy7c68300c_8.pdf for more information */ +#define USBCYPRESS_PASSTHROUGH_LEN 16 +int usbcypress_device::ata_command_interface(smart_command_set command, int select, char *data) +{ + struct scsi_cmnd_io io_hdr = {}; + unsigned char cdb[USBCYPRESS_PASSTHROUGH_LEN] = {}; + unsigned char sense[32] = {}; + int copydata = 0; + int outlen = 0; + int ck_cond = 0; /* set to 1 to read register(s) back */ + int t_dir = 1; /* 0 -> to device, 1 -> from device */ + int byte_block = 1; /* 0 -> bytes, 1 -> 512 byte blocks */ + int t_length = 0; /* 0 -> no data transferred */ + int feature = 0; + int ata_command = 0; + int sector_count = 0; + int lba_low = 0; + int lba_mid = 0; + int lba_high = 0; + int passthru_size = USBCYPRESS_PASSTHROUGH_LEN; + + ata_command = ATA_SMART_CMD; + switch (command) { + case CHECK_POWER_MODE: + ata_command = ATA_CHECK_POWER_MODE; + ck_cond = 1; + copydata = 1; + break; + case READ_VALUES: /* READ DATA */ + feature = ATA_SMART_READ_VALUES; + sector_count = 1; /* one (512 byte) block */ + t_length = 2; /* sector count holds count */ + copydata = 512; + break; + case READ_THRESHOLDS: /* obsolete */ + feature = ATA_SMART_READ_THRESHOLDS; + sector_count = 1; /* one (512 byte) block */ + lba_low = 1; + t_length = 2; /* sector count holds count */ + copydata=512; + break; + case READ_LOG: + feature = ATA_SMART_READ_LOG_SECTOR; + sector_count = 1; /* one (512 byte) block */ + lba_low = select; + t_length = 2; /* sector count holds count */ + copydata = 512; + break; + case WRITE_LOG: + feature = ATA_SMART_WRITE_LOG_SECTOR; + sector_count = 1; /* one (512 byte) block */ + lba_low = select; + t_length = 2; /* sector count holds count */ + t_dir = 0; /* to device */ + outlen = 512; + break; + case IDENTIFY: + ata_command = ATA_IDENTIFY_DEVICE; + sector_count = 1; /* one (512 byte) block */ + t_length = 2; /* sector count holds count */ + copydata = 512; + break; + case PIDENTIFY: + ata_command = ATA_IDENTIFY_PACKET_DEVICE; + sector_count = 1; /* one (512 byte) block */ + t_length = 2; /* sector count (7:0) holds count */ + copydata = 512; + break; + case ENABLE: + feature = ATA_SMART_ENABLE; + lba_low = 1; + break; + case DISABLE: + feature = ATA_SMART_DISABLE; + lba_low = 1; + break; + case STATUS: + // this command only says if SMART is working. It could be + // replaced with STATUS_CHECK below. + feature = ATA_SMART_STATUS; + ck_cond = 1; + break; + case AUTO_OFFLINE: + feature = ATA_SMART_AUTO_OFFLINE; + sector_count = select; // YET NOTE - THIS IS A NON-DATA COMMAND!! + break; + case AUTOSAVE: + feature = ATA_SMART_AUTOSAVE; + sector_count = select; // YET NOTE - THIS IS A NON-DATA COMMAND!! + break; + case IMMEDIATE_OFFLINE: + feature = ATA_SMART_IMMEDIATE_OFFLINE; + lba_low = select; + break; + case STATUS_CHECK: + // This command uses HDIO_DRIVE_TASK and has different syntax than + // the other commands. + feature = ATA_SMART_STATUS; /* SMART RETURN STATUS */ + ck_cond = 1; + break; + default: + pout("Unrecognized command %d in usbcypress_device::ata_command_interface()\n" + "Please contact " PACKAGE_BUGREPORT "\n", command); + errno=ENOSYS; + return -1; + } + if (ATA_SMART_CMD == ata_command) { + lba_mid = 0x4f; + lba_high = 0xc2; + } + + cdb[0] = m_signature; // bVSCBSignature : vendor-specific command + cdb[1] = 0x24; // bVSCBSubCommand : 0x24 for ATACB + cdb[2] = 0x0; + if (ata_command == ATA_IDENTIFY_DEVICE || ata_command == ATA_IDENTIFY_PACKET_DEVICE) + cdb[2] |= (1<<7); //set IdentifyPacketDevice for these cmds + cdb[3] = 0xff - (1<<0) - (1<<6); //features, sector count, lba low, lba med + // lba high, command are valid + cdb[4] = byte_block; //TransferBlockCount : 512 + + + cdb[6] = feature; + cdb[7] = sector_count; + cdb[8] = lba_low; + cdb[9] = lba_mid; + cdb[10] = lba_high; + cdb[12] = ata_command; + + if (0 == t_length) { + io_hdr.dxfer_dir = DXFER_NONE; + io_hdr.dxfer_len = 0; + } else if (t_dir) { /* from device */ + io_hdr.dxfer_dir = DXFER_FROM_DEVICE; + io_hdr.dxfer_len = copydata; + io_hdr.dxferp = (unsigned char *)data; + memset(data, 0, copydata); /* prefill with zeroes */ + } else { /* to device */ + io_hdr.dxfer_dir = DXFER_TO_DEVICE; + io_hdr.dxfer_len = outlen; + io_hdr.dxferp = (unsigned char *)data; + } + io_hdr.cmnd = cdb; + io_hdr.cmnd_len = passthru_size; + io_hdr.sensep = sense; + io_hdr.max_sense_len = sizeof(sense); + io_hdr.timeout = SCSI_TIMEOUT_DEFAULT; + + scsi_device * scsidev = get_tunnel_dev(); + if (!scsidev->scsi_pass_through(&io_hdr)) { + if (scsi_debugmode > 0) + pout("usbcypress_device::ata_command_interface: scsi_pass_through() failed, " + "errno=%d [%s]\n", scsidev->get_errno(), scsidev->get_errmsg()); + set_err(scsidev->get_err()); + return -1; + } + + // if there is a sense the command failed or the + // device doesn't support usbcypress + if (io_hdr.scsi_status == SCSI_STATUS_CHECK_CONDITION && + sg_scsi_normalize_sense(io_hdr.sensep, io_hdr.resp_sense_len, NULL)) { + return -1; + } + if (ck_cond) { + unsigned char ardp[8]; + int ard_len = 8; + /* XXX this is racy if there other scsi command between + * the first usbcypress command and this one + */ + //pout("If you got strange result, please retry without traffic on the disc\n"); + /* we use the same command as before, but we set + * * the read taskfile bit, for not executing usbcypress command, + * * but reading register selected in srb->cmnd[4] + */ + cdb[2] = (1<<0); /* ask read taskfile */ + memset(sense, 0, sizeof(sense)); + + /* transfer 8 bytes */ + memset(&io_hdr, 0, sizeof(io_hdr)); + io_hdr.dxfer_dir = DXFER_FROM_DEVICE; + io_hdr.dxfer_len = ard_len; + io_hdr.dxferp = (unsigned char *)ardp; + memset(ardp, 0, ard_len); /* prefill with zeroes */ + + io_hdr.cmnd = cdb; + io_hdr.cmnd_len = passthru_size; + io_hdr.sensep = sense; + io_hdr.max_sense_len = sizeof(sense); + io_hdr.timeout = SCSI_TIMEOUT_DEFAULT; + + + if (!scsidev->scsi_pass_through(&io_hdr)) { + if (scsi_debugmode > 0) + pout("usbcypress_device::ata_command_interface: scsi_pass_through() failed, " + "errno=%d [%s]\n", scsidev->get_errno(), scsidev->get_errmsg()); + set_err(scsidev->get_err()); + return -1; + } + // if there is a sense the command failed or the + // device doesn't support usbcypress + if (io_hdr.scsi_status == SCSI_STATUS_CHECK_CONDITION && + sg_scsi_normalize_sense(io_hdr.sensep, io_hdr.resp_sense_len, NULL)) { + return -1; + } + + + if (scsi_debugmode > 1) { + pout("Values from ATA Return Descriptor are:\n"); + dStrHex((const uint8_t *)ardp, ard_len, 1); + } + + if (ATA_CHECK_POWER_MODE == ata_command) + data[0] = ardp[2]; /* sector count (0:7) */ + else if (STATUS_CHECK == command) { + if ((ardp[4] == 0x4f) && (ardp[5] == 0xc2)) + return 0; /* GOOD smart status */ + if ((ardp[4] == 0xf4) && (ardp[5] == 0x2c)) + return 1; // smart predicting failure, "bad" status + // We haven't gotten output that makes sense so + // print out some debugging info + syserror("Error SMART Status command failed"); + pout("This may be due to a race in usbcypress\n"); + pout("Retry without other disc access\n"); + pout("Please get assistance from " PACKAGE_URL "\n"); + pout("Values from ATA Return Descriptor are:\n"); + dStrHex((const uint8_t *)ardp, ard_len, 1); + return -1; + } + } + return 0; +} + +///////////////////////////////////////////////////////////////////////////// + +/// JMicron USB Bridge support. + +class usbjmicron_device +: public tunnelled_device< + /*implements*/ ata_device, + /*by tunnelling through a*/ scsi_device + > +{ +public: + usbjmicron_device(smart_interface * intf, scsi_device * scsidev, + const char * req_type, bool prolific, + bool ata_48bit_support, int port); + + virtual ~usbjmicron_device(); + + virtual bool open() override; + + virtual bool ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out) override; + +private: + bool get_registers(unsigned short addr, unsigned char * buf, unsigned short size); + + bool m_prolific; + bool m_ata_48bit_support; + int m_port; +}; + + +usbjmicron_device::usbjmicron_device(smart_interface * intf, scsi_device * scsidev, + const char * req_type, bool prolific, + bool ata_48bit_support, int port) +: smart_device(intf, scsidev->get_dev_name(), "usbjmicron", req_type), + tunnelled_device<ata_device, scsi_device>(scsidev), + m_prolific(prolific), m_ata_48bit_support(ata_48bit_support), + m_port(port >= 0 || !prolific ? port : 0) +{ + set_info().info_name = strprintf("%s [USB JMicron]", scsidev->get_info_name()); +} + +usbjmicron_device::~usbjmicron_device() +{ +} + + +bool usbjmicron_device::open() +{ + // Open USB first + if (!tunnelled_device<ata_device, scsi_device>::open()) + return false; + + // Detect port if not specified + if (m_port < 0) { + unsigned char regbuf[1] = {0}; + if (!get_registers(0x720f, regbuf, sizeof(regbuf))) { + close(); + return false; + } + + switch (regbuf[0] & 0x44) { + case 0x04: + m_port = 0; break; + case 0x40: + m_port = 1; break; + case 0x44: + close(); + return set_err(EINVAL, "Two devices connected, try '-d usbjmicron,[01]'"); + default: + close(); + return set_err(ENODEV, "No device connected"); + } + } + + return true; +} + + +bool usbjmicron_device::ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out) +{ + if (!ata_cmd_is_supported(in, + ata_device::supports_data_out | + ata_device::supports_smart_status | + (m_ata_48bit_support ? ata_device::supports_48bit_hi_null : 0), + "JMicron") + ) + return false; + + if (m_port < 0) + return set_err(EIO, "Unknown JMicron port"); + + scsi_cmnd_io io_hdr = {}; + + bool rwbit = true; + unsigned char smart_status = 0xff; + + bool is_smart_status = ( in.in_regs.command == ATA_SMART_CMD + && in.in_regs.features == ATA_SMART_STATUS); + + if (is_smart_status && in.out_needed.is_set()) { + io_hdr.dxfer_dir = DXFER_FROM_DEVICE; + io_hdr.dxfer_len = 1; + io_hdr.dxferp = &smart_status; + } + else switch (in.direction) { + case ata_cmd_in::no_data: + io_hdr.dxfer_dir = DXFER_NONE; + break; + case ata_cmd_in::data_in: + io_hdr.dxfer_dir = DXFER_FROM_DEVICE; + io_hdr.dxfer_len = in.size; + io_hdr.dxferp = (unsigned char *)in.buffer; + memset(in.buffer, 0, in.size); + break; + case ata_cmd_in::data_out: + io_hdr.dxfer_dir = DXFER_TO_DEVICE; + io_hdr.dxfer_len = in.size; + io_hdr.dxferp = (unsigned char *)in.buffer; + rwbit = false; + break; + default: + return set_err(EINVAL); + } + + // Build pass through command + unsigned char cdb[14]; + cdb[ 0] = 0xdf; + cdb[ 1] = (rwbit ? 0x10 : 0x00); + cdb[ 2] = 0x00; + sg_put_unaligned_be16(io_hdr.dxfer_len, cdb + 3); + cdb[ 5] = in.in_regs.features; + cdb[ 6] = in.in_regs.sector_count; + cdb[ 7] = in.in_regs.lba_low; + cdb[ 8] = in.in_regs.lba_mid; + cdb[ 9] = in.in_regs.lba_high; + cdb[10] = in.in_regs.device | (m_port == 0 ? 0xa0 : 0xb0); + cdb[11] = in.in_regs.command; + // Prolific PL3507 + cdb[12] = 0x06; + cdb[13] = 0x7b; + + io_hdr.cmnd = cdb; + io_hdr.cmnd_len = (!m_prolific ? 12 : 14); + + scsi_device * scsidev = get_tunnel_dev(); + if (!scsidev->scsi_pass_through_and_check(&io_hdr, + "usbjmicron_device::ata_pass_through: ")) + return set_err(scsidev->get_err()); + + if (in.out_needed.is_set()) { + if (is_smart_status) { + if (io_hdr.resid == 1) + // Some (Prolific) USB bridges do not transfer a status byte + return set_err(ENOSYS, "Incomplete response, status byte missing [JMicron]"); + + switch (smart_status) { + case 0xc2: + out.out_regs.lba_high = 0xc2; + out.out_regs.lba_mid = 0x4f; + break; + case 0x2c: + out.out_regs.lba_high = 0x2c; + out.out_regs.lba_mid = 0xf4; + break; + default: + // Some (JM20336) USB bridges always return 0x01, regardless of SMART Status + return set_err(ENOSYS, "Invalid status byte (0x%02x) [JMicron]", smart_status); + } + } + +#if 0 // Not needed for SMART STATUS, see also notes below + else { + // Read ATA output registers + // NOTE: The register addresses are not valid for some older chip revisions + // NOTE: There is a small race condition here! + unsigned char regbuf[16] = {0, }; + if (!get_registers((m_port == 0 ? 0x8000 : 0x9000), regbuf, sizeof(regbuf))) + return false; + + out.out_regs.sector_count = regbuf[ 0]; + out.out_regs.lba_mid = regbuf[ 4]; + out.out_regs.lba_low = regbuf[ 6]; + out.out_regs.device = regbuf[ 9]; + out.out_regs.lba_high = regbuf[10]; + out.out_regs.error = regbuf[13]; + out.out_regs.status = regbuf[14]; + } +#endif + } + + return true; +} + +bool usbjmicron_device::get_registers(unsigned short addr, + unsigned char * buf, unsigned short size) +{ + unsigned char cdb[14]; + cdb[ 0] = 0xdf; + cdb[ 1] = 0x10; + cdb[ 2] = 0x00; + sg_put_unaligned_be16(size, cdb + 3); + cdb[ 5] = 0x00; + sg_put_unaligned_be16(addr, cdb + 6); + cdb[ 8] = 0x00; + cdb[ 9] = 0x00; + cdb[10] = 0x00; + cdb[11] = 0xfd; + // Prolific PL3507 + cdb[12] = 0x06; + cdb[13] = 0x7b; + + scsi_cmnd_io io_hdr = {}; + io_hdr.dxfer_dir = DXFER_FROM_DEVICE; + io_hdr.dxfer_len = size; + io_hdr.dxferp = buf; + io_hdr.cmnd = cdb; + io_hdr.cmnd_len = (!m_prolific ? 12 : 14); + + scsi_device * scsidev = get_tunnel_dev(); + if (!scsidev->scsi_pass_through_and_check(&io_hdr, + "usbjmicron_device::get_registers: ")) + return set_err(scsidev->get_err()); + + return true; +} + + +///////////////////////////////////////////////////////////////////////////// + +/// Prolific USB Bridge support. (PL2773) (Probably works on PL2771 also...) + +class usbprolific_device +: public tunnelled_device< + /*implements*/ ata_device, + /*by tunnelling through a*/ scsi_device + > +{ +public: + usbprolific_device(smart_interface * intf, scsi_device * scsidev, + const char * req_type); + + virtual ~usbprolific_device(); + + virtual bool ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out) override; +}; + + +usbprolific_device::usbprolific_device(smart_interface * intf, scsi_device * scsidev, + const char * req_type) +: smart_device(intf, scsidev->get_dev_name(), "usbprolific", req_type), + tunnelled_device<ata_device, scsi_device>(scsidev) +{ + set_info().info_name = strprintf("%s [USB Prolific]", scsidev->get_info_name()); +} + +usbprolific_device::~usbprolific_device() +{ +} + +bool usbprolific_device::ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out) +{ + if (!ata_cmd_is_supported(in, + ata_device::supports_data_out | + ata_device::supports_48bit_hi_null | + ata_device::supports_output_regs | + ata_device::supports_smart_status, + "Prolific" ) + ) + return false; + + scsi_cmnd_io io_hdr = {}; + unsigned char cmd_rw = 0x10; // Read + + switch (in.direction) { + case ata_cmd_in::no_data: + io_hdr.dxfer_dir = DXFER_NONE; + break; + case ata_cmd_in::data_in: + io_hdr.dxfer_dir = DXFER_FROM_DEVICE; + io_hdr.dxfer_len = in.size; + io_hdr.dxferp = (unsigned char *)in.buffer; + memset(in.buffer, 0, in.size); + break; + case ata_cmd_in::data_out: + io_hdr.dxfer_dir = DXFER_TO_DEVICE; + io_hdr.dxfer_len = in.size; + io_hdr.dxferp = (unsigned char *)in.buffer; + cmd_rw = 0x0; // Write + break; + default: + return set_err(EINVAL); + } + + // Based on reverse engineering of iSmart.exe with API Monitor. + // Seen commands: + // D0 0 0 0 06 7B 0 0 0 0 0 0 // Read Firmware info?, reads 16 bytes + // F4 0 0 0 06 7B // ?? + // D8 15 0 D8 06 7B 0 0 0 0 1 1 4F C2 A0 B0 // SMART Enable + // D8 15 0 D0 06 7B 0 0 2 0 1 1 4F C2 A0 B0 // SMART Read values + // D8 15 0 D1 06 7B 0 0 2 0 1 1 4F C2 A0 B0 // SMART Read thresholds + // D8 15 0 D4 06 7B 0 0 0 0 0 1 4F C2 A0 B0 // SMART Execute self test + // D7 0 0 0 06 7B 0 0 0 0 0 0 0 0 0 0 // Read status registers, Reads 16 bytes of data + // Additional DATA OUT support based on document from Prolific + + // Build pass through command + unsigned char cdb[16]; + cdb[ 0] = 0xD8; // Operation Code (D8 = Prolific ATA pass through) + cdb[ 1] = cmd_rw|0x5; // Read(0x10)/Write(0x0) | NORMAL(0x5)/PREFIX(0x0)(?) + cdb[ 2] = 0x0; // Reserved + cdb[ 3] = in.in_regs.features; // Feature register (SMART command) + cdb[ 4] = 0x06; // Check Word (VendorID magic, Prolific: 0x067B) + cdb[ 5] = 0x7B; // Check Word (VendorID magic, Prolific: 0x067B) + sg_put_unaligned_be32(io_hdr.dxfer_len, cdb + 6); + cdb[10] = in.in_regs.sector_count; // Sector Count + cdb[11] = in.in_regs.lba_low; // LBA Low (7:0) + cdb[12] = in.in_regs.lba_mid; // LBA Mid (15:8) + cdb[13] = in.in_regs.lba_high; // LBA High (23:16) + cdb[14] = in.in_regs.device | 0xA0; // Device/Head + cdb[15] = in.in_regs.command; // ATA Command Register (only PIO supported) + // Use '-r scsiioctl,1' to print CDB for debug purposes + + io_hdr.cmnd = cdb; + io_hdr.cmnd_len = 16; + + scsi_device * scsidev = get_tunnel_dev(); + if (!scsidev->scsi_pass_through_and_check(&io_hdr, + "usbprolific_device::ata_pass_through: ")) + return set_err(scsidev->get_err()); + + if (in.out_needed.is_set()) { + // Read ATA output registers + unsigned char regbuf[16] = {0, }; + memset(&io_hdr, 0, sizeof(io_hdr)); + io_hdr.dxfer_dir = DXFER_FROM_DEVICE; + io_hdr.dxfer_len = sizeof(regbuf); + io_hdr.dxferp = regbuf; + + memset(cdb, 0, sizeof(cdb)); + cdb[ 0] = 0xD7; // Prolific read registers + cdb[ 4] = 0x06; // Check Word (VendorID magic, Prolific: 0x067B) + cdb[ 5] = 0x7B; // Check Word (VendorID magic, Prolific: 0x067B) + io_hdr.cmnd = cdb; + io_hdr.cmnd_len = sizeof(cdb); + + if (!scsidev->scsi_pass_through_and_check(&io_hdr, + "usbprolific_device::scsi_pass_through (get registers): ")) + return set_err(scsidev->get_err()); + + // Use '-r scsiioctl,2' to print input registers for debug purposes + // Example: 50 00 00 00 00 01 4f 00 c2 00 a0 da 00 b0 00 50 + out.out_regs.status = regbuf[0]; // Status + out.out_regs.error = regbuf[1]; // Error + out.out_regs.sector_count = regbuf[2]; // Sector Count (7:0) + out.out_regs.lba_low = regbuf[4]; // LBA Low (7:0) + out.out_regs.lba_mid = regbuf[6]; // LBA Mid (7:0) + out.out_regs.lba_high = regbuf[8]; // LBA High (7:0) + out.out_regs.device = regbuf[10]; // Device/Head + // = regbuf[11]; // ATA Feature (7:0) + // = regbuf[13]; // ATA Command + } + + return true; +} + + +///////////////////////////////////////////////////////////////////////////// + +/// SunplusIT USB Bridge support. + +class usbsunplus_device +: public tunnelled_device< + /*implements*/ ata_device, + /*by tunnelling through a*/ scsi_device + > +{ +public: + usbsunplus_device(smart_interface * intf, scsi_device * scsidev, + const char * req_type); + + virtual ~usbsunplus_device(); + + virtual bool ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out) override; +}; + + +usbsunplus_device::usbsunplus_device(smart_interface * intf, scsi_device * scsidev, + const char * req_type) +: smart_device(intf, scsidev->get_dev_name(), "usbsunplus", req_type), + tunnelled_device<ata_device, scsi_device>(scsidev) +{ + set_info().info_name = strprintf("%s [USB Sunplus]", scsidev->get_info_name()); +} + +usbsunplus_device::~usbsunplus_device() +{ +} + +bool usbsunplus_device::ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out) +{ + if (!ata_cmd_is_supported(in, + ata_device::supports_data_out | + ata_device::supports_output_regs | + ata_device::supports_48bit, + "Sunplus") + ) + return false; + + scsi_cmnd_io io_hdr = {}; + unsigned char cdb[12]; + + if (in.in_regs.is_48bit_cmd()) { + // Set "previous" registers + io_hdr.dxfer_dir = DXFER_NONE; + + cdb[ 0] = 0xf8; + cdb[ 1] = 0x00; + cdb[ 2] = 0x23; // Subcommand: Pass through presetting + cdb[ 3] = 0x00; + cdb[ 4] = 0x00; + cdb[ 5] = in.in_regs.prev.features; + cdb[ 6] = in.in_regs.prev.sector_count; + cdb[ 7] = in.in_regs.prev.lba_low; + cdb[ 8] = in.in_regs.prev.lba_mid; + cdb[ 9] = in.in_regs.prev.lba_high; + cdb[10] = 0x00; + cdb[11] = 0x00; + + io_hdr.cmnd = cdb; + io_hdr.cmnd_len = sizeof(cdb); + + scsi_device * scsidev = get_tunnel_dev(); + if (!scsidev->scsi_pass_through_and_check(&io_hdr, + "usbsunplus_device::scsi_pass_through (presetting): ")) + return set_err(scsidev->get_err()); + } + + // Run Pass through command + memset(&io_hdr, 0, sizeof(io_hdr)); + unsigned char protocol; + switch (in.direction) { + case ata_cmd_in::no_data: + io_hdr.dxfer_dir = DXFER_NONE; + protocol = 0x00; + break; + case ata_cmd_in::data_in: + io_hdr.dxfer_dir = DXFER_FROM_DEVICE; + io_hdr.dxfer_len = in.size; + io_hdr.dxferp = (unsigned char *)in.buffer; + memset(in.buffer, 0, in.size); + protocol = 0x10; + break; + case ata_cmd_in::data_out: + io_hdr.dxfer_dir = DXFER_TO_DEVICE; + io_hdr.dxfer_len = in.size; + io_hdr.dxferp = (unsigned char *)in.buffer; + protocol = 0x11; + break; + default: + return set_err(EINVAL); + } + + cdb[ 0] = 0xf8; + cdb[ 1] = 0x00; + cdb[ 2] = 0x22; // Subcommand: Pass through + cdb[ 3] = protocol; + cdb[ 4] = (unsigned char)(io_hdr.dxfer_len >> 9); + cdb[ 5] = in.in_regs.features; + cdb[ 6] = in.in_regs.sector_count; + cdb[ 7] = in.in_regs.lba_low; + cdb[ 8] = in.in_regs.lba_mid; + cdb[ 9] = in.in_regs.lba_high; + cdb[10] = in.in_regs.device | 0xa0; + cdb[11] = in.in_regs.command; + + io_hdr.cmnd = cdb; + io_hdr.cmnd_len = sizeof(cdb); + + scsi_device * scsidev = get_tunnel_dev(); + if (!scsidev->scsi_pass_through_and_check(&io_hdr, + "usbsunplus_device::scsi_pass_through: ")) + // Returns sense key 0x03 (medium error) on ATA command error + return set_err(scsidev->get_err()); + + if (in.out_needed.is_set()) { + // Read ATA output registers + unsigned char regbuf[8] = {0, }; + memset(&io_hdr, 0, sizeof(io_hdr)); + io_hdr.dxfer_dir = DXFER_FROM_DEVICE; + io_hdr.dxfer_len = sizeof(regbuf); + io_hdr.dxferp = regbuf; + + cdb[ 0] = 0xf8; + cdb[ 1] = 0x00; + cdb[ 2] = 0x21; // Subcommand: Get status + memset(cdb+3, 0, sizeof(cdb)-3); + io_hdr.cmnd = cdb; + io_hdr.cmnd_len = sizeof(cdb); + + if (!scsidev->scsi_pass_through_and_check(&io_hdr, + "usbsunplus_device::scsi_pass_through (get registers): ")) + return set_err(scsidev->get_err()); + + out.out_regs.error = regbuf[1]; + out.out_regs.sector_count = regbuf[2]; + out.out_regs.lba_low = regbuf[3]; + out.out_regs.lba_mid = regbuf[4]; + out.out_regs.lba_high = regbuf[5]; + out.out_regs.device = regbuf[6]; + out.out_regs.status = regbuf[7]; + } + + return true; +} + + +} // namespace + +using namespace sat; + + +///////////////////////////////////////////////////////////////////////////// + +// Return ATA->SCSI filter for SAT or USB. + +ata_device * smart_interface::get_sat_device(const char * type, scsi_device * scsidev) +{ + if (!scsidev) + throw std::logic_error("smart_interface: get_sat_device() called with scsidev=0"); + + // Take temporary ownership of 'scsidev' to delete it on error + scsi_device_auto_ptr scsidev_holder(scsidev); + ata_device * satdev = nullptr; + + if (str_starts_with(type, "sat")) { + const char * t = type + 3; + sat_device::sat_scsi_mode mode = sat_device::sat_always; + if (str_starts_with(t, ",auto")) { + t += 5; + mode = sat_device::sat_auto; + } + int ptlen = 0, n = -1; + if (*t && !(sscanf(t, ",%d%n", &ptlen, &n) == 1 && n == (int)strlen(t) + && (ptlen == 0 || ptlen == 12 || ptlen == 16))) + return set_err_np(EINVAL, "Option '-d sat[,auto][,N]' requires N to be 0, 12 or 16"); + satdev = new sat_device(this, scsidev, type, mode, ptlen); + } + + else if (!strcmp(type, "scsi")) { + satdev = new sat_device(this, scsidev, type, sat_device::scsi_always); + } + + else if (str_starts_with(type, "usbcypress")) { + unsigned signature = 0x24; int n1 = -1, n2 = -1; + if (!(((sscanf(type, "usbcypress%n,0x%x%n", &n1, &signature, &n2) == 1 && n2 == (int)strlen(type)) + || n1 == (int)strlen(type)) && signature <= 0xff)) + return set_err_np(EINVAL, "Option '-d usbcypress,<n>' requires <n> to be " + "an hexadecimal number between 0x0 and 0xff" ); + satdev = new usbcypress_device(this, scsidev, type, signature); + } + + else if (str_starts_with(type, "usbjmicron")) { + const char * t = type + 10; + bool prolific = false; + if (str_starts_with(t, ",p")) { + t += 2; + prolific = true; + } + bool ata_48bit_support = false; + if (str_starts_with(t, ",x")) { + t += 2; + ata_48bit_support = true; + } + int port = -1, n = -1; + if (*t && !( (sscanf(t, ",%d%n", &port, &n) == 1 + && n == (int)strlen(t) && 0 <= port && port <= 1))) + return set_err_np(EINVAL, "Option '-d usbjmicron[,p][,x],<n>' requires <n> to be 0 or 1"); + satdev = new usbjmicron_device(this, scsidev, type, prolific, ata_48bit_support, port); + } + + else if (!strcmp(type, "usbprolific")) { + satdev = new usbprolific_device(this, scsidev, type); + } + + else if (!strcmp(type, "usbsunplus")) { + satdev = new usbsunplus_device(this, scsidev, type); + } + + else if (str_starts_with(type, "usbasm1352r")) { + unsigned port = ~0; int n = -1; + if (!(sscanf(type, "usbasm1352r,%u%n", &port, &n) == 1 && n == (int)strlen(type) && port <= 1)) + return set_err_np(EINVAL, "Option '-d usbasm1352r,<n>' requires <n> to be 0 or 1"); + satdev = new sat_device(this, scsidev, type, sat_device::sat_always, 0, sat_device::sat_asm1352r, port); + } + + else { + return set_err_np(EINVAL, "Unknown USB device type '%s'", type); + } + + // 'scsidev' is now owned by 'satdev' + scsidev_holder.release(); + return satdev; +} + +// Try to detect a SAT device behind a SCSI interface. + +ata_device * smart_interface::autodetect_sat_device(scsi_device * scsidev, + const unsigned char * inqdata, unsigned inqsize) +{ + if (!scsidev->is_open()) + return 0; + + // SAT ? + if (inqdata && inqsize >= 36 && !memcmp(inqdata + 8, "ATA ", 8)) { + // TODO: Linux-specific? No, all SAT standards say the 'T10 Vendor + // Identification' field shall be 'ATA '. + ata_device_auto_ptr atadev( new sat_device(this, scsidev, "") , scsidev); + if (has_sat_pass_through(atadev.get())) + return atadev.release(); // Detected SAT + } + + return 0; +} + + +///////////////////////////////////////////////////////////////////////////// +// USB device type detection + +// Format USB ID for error messages +static std::string format_usb_id(int vendor_id, int product_id, int version) +{ + if (version >= 0) + return strprintf("[0x%04x:0x%04x (0x%03x)]", vendor_id, product_id, version); + else + return strprintf("[0x%04x:0x%04x]", vendor_id, product_id); +} + +// Get type name for USB device with known VENDOR:PRODUCT ID. +const char * smart_interface::get_usb_dev_type_by_id(int vendor_id, int product_id, + int version /*= -1*/) +{ + usb_dev_info info, info2; + int n = lookup_usb_device(vendor_id, product_id, version, info, info2); + + if (n <= 0) { + set_err(EINVAL, "Unknown USB bridge %s", + format_usb_id(vendor_id, product_id, version).c_str()); + return 0; + } + + if (n > 1) { + set_err(EINVAL, "USB bridge %s type is ambiguous: '%s' or '%s'", + format_usb_id(vendor_id, product_id, version).c_str(), + (!info.usb_type.empty() ? info.usb_type.c_str() : "[unsupported]"), + (!info2.usb_type.empty() ? info2.usb_type.c_str() : "[unsupported]")); + return 0; + } + + if (info.usb_type.empty()) { + set_err(ENOSYS, "Unsupported USB bridge %s", + format_usb_id(vendor_id, product_id, version).c_str()); + return 0; + } + + // TODO: change return type to std::string + static std::string type; + type = info.usb_type; + return type.c_str(); +} |