diff options
Diffstat (limited to '')
| -rw-r--r-- | dev_areca.cpp | 695 |
1 files changed, 695 insertions, 0 deletions
diff --git a/dev_areca.cpp b/dev_areca.cpp new file mode 100644 index 0000000..5b47eac --- /dev/null +++ b/dev_areca.cpp @@ -0,0 +1,695 @@ +/* + * dev_areca.cpp + * + * Home page of code is: https://www.smartmontools.org + * + * Copyright (C) 2012 Hank Wu <hank@areca.com.tw> + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ + +#include "config.h" + +#include "dev_interface.h" +#include "dev_areca.h" + +const char * dev_areca_cpp_cvsid = "$Id: dev_areca.cpp 5337 2022-02-27 07:53:55Z dpgilbert $" + DEV_ARECA_H_CVSID; + +#include "atacmds.h" +#include "scsicmds.h" + +#include <errno.h> + +#if 0 // For debugging areca code +static void dumpdata(unsigned char *block, int len) +{ + int ln = (len / 16) + 1; // total line# + unsigned char c; + int pos = 0; + + printf(" Address = %p, Length = (0x%x)%d\n", block, len, len); + printf(" 0 1 2 3 4 5 6 7 8 9 A B C D E F ASCII \n"); + printf("=====================================================================\n"); + + for ( int l = 0; l < ln && len; l++ ) + { + // printf the line# and the HEX data + // if a line data length < 16 then append the space to the tail of line to reach 16 chars + printf("%02X | ", l); + for ( pos = 0; pos < 16 && len; pos++, len-- ) + { + c = block[l*16+pos]; + printf("%02X ", c); + } + + if ( pos < 16 ) + { + for ( int loop = pos; loop < 16; loop++ ) + { + printf(" "); + } + } + + // print ASCII char + for ( int loop = 0; loop < pos; loop++ ) + { + c = block[l*16+loop]; + if ( c >= 0x20 && c <= 0x7F ) + { + printf("%c", c); + } + else + { + printf("."); + } + } + printf("\n"); + } + printf("=====================================================================\n"); +} +#endif + +generic_areca_device::generic_areca_device(smart_interface * intf, const char * dev_name, int disknum, int encnum) +: smart_device(intf, dev_name, "areca", "areca"), + m_disknum(disknum), + m_encnum(encnum) +{ + set_info().info_name = strprintf("%s [areca_disk#%02d_enc#%02d]", dev_name, disknum, encnum); +} + +generic_areca_device::~generic_areca_device() +{ + +} + +// PURPOSE +// This is an interface routine meant to isolate the OS dependent +// parts of the code, and to provide a debugging interface. Each +// different port and OS needs to provide it's own interface. This +// is the Windows interface to the Areca "arcmsr" driver. It allows ATA +// commands to be passed through the SCSI driver. +// DETAILED DESCRIPTION OF ARGUMENTS +// fd: is the file descriptor provided by open() +// disknum is the disk number (0 to 127) in the RAID array +// command: defines the different 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" +int generic_areca_device::arcmsr_command_handler(unsigned long arcmsr_cmd, unsigned char *data, int data_len) +{ + if (arcmsr_cmd >= ARCMSR_CMD_TOTAL) + return -1; + + static const unsigned int cmds[ARCMSR_CMD_TOTAL] = + { + ARCMSR_IOCTL_READ_RQBUFFER, + ARCMSR_IOCTL_WRITE_WQBUFFER, + ARCMSR_IOCTL_CLEAR_RQBUFFER, + ARCMSR_IOCTL_CLEAR_WQBUFFER, + ARCMSR_IOCTL_RETURN_CODE_3F + }; + + int ioctlreturn = 0; + sSRB_BUFFER sBuf; + struct scsi_cmnd_io iop = {}; + int dir = DXFER_TO_DEVICE; + + uint8_t cdb[10]={}; + uint8_t sense[32]={}; + + unsigned char *areca_return_packet; + int total = 0; + int expected = -1; + unsigned char return_buff[2048]={0}; + unsigned char *ptr = &return_buff[0]; + + memset((unsigned char *)&sBuf, 0, sizeof(sBuf)); + + sBuf.srbioctl.HeaderLength = sizeof(sARCMSR_IO_HDR); + memcpy(sBuf.srbioctl.Signature, ARECA_SIG_STR, strlen(ARECA_SIG_STR)); + sBuf.srbioctl.Timeout = 10000; + sBuf.srbioctl.ControlCode = cmds[arcmsr_cmd]; + + switch ( arcmsr_cmd ) + { + // command for writing data to driver + case ARCMSR_WRITE_WQBUFFER: + if ( data && data_len ) + { + sBuf.srbioctl.Length = data_len; + memcpy((unsigned char *)sBuf.ioctldatabuffer, (unsigned char *)data, data_len); + } + /* FALLTHRU */ + // commands for clearing related buffer of driver + case ARCMSR_CLEAR_RQBUFFER: + case ARCMSR_CLEAR_WQBUFFER: + cdb[0] = 0x3B; //SCSI_WRITE_BUF command; + break; + // command for reading data from driver + case ARCMSR_READ_RQBUFFER: + // command for identifying driver + case ARCMSR_RETURN_CODE_3F: + cdb[0] = 0x3C; //SCSI_READ_BUF command; + dir = DXFER_FROM_DEVICE; + break; + default: + // unknown arcmsr commands + return -1; + } + + cdb[1] = 0x01; + cdb[2] = 0xf0; + cdb[5] = cmds[arcmsr_cmd] >> 24; + cdb[6] = cmds[arcmsr_cmd] >> 16; + cdb[7] = cmds[arcmsr_cmd] >> 8; + cdb[8] = cmds[arcmsr_cmd] & 0x0F; + + iop.dxfer_dir = dir; + iop.dxfer_len = sizeof(sBuf); + iop.dxferp = (unsigned char *)&sBuf; + iop.cmnd = cdb; + iop.cmnd_len = sizeof(cdb); + iop.sensep = sense; + iop.max_sense_len = sizeof(sense); + iop.timeout = SCSI_TIMEOUT_DEFAULT; + + while ( 1 ) + { + ioctlreturn = arcmsr_do_scsi_io(&iop); + if(ioctlreturn || iop.scsi_status) + { + break; + } + + if ( arcmsr_cmd != ARCMSR_READ_RQBUFFER ) + { + // if succeeded, just returns the length of outgoing data + return data_len; + } + + if ( sBuf.srbioctl.Length ) + { + memcpy(ptr, &sBuf.ioctldatabuffer[0], sBuf.srbioctl.Length); + ptr += sBuf.srbioctl.Length; + total += sBuf.srbioctl.Length; + // the returned bytes enough to compute payload length ? + if ( expected < 0 && total >= 5 ) + { + areca_return_packet = (unsigned char *)&return_buff[0]; + if ( areca_return_packet[0] == 0x5E && + areca_return_packet[1] == 0x01 && + areca_return_packet[2] == 0x61 ) + { + // valid header, let's compute the returned payload length, + // we expected the total length is + // payload + 3 bytes header + 2 bytes length + 1 byte checksum + expected = areca_return_packet[4] * 256 + areca_return_packet[3] + 6; + } + } + + if ( total >= 7 && total >= expected ) + { + //printf("total bytes received = %d, expected length = %d\n", total, expected); + + // ------ Okay! we received enough -------- + break; + } + } + } + + // Deal with the different error cases + if ( arcmsr_cmd == ARCMSR_RETURN_CODE_3F ) + { + // Silence the ARCMSR_IOCTL_RETURN_CODE_3F's error, no pout(...) + return -4; + } + + if ( ioctlreturn ) + { + pout("do_scsi_cmnd_io with write buffer failed code = %x\n", ioctlreturn); + return -2; + } + + if ( iop.scsi_status ) + { + pout("io_hdr.scsi_status with write buffer failed code = %x\n", iop.scsi_status); + return -3; + } + + if ( data ) + { + memcpy(data, return_buff, total); + } + + return total; +} + +bool generic_areca_device::arcmsr_probe() +{ + if(!is_open()) + { + open(); + } + + if(arcmsr_command_handler(ARCMSR_RETURN_CODE_3F, NULL, 0) != 0) + { + return false; + } + return true; +} + +int generic_areca_device::arcmsr_ui_handler(unsigned char *areca_packet, int areca_packet_len, unsigned char *result) +{ + int expected = 0; + unsigned char return_buff[2048]; + unsigned char cs = 0; + int cs_pos = 0; + + // ----- ADD CHECKSUM ----- + cs_pos = areca_packet_len - 1; + for(int i = 3; i < cs_pos; i++) + { + areca_packet[cs_pos] += areca_packet[i]; + } + + if(!arcmsr_lock()) + { + return -1; + } + expected = arcmsr_command_handler(ARCMSR_CLEAR_RQBUFFER, NULL, 0); + if (expected==-3) { + return set_err(EIO); + } + arcmsr_command_handler(ARCMSR_CLEAR_WQBUFFER, NULL, 0); + expected = arcmsr_command_handler(ARCMSR_WRITE_WQBUFFER, areca_packet, areca_packet_len); + if ( expected > 0 ) + { + expected = arcmsr_command_handler(ARCMSR_READ_RQBUFFER, return_buff, sizeof(return_buff)); + } + + if ( expected < 3 + 1 ) // Prefix + Checksum + { + return -1; + } + + if(!arcmsr_unlock()) + { + return -1; + } + + // ----- VERIFY THE CHECKSUM ----- + cs = 0; + for ( int loop = 3; loop < expected - 1; loop++ ) + { + cs += return_buff[loop]; + } + + if ( return_buff[expected - 1] != cs ) + { + return -1; + } + + memcpy(result, return_buff, expected); + + return expected; +} + +int generic_areca_device::arcmsr_get_controller_type() +{ + int expected = 0; + unsigned char return_buff[2048]; + unsigned char areca_packet[] = {0x5E, 0x01, 0x61, 0x01, 0x00, 0x23, 0x00}; + + memset(return_buff, 0, sizeof(return_buff)); + expected = arcmsr_ui_handler(areca_packet, sizeof(areca_packet), return_buff); + if ( expected < 0 ) + { + return -1; + } + + return return_buff[0xc2]; +} + +int generic_areca_device::arcmsr_get_dev_type() +{ + int expected = 0; + unsigned char return_buff[2048]; + int ctlr_type = -1; + int encnum = get_encnum(); + int disknum = get_disknum(); + unsigned char areca_packet[] = {0x5E, 0x01, 0x61, 0x03, 0x00, 0x22, + (unsigned char)(disknum - 1), (unsigned char)(encnum - 1), 0x00}; + + memset(return_buff, 0, sizeof(return_buff)); + expected = arcmsr_ui_handler(areca_packet, sizeof(areca_packet), return_buff); + if ( expected < 0 ) + { + return -1; + } + + ctlr_type = arcmsr_get_controller_type(); + + if( ctlr_type < 0 ) + { + return ctlr_type; + } + + if( ctlr_type == 0x02/* SATA Controllers */ || + (ctlr_type == 0x03 /* SAS Controllers */ && return_buff[0x52] & 0x01 /* SATA devices behind SAS Controller */) ) + { + // SATA device + return 1; + } + + // SAS device + return 0; +} + +bool generic_areca_device::arcmsr_ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out) +{ + // ATA input registers + typedef struct _ATA_INPUT_REGISTERS + { + unsigned char features; + unsigned char sector_count; + unsigned char sector_number; + unsigned char cylinder_low; + unsigned char cylinder_high; + unsigned char device_head; + unsigned char command; + unsigned char reserved[8]; + unsigned char data[512]; // [in/out] buffer for outgoing/incoming data + } sATA_INPUT_REGISTERS; + + // ATA output registers + // Note: The output registers is re-sorted for areca internal use only + typedef struct _ATA_OUTPUT_REGISTERS + { + unsigned char error; + unsigned char status; + unsigned char sector_count; + unsigned char sector_number; + unsigned char cylinder_low; + unsigned char cylinder_high; + } sATA_OUTPUT_REGISTERS; + + // Areca packet format for outgoing: + // B[0~2] : 3 bytes header, fixed value 0x5E, 0x01, 0x61 + // B[3~4] : 2 bytes command length + variant data length, little endian + // B[5] : 1 bytes areca defined command code, ATA passthrough command code is 0x1c + // B[6~last-1] : variant bytes payload data + // B[last] : 1 byte checksum, simply sum(B[3] ~ B[last -1]) + // + // + // header 3 bytes length 2 bytes cmd 1 byte payload data x bytes cs 1 byte + // +--------------------------------------------------------------------------------+ + // + 0x5E 0x01 0x61 | 0x00 0x00 | 0x1c | .................... | 0x00 | + // +--------------------------------------------------------------------------------+ + // + + //Areca packet format for incoming: + // B[0~2] : 3 bytes header, fixed value 0x5E, 0x01, 0x61 + // B[3~4] : 2 bytes payload length, little endian + // B[5~last-1] : variant bytes returned payload data + // B[last] : 1 byte checksum, simply sum(B[3] ~ B[last -1]) + // + // + // header 3 bytes length 2 bytes payload data x bytes cs 1 byte + // +-------------------------------------------------------------------+ + // + 0x5E 0x01 0x61 | 0x00 0x00 | .................... | 0x00 | + // +-------------------------------------------------------------------+ + unsigned char areca_packet[640]; + int areca_packet_len = sizeof(areca_packet); + unsigned char return_buff[2048]; + int expected = 0; + + sATA_INPUT_REGISTERS *ata_cmd; + + // For debugging +#if 0 + memset(sInq, 0, sizeof(sInq)); + scsiStdInquiry(fd, (unsigned char *)sInq, (int)sizeof(sInq)); + dumpdata((unsigned char *)sInq, sizeof(sInq)); +#endif + memset(areca_packet, 0, areca_packet_len); + + // ----- BEGIN TO SETUP HEADERS ------- + areca_packet[0] = 0x5E; + areca_packet[1] = 0x01; + areca_packet[2] = 0x61; + areca_packet[3] = (unsigned char)((areca_packet_len - 6) & 0xff); + areca_packet[4] = (unsigned char)(((areca_packet_len - 6) >> 8) & 0xff); + areca_packet[5] = 0x1c; // areca defined code for ATA passthrough command + + // ----- BEGIN TO SETUP PAYLOAD DATA ----- + memcpy(&areca_packet[7], "SmrT", 4); // areca defined password + ata_cmd = (sATA_INPUT_REGISTERS *)&areca_packet[12]; + + // Set registers + { + const ata_in_regs & r = in.in_regs; + ata_cmd->features = r.features; + ata_cmd->sector_count = r.sector_count; + ata_cmd->sector_number = r.lba_low; + ata_cmd->cylinder_low = r.lba_mid; + ata_cmd->cylinder_high = r.lba_high; + ata_cmd->device_head = r.device; + ata_cmd->command = r.command; + } + bool readdata = false; + if (in.direction == ata_cmd_in::data_in) { + readdata = true; + // the command will read data + areca_packet[6] = 0x13; + } + else if ( in.direction == ata_cmd_in::no_data ) + { + // the commands will return no data + areca_packet[6] = 0x15; + } + else if (in.direction == ata_cmd_in::data_out) + { + // the commands will write data + memcpy(ata_cmd->data, in.buffer, in.size); + areca_packet[6] = 0x14; + } + else { + // COMMAND NOT SUPPORTED VIA ARECA IOCTL INTERFACE + return set_err(ENOSYS); + } + + areca_packet[11] = get_disknum() - 1; // disk# + areca_packet[19] = get_encnum() - 1; // enc# + + // ----- BEGIN TO SEND TO ARECA DRIVER ------ + expected = arcmsr_ui_handler(areca_packet, areca_packet_len, return_buff); + if ( expected < 0 ) + { + return set_err(EIO); + } + + sATA_OUTPUT_REGISTERS *ata_out = (sATA_OUTPUT_REGISTERS *)&return_buff[5] ; + if ( ata_out->status ) + { + if ( in.in_regs.command == ATA_IDENTIFY_DEVICE + && !nonempty((unsigned char *)in.buffer, in.size)) + { + return set_err(ENODEV, "No drive on port %d", get_disknum()); + } + } + + // returns with data + if (readdata) + { + memcpy(in.buffer, &return_buff[7], in.size); + } + + // Return register values + { + ata_out_regs & r = out.out_regs; + r.error = ata_out->error; + r.sector_count = ata_out->sector_count; + r.lba_low = ata_out->sector_number; + r.lba_mid = ata_out->cylinder_low; + r.lba_high = ata_out->cylinder_high; + r.status = ata_out->status; + } + return true; +} + +bool generic_areca_device::arcmsr_scsi_pass_through(struct scsi_cmnd_io * iop) +{ + // Areca packet format for outgoing: + // B[0~2] : 3 bytes header, fixed value 0x5E, 0x01, 0x61 + // B[3~4] : 2 bytes command length + variant data length, little endian + // B[5] : 1 bytes areca defined command code + // B[6~last-1] : variant bytes payload data + // B[last] : 1 byte checksum, simply sum(B[3] ~ B[last -1]) + // + // + // header 3 bytes length 2 bytes cmd 1 byte payload data x bytes cs 1 byte + // +--------------------------------------------------------------------------------+ + // + 0x5E 0x01 0x61 | 0x00 0x00 | 0x1c | .................... | 0x00 | + // +--------------------------------------------------------------------------------+ + // + + //Areca packet format for incoming: + // B[0~2] : 3 bytes header, fixed value 0x5E, 0x01, 0x61 + // B[3~4] : 2 bytes payload length, little endian + // B[5~last-1] : variant bytes returned payload data + // B[last] : 1 byte checksum, simply sum(B[3] ~ B[last -1]) + // + // + // header 3 bytes length 2 bytes payload data x bytes cs 1 byte + // +-------------------------------------------------------------------+ + // + 0x5E 0x01 0x61 | 0x00 0x00 | .................... | 0x00 | + // +-------------------------------------------------------------------+ + unsigned char areca_packet[640]; + int areca_packet_len = sizeof(areca_packet); + unsigned char return_buff[2048]; + int expected = 0; + + if (iop->cmnd_len > 16) { + set_err(EINVAL, "cmnd_len too large"); + return false; + } + + memset(areca_packet, 0, areca_packet_len); + + // ----- BEGIN TO SETUP HEADERS ------- + areca_packet[0] = 0x5E; + areca_packet[1] = 0x01; + areca_packet[2] = 0x61; + areca_packet[3] = (unsigned char)((areca_packet_len - 6) & 0xff); + areca_packet[4] = (unsigned char)(((areca_packet_len - 6) >> 8) & 0xff); + areca_packet[5] = 0x1c; + + // ----- BEGIN TO SETUP PAYLOAD DATA ----- + areca_packet[6] = 0x16; // scsi pass through + memcpy(&areca_packet[7], "SmrT", 4); // areca defined password + areca_packet[12] = iop->cmnd_len; // cdb length + memcpy( &areca_packet[35], iop->cmnd, iop->cmnd_len); // cdb + areca_packet[15] = (unsigned char)iop->dxfer_len; // 15(LSB) ~ 18(MSB): data length ( max=512 bytes) + areca_packet[16] = (unsigned char)(iop->dxfer_len >> 8); + areca_packet[17] = (unsigned char)(iop->dxfer_len >> 16); + areca_packet[18] = (unsigned char)(iop->dxfer_len >> 24); + if(iop->dxfer_dir == DXFER_TO_DEVICE) + { + areca_packet[13] |= 0x01; + memcpy(&areca_packet[67], iop->dxferp, iop->dxfer_len); + } + else if (iop->dxfer_dir == DXFER_FROM_DEVICE) + { + } + else if( iop->dxfer_dir == DXFER_NONE) + { + } + else { + // COMMAND NOT SUPPORTED VIA ARECA IOCTL INTERFACE + return set_err(ENOSYS); + } + + areca_packet[11] = get_disknum() - 1; // disk# + areca_packet[19] = get_encnum() - 1; // enc# + + // ----- BEGIN TO SEND TO ARECA DRIVER ------ + expected = arcmsr_ui_handler(areca_packet, areca_packet_len, return_buff); + + if (expected < 0) + return set_err(EIO, "arcmsr_scsi_pass_through: I/O error"); + if (expected < 15) // 7 bytes if port is empty + return set_err(EIO, "arcmsr_scsi_pass_through: missing data (%d bytes, expected %d)", expected, 15); + + int scsi_status = return_buff[5]; + int in_data_len = return_buff[11] | return_buff[12] << 8 | return_buff[13] << 16 | return_buff[14] << 24; + + if (iop->dxfer_dir == DXFER_FROM_DEVICE) + { + memset(iop->dxferp, 0, iop->dxfer_len); // need? + memcpy(iop->dxferp, &return_buff[15], in_data_len); + } + + if(scsi_status == 0xE1 /* Underrun, actual data length < requested data length */) + { + // don't care, just ignore + scsi_status = 0x0; + } + + if(scsi_status != 0x00 && scsi_status != SCSI_STATUS_CHECK_CONDITION) + { + return set_err(EIO); + } + + if(scsi_status == SCSI_STATUS_CHECK_CONDITION) + { + // check condition + iop->scsi_status = SCSI_STATUS_CHECK_CONDITION; + iop->resp_sense_len = 4; + iop->sensep[0] = return_buff[7]; + iop->sensep[1] = return_buff[8]; + iop->sensep[2] = return_buff[9]; + iop->sensep[3] = return_buff[10]; + } + + return true; +} + +///////////////////////////////////////////////////////////// +areca_ata_device::areca_ata_device(smart_interface * intf, const char * dev_name, int disknum, int encnum) +: smart_device(intf, dev_name, "areca", "areca") +{ + set_encnum(encnum); + set_disknum(disknum); + set_info().info_name = strprintf("%s [areca_disk#%02d_enc#%02d]", dev_name, disknum, encnum); +} + +areca_ata_device::~areca_ata_device() +{ + +} + +bool areca_ata_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 | // TODO + ata_device::supports_48bit_hi_null, + "Areca") + ) + return false; + + return arcmsr_ata_pass_through(in, out); +} + +///////////////////////////////////////////////////////////// +areca_scsi_device::areca_scsi_device(smart_interface * intf, const char * dev_name, int disknum, int encnum) +: smart_device(intf, dev_name, "areca", "areca") +{ + set_encnum(encnum); + set_disknum(disknum); + set_info().info_name = strprintf("%s [areca_disk#%02d_enc#%02d]", dev_name, disknum, encnum); +} + +areca_scsi_device::~areca_scsi_device() +{ + +} + +bool areca_scsi_device::scsi_pass_through(struct scsi_cmnd_io * iop) +{ + return arcmsr_scsi_pass_through(iop); +} + + + + |