aaru-dps/Aaru.Server
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.Server.git synced 2025-12-16 19:24:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor: Formatting.

Browse Source
This commit is contained in:
Natalia Portillo
2017-12-18 18:28:33 +00:00
parent c30a547b17
commit ea2097d03f
24 changed files with 1963 additions and 1358 deletions
Download Patch File Download Diff File Expand all files Collapse all files

255
DiscImageChef.Device.Report/ata.c
View File

@@ -4,6 +4,7 @@
#include <scsi/sg.h> #include <scsi/sg.h>
#include <malloc.h> #include <malloc.h>
#include <stdint.h>
#include <string.h> #include <string.h>
#include "ata.h" #include "ata.h"
#include "scsi.h" #include "scsi.h"
@@ -30,13 +31,13 @@ int AtaProtocolToScsiDirection(int protocol)
} }
} }
unsigned char *AtaToCString(unsigned char* string, int len) unsigned char *AtaToCString(unsigned char *string, int len)
{ {
unsigned char* buffer = malloc(len + 1); unsigned char *buffer = malloc(len + 1);
unsigned char* ptr = buffer; unsigned char *ptr = buffer;
int i; int i;
for(i = 0; i < len; i+=2) for(i = 0; i < len; i += 2)
{ {
*ptr++ = *(string + i + 1); *ptr++ = *(string + i + 1);
*ptr++ = *(string + i); *ptr++ = *(string + i);
@@ -56,7 +57,8 @@ unsigned char *AtaToCString(unsigned char* string, int len)
return buffer; return buffer;
} }
int SendAtaCommandChs(int fd, AtaRegistersCHS registers, AtaErrorRegistersCHS **errorRegisters, int protocol, int transferRegister, unsigned char *buffer, unsigned int buffer_len, int transferBlocks) int SendAtaCommandChs(int fd, AtaRegistersCHS registers, AtaErrorRegistersCHS **errorRegisters, int protocol,
int transferRegister, unsigned char *buffer, unsigned int buffer_len, int transferBlocks)
{ {
unsigned char cdb[16]; unsigned char cdb[16];
memset(&cdb, 0, 16); memset(&cdb, 0, 16);
@@ -81,26 +83,27 @@ int SendAtaCommandChs(int fd, AtaRegistersCHS registers, AtaErrorRegistersCHS **
cdb[2] |= (transferRegister & 0x03); cdb[2] |= (transferRegister & 0x03);
} }
cdb[4] = registers.feature; cdb[4] = registers.feature;
cdb[6] = registers.sectorCount; cdb[6] = registers.sectorCount;
cdb[8] = registers.sector; cdb[8] = registers.sector;
cdb[10] = registers.cylinderLow; cdb[10] = registers.cylinderLow;
cdb[12] = registers.cylinderHigh; cdb[12] = registers.cylinderHigh;
cdb[13] = registers.deviceHead; cdb[13] = registers.deviceHead;
cdb[14] = registers.command; cdb[14] = registers.command;
unsigned char *sense_buf; unsigned char *sense_buf;
int error = SendScsiCommand(fd, &cdb, 16, buffer, buffer_len, &sense_buf, AtaProtocolToScsiDirection(protocol)); int error = SendScsiCommand(fd, &cdb, 16, buffer, buffer_len, &sense_buf,
AtaProtocolToScsiDirection(protocol));
*errorRegisters = malloc(sizeof(AtaErrorRegistersCHS)); *errorRegisters = malloc(sizeof(AtaErrorRegistersCHS));
memset(*errorRegisters, 0, sizeof(AtaErrorRegistersCHS)); memset(*errorRegisters, 0, sizeof(AtaErrorRegistersCHS));
(*errorRegisters)->error = sense_buf[11]; (*errorRegisters)->error = sense_buf[11];
(*errorRegisters)->sectorCount = sense_buf[13]; (*errorRegisters)->sectorCount = sense_buf[13];
(*errorRegisters)->sector = sense_buf[15]; (*errorRegisters)->sector = sense_buf[15];
(*errorRegisters)->cylinderLow = sense_buf[17]; (*errorRegisters)->cylinderLow = sense_buf[17];
(*errorRegisters)->cylinderHigh = sense_buf[19]; (*errorRegisters)->cylinderHigh = sense_buf[19];
(*errorRegisters)->deviceHead = sense_buf[20]; (*errorRegisters)->deviceHead = sense_buf[20];
(*errorRegisters)->status = sense_buf[21]; (*errorRegisters)->status = sense_buf[21];
if(error != 0) if(error != 0)
return error; return error;
@@ -108,7 +111,8 @@ int SendAtaCommandChs(int fd, AtaRegistersCHS registers, AtaErrorRegistersCHS **
return (*errorRegisters)->error; return (*errorRegisters)->error;
} }
int SendAtaCommandLba28(int fd, AtaRegistersLBA28 registers, AtaErrorRegistersLBA28 **errorRegisters, int protocol, int transferRegister, unsigned char *buffer, unsigned int buffer_len, int transferBlocks) int SendAtaCommandLba28(int fd, AtaRegistersLBA28 registers, AtaErrorRegistersLBA28 **errorRegisters, int protocol,
int transferRegister, unsigned char *buffer, unsigned int buffer_len, int transferBlocks)
{ {
unsigned char cdb[16]; unsigned char cdb[16];
memset(&cdb, 0, 16); memset(&cdb, 0, 16);
@@ -135,26 +139,27 @@ int SendAtaCommandLba28(int fd, AtaRegistersLBA28 registers, AtaErrorRegistersLB
cdb[2] |= 0x20; cdb[2] |= 0x20;
cdb[4] = registers.feature; cdb[4] = registers.feature;
cdb[6] = registers.sectorCount; cdb[6] = registers.sectorCount;
cdb[8] = registers.lbaLow; cdb[8] = registers.lbaLow;
cdb[10] = registers.lbaMid; cdb[10] = registers.lbaMid;
cdb[12] = registers.lbaHigh; cdb[12] = registers.lbaHigh;
cdb[13] = registers.deviceHead; cdb[13] = registers.deviceHead;
cdb[14] = registers.command; cdb[14] = registers.command;
unsigned char *sense_buf; unsigned char *sense_buf;
int error = SendScsiCommand(fd, &cdb, 16, buffer, buffer_len, &sense_buf, AtaProtocolToScsiDirection(protocol)); int error = SendScsiCommand(fd, &cdb, 16, buffer, buffer_len, &sense_buf,
AtaProtocolToScsiDirection(protocol));
*errorRegisters = malloc(sizeof(AtaErrorRegistersLBA28)); *errorRegisters = malloc(sizeof(AtaErrorRegistersLBA28));
memset(*errorRegisters, 0, sizeof(AtaErrorRegistersLBA28)); memset(*errorRegisters, 0, sizeof(AtaErrorRegistersLBA28));
(*errorRegisters)->error = sense_buf[11]; (*errorRegisters)->error = sense_buf[11];
(*errorRegisters)->sectorCount = sense_buf[13]; (*errorRegisters)->sectorCount = sense_buf[13];
(*errorRegisters)->lbaLow = sense_buf[15]; (*errorRegisters)->lbaLow = sense_buf[15];
(*errorRegisters)->lbaMid= sense_buf[17]; (*errorRegisters)->lbaMid = sense_buf[17];
(*errorRegisters)->lbaHigh = sense_buf[19]; (*errorRegisters)->lbaHigh = sense_buf[19];
(*errorRegisters)->deviceHead = sense_buf[20]; (*errorRegisters)->deviceHead = sense_buf[20];
(*errorRegisters)->status = sense_buf[21]; (*errorRegisters)->status = sense_buf[21];
if(error != 0) if(error != 0)
return error; return error;
@@ -162,7 +167,8 @@ int SendAtaCommandLba28(int fd, AtaRegistersLBA28 registers, AtaErrorRegistersLB
return (*errorRegisters)->error; return (*errorRegisters)->error;
} }
int SendAtaCommandLba48(int fd, AtaRegistersLBA48 registers, AtaErrorRegistersLBA48 **errorRegisters, int protocol, int transferRegister, unsigned char *buffer, unsigned int buffer_len, int transferBlocks) int SendAtaCommandLba48(int fd, AtaRegistersLBA48 registers, AtaErrorRegistersLBA48 **errorRegisters, int protocol,
int transferRegister, unsigned char *buffer, unsigned int buffer_len, int transferBlocks)
{ {
unsigned char cdb[16]; unsigned char cdb[16];
memset(&cdb, 0, 16); memset(&cdb, 0, 16);
@@ -190,31 +196,32 @@ int SendAtaCommandLba48(int fd, AtaRegistersLBA48 registers, AtaErrorRegistersLB
cdb[2] |= 0x20; cdb[2] |= 0x20;
cdb[3] = (uint8_t)((registers.feature & 0xFF00) >> 8); cdb[3] = (uint8_t)((registers.feature & 0xFF00) >> 8);
cdb[4] = (uint8_t)(registers.feature & 0xFF); cdb[4] = (uint8_t)(registers.feature & 0xFF);
cdb[5] = (uint8_t)((registers.sectorCount & 0xFF00) >> 8); cdb[5] = (uint8_t)((registers.sectorCount & 0xFF00) >> 8);
cdb[6] = (uint8_t)(registers.sectorCount & 0xFF); cdb[6] = (uint8_t)(registers.sectorCount & 0xFF);
cdb[7] = (uint8_t)((registers.lbaLow & 0xFF00) >> 8); cdb[7] = (uint8_t)((registers.lbaLow & 0xFF00) >> 8);
cdb[8] = (uint8_t)(registers.lbaLow & 0xFF); cdb[8] = (uint8_t)(registers.lbaLow & 0xFF);
cdb[9] = (uint8_t)((registers.lbaMid & 0xFF00) >> 8); cdb[9] = (uint8_t)((registers.lbaMid & 0xFF00) >> 8);
cdb[10] = (uint8_t)(registers.lbaMid & 0xFF); cdb[10] = (uint8_t)(registers.lbaMid & 0xFF);
cdb[11] = (uint8_t)((registers.lbaHigh & 0xFF00) >> 8); cdb[11] = (uint8_t)((registers.lbaHigh & 0xFF00) >> 8);
cdb[12] = (uint8_t)(registers.lbaHigh & 0xFF); cdb[12] = (uint8_t)(registers.lbaHigh & 0xFF);
cdb[13] = registers.deviceHead; cdb[13] = registers.deviceHead;
cdb[14] = registers.command; cdb[14] = registers.command;
unsigned char *sense_buf; unsigned char *sense_buf;
int error = SendScsiCommand(fd, &cdb, 16, buffer, buffer_len, &sense_buf, AtaProtocolToScsiDirection(protocol)); int error = SendScsiCommand(fd, &cdb, 16, buffer, buffer_len, &sense_buf,
AtaProtocolToScsiDirection(protocol));
*errorRegisters = malloc(sizeof(AtaErrorRegistersLBA48)); *errorRegisters = malloc(sizeof(AtaErrorRegistersLBA48));
memset(*errorRegisters, 0, sizeof(AtaErrorRegistersLBA48)); memset(*errorRegisters, 0, sizeof(AtaErrorRegistersLBA48));
(*errorRegisters)->error = sense_buf[11]; (*errorRegisters)->error = sense_buf[11];
(*errorRegisters)->sectorCount = (uint16_t)((sense_buf[12] << 8) + sense_buf[13]); (*errorRegisters)->sectorCount = (uint16_t)((sense_buf[12] << 8) + sense_buf[13]);
(*errorRegisters)->lbaLow = (uint16_t)((sense_buf[14] << 8) + sense_buf[15]); (*errorRegisters)->lbaLow = (uint16_t)((sense_buf[14] << 8) + sense_buf[15]);
(*errorRegisters)->lbaMid = (uint16_t)((sense_buf[16] << 8) + sense_buf[17]); (*errorRegisters)->lbaMid = (uint16_t)((sense_buf[16] << 8) + sense_buf[17]);
(*errorRegisters)->lbaHigh = (uint16_t)((sense_buf[18] << 8) + sense_buf[19]); (*errorRegisters)->lbaHigh = (uint16_t)((sense_buf[18] << 8) + sense_buf[19]);
(*errorRegisters)->deviceHead = sense_buf[20]; (*errorRegisters)->deviceHead = sense_buf[20];
(*errorRegisters)->status = sense_buf[21]; (*errorRegisters)->status = sense_buf[21];
if(error != 0) if(error != 0)
return error; return error;
@@ -231,12 +238,15 @@ int Identify(int fd, unsigned char **buffer, AtaErrorRegistersCHS **errorRegiste
registers.command = ATA_IDENTIFY_DEVICE; registers.command = ATA_IDENTIFY_DEVICE;
int error = SendAtaCommandChs(fd, registers, errorRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_NONE, *buffer, 512, 0); int error = SendAtaCommandChs(fd, registers, errorRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_NONE, *buffer, 512,
0);
return error; return error;
} }
int Read(int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegisters, int retry, uint16_t cylinder, uint8_t head, uint8_t sector, uint8_t count) int
Read(int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegisters, int retry, uint16_t cylinder, uint8_t head,
uint8_t sector, uint8_t count)
{ {
int buffer_len; int buffer_len;
if(count == 0) if(count == 0)
@@ -252,19 +262,21 @@ int Read(int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegisters,
if(retry) if(retry)
registers.command = ATA_READ_RETRY; registers.command = ATA_READ_RETRY;
else else
registers.command = ATA_READ_SECTORS; registers.command = ATA_READ_SECTORS;
registers.sectorCount = count; registers.sectorCount = count;
registers.cylinderHigh = (uint8_t)((cylinder & 0xFF00) / 0x100); registers.cylinderHigh = (uint8_t)((cylinder & 0xFF00) / 0x100);
registers.cylinderLow = (uint8_t)((cylinder & 0xFF) / 0x1); registers.cylinderLow = (uint8_t)((cylinder & 0xFF) / 0x1);
registers.deviceHead = (uint8_t)(head & 0x0F); registers.deviceHead = (uint8_t)(head & 0x0F);
registers.sector = sector; registers.sector = sector;
int error = SendAtaCommandChs(fd, registers, statusRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_SECTORCOUNT, *buffer, buffer_len, 1); int error = SendAtaCommandChs(fd, registers, statusRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_SECTORCOUNT,
*buffer, buffer_len, 1);
return error; return error;
} }
int ReadLong(int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegisters, int retry, uint16_t cylinder, uint8_t head, uint8_t sector, uint32_t blockSize) int ReadLong(int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegisters, int retry, uint16_t cylinder,
uint8_t head, uint8_t sector, uint32_t blockSize)
{ {
*buffer = malloc(blockSize); *buffer = malloc(blockSize);
memset(*buffer, 0, blockSize); memset(*buffer, 0, blockSize);
@@ -274,14 +286,15 @@ int ReadLong(int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegist
if(retry) if(retry)
registers.command = ATA_READ_LONG_RETRY; registers.command = ATA_READ_LONG_RETRY;
else else
registers.command = ATA_READ_LONG; registers.command = ATA_READ_LONG;
registers.sectorCount = 1; registers.sectorCount = 1;
registers.cylinderHigh = (uint8_t)((cylinder & 0xFF00) / 0x100); registers.cylinderHigh = (uint8_t)((cylinder & 0xFF00) / 0x100);
registers.cylinderLow = (uint8_t)((cylinder & 0xFF) / 0x1); registers.cylinderLow = (uint8_t)((cylinder & 0xFF) / 0x1);
registers.deviceHead = (uint8_t)(head & 0x0F); registers.deviceHead = (uint8_t)(head & 0x0F);
registers.sector = sector; registers.sector = sector;
int error = SendAtaCommandChs(fd, registers, statusRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_SECTORCOUNT, *buffer, blockSize, 1); int error = SendAtaCommandChs(fd, registers, statusRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_SECTORCOUNT,
*buffer, blockSize, 1);
return error; return error;
} }
@@ -293,18 +306,20 @@ int Seek(int fd, AtaErrorRegistersCHS **statusRegisters, uint16_t cylinder, uint
AtaRegistersCHS registers; AtaRegistersCHS registers;
memset(&registers, 0, sizeof(AtaRegistersCHS)); memset(&registers, 0, sizeof(AtaRegistersCHS));
registers.command = ATA_SEEK; registers.command = ATA_SEEK;
registers.cylinderHigh = (uint8_t)((cylinder & 0xFF00) / 0x100); registers.cylinderHigh = (uint8_t)((cylinder & 0xFF00) / 0x100);
registers.cylinderLow = (uint8_t)((cylinder & 0xFF) / 0x1); registers.cylinderLow = (uint8_t)((cylinder & 0xFF) / 0x1);
registers.deviceHead = (uint8_t)(head & 0x0F); registers.deviceHead = (uint8_t)(head & 0x0F);
registers.sector = sector; registers.sector = sector;
int error = SendAtaCommandChs(fd, registers, statusRegisters, ATA_PROTOCOL_NO_DATA, ATA_TRANSFER_NONE, *buffer, 0, 0); int error = SendAtaCommandChs(fd, registers, statusRegisters, ATA_PROTOCOL_NO_DATA, ATA_TRANSFER_NONE, *buffer, 0,
0);
return error; return error;
} }
int ReadDma(int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegisters, int retry, uint16_t cylinder, uint8_t head, uint8_t sector, uint8_t count) int ReadDma(int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegisters, int retry, uint16_t cylinder,
uint8_t head, uint8_t sector, uint8_t count)
{ {
int buffer_len; int buffer_len;
if(count == 0) if(count == 0)
@@ -320,19 +335,21 @@ int ReadDma(int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegiste
if(retry) if(retry)
registers.command = ATA_READ_DMA_RETRY; registers.command = ATA_READ_DMA_RETRY;
else else
registers.command = ATA_READ_DMA; registers.command = ATA_READ_DMA;
registers.sectorCount = count; registers.sectorCount = count;
registers.cylinderHigh = (uint8_t)((cylinder & 0xFF00) / 0x100); registers.cylinderHigh = (uint8_t)((cylinder & 0xFF00) / 0x100);
registers.cylinderLow = (uint8_t)((cylinder & 0xFF) / 0x1); registers.cylinderLow = (uint8_t)((cylinder & 0xFF) / 0x1);
registers.deviceHead = (uint8_t)(head & 0x0F); registers.deviceHead = (uint8_t)(head & 0x0F);
registers.sector = sector; registers.sector = sector;
int error = SendAtaCommandChs(fd, registers, statusRegisters, ATA_PROTOCOL_DMA, ATA_TRANSFER_SECTORCOUNT, *buffer, buffer_len, 1); int error = SendAtaCommandChs(fd, registers, statusRegisters, ATA_PROTOCOL_DMA, ATA_TRANSFER_SECTORCOUNT, *buffer,
buffer_len, 1);
return error; return error;
} }
int ReadDmaLba(int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRegisters, int retry, uint32_t lba, uint8_t count) int ReadDmaLba(int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRegisters, int retry, uint32_t lba,
uint8_t count)
{ {
int buffer_len; int buffer_len;
if(count == 0) if(count == 0)
@@ -350,18 +367,20 @@ int ReadDmaLba(int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRe
else else
registers.command = ATA_READ_DMA; registers.command = ATA_READ_DMA;
registers.sectorCount = count; registers.sectorCount = count;
registers.deviceHead = (uint8_t)((lba & 0xF000000) / 0x1000000); registers.deviceHead = (uint8_t)((lba & 0xF000000) / 0x1000000);
registers.lbaHigh = (uint8_t)((lba & 0xFF0000) / 0x10000); registers.lbaHigh = (uint8_t)((lba & 0xFF0000) / 0x10000);
registers.lbaMid = (uint8_t)((lba & 0xFF00) / 0x100); registers.lbaMid = (uint8_t)((lba & 0xFF00) / 0x100);
registers.lbaLow = (uint8_t)((lba & 0xFF) / 0x1); registers.lbaLow = (uint8_t)((lba & 0xFF) / 0x1);
registers.deviceHead += 0x40; registers.deviceHead += 0x40;
int error = SendAtaCommandLba28(fd, registers, statusRegisters, ATA_PROTOCOL_DMA, ATA_TRANSFER_SECTORCOUNT, *buffer, buffer_len, 1); int error = SendAtaCommandLba28(fd, registers, statusRegisters, ATA_PROTOCOL_DMA, ATA_TRANSFER_SECTORCOUNT, *buffer,
buffer_len, 1);
return error; return error;
} }
int ReadLba(int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRegisters, int retry, uint32_t lba, uint8_t count) int ReadLba(int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRegisters, int retry, uint32_t lba,
uint8_t count)
{ {
int buffer_len; int buffer_len;
if(count == 0) if(count == 0)
@@ -379,18 +398,20 @@ int ReadLba(int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRegis
else else
registers.command = ATA_READ_SECTORS; registers.command = ATA_READ_SECTORS;
registers.sectorCount = count; registers.sectorCount = count;
registers.deviceHead = (uint8_t)((lba & 0xF000000) / 0x1000000); registers.deviceHead = (uint8_t)((lba & 0xF000000) / 0x1000000);
registers.lbaHigh = (uint8_t)((lba & 0xFF0000) / 0x10000); registers.lbaHigh = (uint8_t)((lba & 0xFF0000) / 0x10000);
registers.lbaMid = (uint8_t)((lba & 0xFF00) / 0x100); registers.lbaMid = (uint8_t)((lba & 0xFF00) / 0x100);
registers.lbaLow = (uint8_t)((lba & 0xFF) / 0x1); registers.lbaLow = (uint8_t)((lba & 0xFF) / 0x1);
registers.deviceHead += 0x40; registers.deviceHead += 0x40;
int error = SendAtaCommandLba28(fd, registers, statusRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_SECTORCOUNT, *buffer, buffer_len, 1); int error = SendAtaCommandLba28(fd, registers, statusRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_SECTORCOUNT,
*buffer, buffer_len, 1);
return error; return error;
} }
int ReadLongLba(int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRegisters, int retry, uint32_t lba, uint32_t blockSize) int ReadLongLba(int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRegisters, int retry, uint32_t lba,
uint32_t blockSize)
{ {
*buffer = malloc(blockSize); *buffer = malloc(blockSize);
memset(*buffer, 0, blockSize); memset(*buffer, 0, blockSize);
@@ -403,13 +424,14 @@ int ReadLongLba(int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusR
registers.command = ATA_READ_LONG; registers.command = ATA_READ_LONG;
registers.sectorCount = 1; registers.sectorCount = 1;
registers.sectorCount = 1; registers.sectorCount = 1;
registers.deviceHead = (uint8_t)((lba & 0xF000000) / 0x1000000); registers.deviceHead = (uint8_t)((lba & 0xF000000) / 0x1000000);
registers.lbaHigh = (uint8_t)((lba & 0xFF0000) / 0x10000); registers.lbaHigh = (uint8_t)((lba & 0xFF0000) / 0x10000);
registers.lbaMid = (uint8_t)((lba & 0xFF00) / 0x100); registers.lbaMid = (uint8_t)((lba & 0xFF00) / 0x100);
registers.lbaLow = (uint8_t)((lba & 0xFF) / 0x1); registers.lbaLow = (uint8_t)((lba & 0xFF) / 0x1);
registers.deviceHead += 0x40; registers.deviceHead += 0x40;
int error = SendAtaCommandLba28(fd, registers, statusRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_SECTORCOUNT, *buffer, blockSize, 1); int error = SendAtaCommandLba28(fd, registers, statusRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_SECTORCOUNT,
*buffer, blockSize, 1);
return error; return error;
} }
@@ -421,14 +443,15 @@ int SeekLba(int fd, AtaErrorRegistersLBA28 **statusRegisters, uint32_t lba)
AtaRegistersLBA28 registers; AtaRegistersLBA28 registers;
memset(&registers, 0, sizeof(AtaRegistersLBA28)); memset(&registers, 0, sizeof(AtaRegistersLBA28));
registers.command = ATA_SEEK; registers.command = ATA_SEEK;
registers.deviceHead = (uint8_t)((lba & 0xF000000) / 0x1000000); registers.deviceHead = (uint8_t)((lba & 0xF000000) / 0x1000000);
registers.lbaHigh = (uint8_t)((lba & 0xFF0000) / 0x10000); registers.lbaHigh = (uint8_t)((lba & 0xFF0000) / 0x10000);
registers.lbaMid = (uint8_t)((lba & 0xFF00) / 0x100); registers.lbaMid = (uint8_t)((lba & 0xFF00) / 0x100);
registers.lbaLow = (uint8_t)((lba & 0xFF) / 0x1); registers.lbaLow = (uint8_t)((lba & 0xFF) / 0x1);
registers.deviceHead += 0x40; registers.deviceHead += 0x40;
int error = SendAtaCommandLba28(fd, registers, statusRegisters, ATA_PROTOCOL_NO_DATA, ATA_TRANSFER_NONE, *buffer, 0, 0); int error = SendAtaCommandLba28(fd, registers, statusRegisters, ATA_PROTOCOL_NO_DATA, ATA_TRANSFER_NONE, *buffer, 0,
0);
return error; return error;
} }
@@ -446,14 +469,15 @@ int ReadDmaLba48(int fd, unsigned char **buffer, AtaErrorRegistersLBA48 **status
AtaRegistersLBA48 registers; AtaRegistersLBA48 registers;
memset(&registers, 0, sizeof(AtaRegistersLBA48)); memset(&registers, 0, sizeof(AtaRegistersLBA48));
registers.command = ATA_READ_DMA_EXT; registers.command = ATA_READ_DMA_EXT;
registers.sectorCount = count; registers.sectorCount = count;
registers.lbaHigh = (uint16_t)((lba & 0xFFFF00000000) / 0x100000000); registers.lbaHigh = (uint16_t)((lba & 0xFFFF00000000) / 0x100000000);
registers.lbaMid = (uint16_t)((lba & 0xFFFF0000) / 0x10000); registers.lbaMid = (uint16_t)((lba & 0xFFFF0000) / 0x10000);
registers.lbaLow = (uint16_t)((lba & 0xFFFF) / 0x1); registers.lbaLow = (uint16_t)((lba & 0xFFFF) / 0x1);
registers.deviceHead += 0x40; registers.deviceHead += 0x40;
int error = SendAtaCommandLba48(fd, registers, statusRegisters, ATA_PROTOCOL_DMA, ATA_TRANSFER_SECTORCOUNT, *buffer, buffer_len, 1); int error = SendAtaCommandLba48(fd, registers, statusRegisters, ATA_PROTOCOL_DMA, ATA_TRANSFER_SECTORCOUNT, *buffer,
buffer_len, 1);
return error; return error;
} }
@@ -471,14 +495,15 @@ int ReadLba48(int fd, unsigned char **buffer, AtaErrorRegistersLBA48 **statusReg
AtaRegistersLBA48 registers; AtaRegistersLBA48 registers;
memset(&registers, 0, sizeof(AtaRegistersLBA48)); memset(&registers, 0, sizeof(AtaRegistersLBA48));
registers.command = ATA_READ_EXT; registers.command = ATA_READ_EXT;
registers.sectorCount = count; registers.sectorCount = count;
registers.lbaHigh = (uint16_t)((lba & 0xFFFF00000000) / 0x100000000); registers.lbaHigh = (uint16_t)((lba & 0xFFFF00000000) / 0x100000000);
registers.lbaMid = (uint16_t)((lba & 0xFFFF0000) / 0x10000); registers.lbaMid = (uint16_t)((lba & 0xFFFF0000) / 0x10000);
registers.lbaLow = (uint16_t)((lba & 0xFFFF) / 0x1); registers.lbaLow = (uint16_t)((lba & 0xFFFF) / 0x1);
registers.deviceHead += 0x40; registers.deviceHead += 0x40;
int error = SendAtaCommandLba48(fd, registers, statusRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_SECTORCOUNT, *buffer, buffer_len, 1); int error = SendAtaCommandLba48(fd, registers, statusRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_SECTORCOUNT,
*buffer, buffer_len, 1);
return error; return error;
} }

181
DiscImageChef.Device.Report/ata.h
View File

@@ -5,8 +5,6 @@
#ifndef DISCIMAGECHEF_DEVICE_REPORT_ATA_H #ifndef DISCIMAGECHEF_DEVICE_REPORT_ATA_H
#define DISCIMAGECHEF_DEVICE_REPORT_ATA_H #define DISCIMAGECHEF_DEVICE_REPORT_ATA_H
#include <stdint.h>
#pragma pack(1) #pragma pack(1)
typedef struct typedef struct
{ {
@@ -28,7 +26,7 @@ typedef struct
uint8_t lbaHigh; uint8_t lbaHigh;
uint8_t deviceHead; uint8_t deviceHead;
uint8_t command; uint8_t command;
}AtaRegistersLBA28; } AtaRegistersLBA28;
typedef struct typedef struct
{ {
@@ -37,8 +35,8 @@ typedef struct
uint16_t lbaLow; uint16_t lbaLow;
uint16_t lbaMid; uint16_t lbaMid;
uint16_t lbaHigh; uint16_t lbaHigh;
uint8_t deviceHead; uint8_t deviceHead;
uint8_t command; uint8_t command;
} AtaRegistersLBA48; } AtaRegistersLBA48;
typedef struct typedef struct
@@ -51,7 +49,7 @@ typedef struct
uint8_t cylinderHigh; uint8_t cylinderHigh;
uint8_t deviceHead; uint8_t deviceHead;
uint8_t command; uint8_t command;
}AtaErrorRegistersCHS; } AtaErrorRegistersCHS;
typedef struct typedef struct
{ {
@@ -67,53 +65,51 @@ typedef struct
typedef struct typedef struct
{ {
uint8_t status; uint8_t status;
uint8_t error; uint8_t error;
uint16_t sectorCount; uint16_t sectorCount;
uint16_t lbaLow; uint16_t lbaLow;
uint16_t lbaMid; uint16_t lbaMid;
uint16_t lbaHigh; uint16_t lbaHigh;
uint8_t deviceHead; uint8_t deviceHead;
uint8_t command; uint8_t command;
} AtaErrorRegistersLBA48; } AtaErrorRegistersLBA48;
typedef enum typedef enum
{ {
ATA_TRANSFER_NONE = 0, ATA_TRANSFER_NONE = 0, ATA_TRANSFER_FEATURE, ATA_TRANSFER_SECTORCOUNT, ATA_TRANSFTER_SPTSIU
ATA_TRANSFER_FEATURE,
ATA_TRANSFER_SECTORCOUNT,
ATA_TRANSFTER_SPTSIU
} AtaTransferRegister; } AtaTransferRegister;
typedef enum { typedef enum
ATA_PROTOCOL_HARD_RESET = 0, {
ATA_PROTOCOL_SOFT_RESET = 1, ATA_PROTOCOL_HARD_RESET = 0,
ATA_PROTOCOL_NO_DATA = 3, ATA_PROTOCOL_SOFT_RESET = 1,
ATA_PROTOCOL_PIO_IN = 4, ATA_PROTOCOL_NO_DATA = 3,
ATA_PROTOCOL_PIO_OUT = 5, ATA_PROTOCOL_PIO_IN = 4,
ATA_PROTOCOL_DMA = 6, ATA_PROTOCOL_PIO_OUT = 5,
ATA_PROTOCOL_DMA_QUEUED = 7, ATA_PROTOCOL_DMA = 6,
ATA_PROTOCOL_DMA_QUEUED = 7,
ATA_PROTOCOL_DEVICE_DIAGNOSTICS = 8, ATA_PROTOCOL_DEVICE_DIAGNOSTICS = 8,
ATA_PROTOCOL_DEVICE_RESET = 9, ATA_PROTOCOL_DEVICE_RESET = 9,
ATA_PROTOCOL_UDMA_IN = 10, ATA_PROTOCOL_UDMA_IN = 10,
ATA_PROTOCOL_UDMA_OUT = 11, ATA_PROTOCOL_UDMA_OUT = 11,
ATA_PROTOCOL_FPDMA = 12, ATA_PROTOCOL_FPDMA = 12,
ATA_PROTOCOL_RETURN_RESPONSE = 15 ATA_PROTOCOL_RETURN_RESPONSE = 15
} AtaProtocol; } AtaProtocol;
typedef enum typedef enum
{ {
ATA_READ_RETRY = 0x20, ATA_READ_RETRY = 0x20,
ATA_READ_SECTORS = 0x21, ATA_READ_SECTORS = 0x21,
ATA_READ_LONG_RETRY = 0x22, ATA_READ_LONG_RETRY = 0x22,
ATA_READ_LONG = 0x23, ATA_READ_LONG = 0x23,
ATA_READ_EXT = 0x24, ATA_READ_EXT = 0x24,
ATA_READ_DMA_EXT = 0x25, ATA_READ_DMA_EXT = 0x25,
ATA_SEEK = 0x70, ATA_SEEK = 0x70,
ATA_READ_DMA_RETRY = 0xC8, ATA_READ_DMA_RETRY = 0xC8,
ATA_READ_DMA = 0xC9, ATA_READ_DMA = 0xC9,
ATA_IDENTIFY_PACKET_DEVICE = 0xA1, ATA_IDENTIFY_PACKET_DEVICE = 0xA1,
ATA_IDENTIFY_DEVICE = 0xEC ATA_IDENTIFY_DEVICE = 0xEC
} AtaCommands; } AtaCommands;
typedef struct typedef struct
@@ -143,7 +139,7 @@ typedef struct
Word 2 Word 2
Specific configuration Specific configuration
*/ */
uint16_t SpecificConfiguration; uint16_t SpecificConfiguration;
/* /*
Word 3 Word 3
Heads in default translation mode Heads in default translation mode
@@ -183,7 +179,7 @@ typedef struct
Words 10 to 19 Words 10 to 19
Device serial number, right justified, padded with spaces Device serial number, right justified, padded with spaces
*/ */
uint8_t SerialNumber[20]; uint8_t SerialNumber[20];
/* /*
Word 20 Word 20
Manufacturer defined Manufacturer defined
@@ -209,75 +205,75 @@ typedef struct
Words 23 to 26 Words 23 to 26
Firmware revision, left justified, padded with spaces Firmware revision, left justified, padded with spaces
*/ */
uint8_t FirmwareRevision[8]; uint8_t FirmwareRevision[8];
/* /*
Words 27 to 46 Words 27 to 46
Model number, left justified, padded with spaces Model number, left justified, padded with spaces
*/ */
uint8_t Model[40]; uint8_t Model[40];
/* /*
Word 47 bits 7 to 0 Word 47 bits 7 to 0
Maximum number of sectors that can be transferred per Maximum number of sectors that can be transferred per
interrupt on read and write multiple commands interrupt on read and write multiple commands
*/ */
uint8_t MultipleMaxSectors; uint8_t MultipleMaxSectors;
/* /*
Word 47 bits 15 to 8 Word 47 bits 15 to 8
Vendor unique Vendor unique
ATA/ATAPI-4 says it must be 0x80 ATA/ATAPI-4 says it must be 0x80
*/ */
uint8_t VendorWord47; uint8_t VendorWord47;
/* /*
Word 48 Word 48
ATA-1: Set to 1 if it can perform doubleword I/O ATA-1: Set to 1 if it can perform doubleword I/O
ATA-2 to ATA/ATAPI-7: Reserved ATA-2 to ATA/ATAPI-7: Reserved
ATA8-ACS: Trusted Computing feature set ATA8-ACS: Trusted Computing feature set
*/ */
uint16_t TrustedComputing; uint16_t TrustedComputing;
/* /*
Word 49 Word 49
Capabilities Capabilities
*/ */
uint16_t Capabilities; uint16_t Capabilities;
/* /*
Word 50 Word 50
Capabilities Capabilities
*/ */
uint16_t Capabilities2; uint16_t Capabilities2;
/* /*
Word 51 bits 7 to 0 Word 51 bits 7 to 0
Vendor unique Vendor unique
Obsoleted in ATA/ATAPI-4 Obsoleted in ATA/ATAPI-4
*/ */
uint8_t VendorWord51; uint8_t VendorWord51;
/* /*
Word 51 bits 15 to 8 Word 51 bits 15 to 8
Transfer timing mode in PIO Transfer timing mode in PIO
Obsoleted in ATA/ATAPI-4 Obsoleted in ATA/ATAPI-4
*/ */
uint8_t PIOTransferTimingMode; uint8_t PIOTransferTimingMode;
/* /*
Word 52 bits 7 to 0 Word 52 bits 7 to 0
Vendor unique Vendor unique
Obsoleted in ATA/ATAPI-4 Obsoleted in ATA/ATAPI-4
*/ */
uint8_t VendorWord52; uint8_t VendorWord52;
/* /*
Word 52 bits 15 to 8 Word 52 bits 15 to 8
Transfer timing mode in DMA Transfer timing mode in DMA
Obsoleted in ATA/ATAPI-4 Obsoleted in ATA/ATAPI-4
*/ */
uint8_t DMATransferTimingMode; uint8_t DMATransferTimingMode;
/* /*
Word 53 bits 7 to 0 Word 53 bits 7 to 0
Reports if words 54 to 58 are valid Reports if words 54 to 58 are valid
*/ */
uint8_t ExtendedIdentify; uint8_t ExtendedIdentify;
/* /*
Word 53 bits 15 to 8 Word 53 bits 15 to 8
Free-fall Control Sensitivity Free-fall Control Sensitivity
*/ */
uint8_t FreeFallSensitivity; uint8_t FreeFallSensitivity;
/* /*
Word 54 Word 54
Cylinders in current translation mode Cylinders in current translation mode
@@ -306,12 +302,12 @@ typedef struct
Word 59 bits 7 to 0 Word 59 bits 7 to 0
Number of sectors currently set to transfer on a READ/WRITE MULTIPLE command Number of sectors currently set to transfer on a READ/WRITE MULTIPLE command
*/ */
uint8_t MultipleSectorNumber; uint8_t MultipleSectorNumber;
/* /*
Word 59 bits 15 to 8 Word 59 bits 15 to 8
Indicates if <see cref="MultipleSectorNumber"/> is valid Indicates if <see cref="MultipleSectorNumber"/> is valid
*/ */
uint8_t Capabilities3; uint8_t Capabilities3;
/* /*
Words 60 to 61 Words 60 to 61
If drive supports LBA, how many sectors are addressable using LBA If drive supports LBA, how many sectors are addressable using LBA
@@ -323,7 +319,7 @@ typedef struct
Obsoleted in ATA/ATAPI-4 Obsoleted in ATA/ATAPI-4
In ATAPI it's not obsolete, indicates UDMA mode (UDMA7 is instead MDMA0) In ATAPI it's not obsolete, indicates UDMA mode (UDMA7 is instead MDMA0)
*/ */
uint8_t DMASupported; uint8_t DMASupported;
/* /*
Word 62 bits 15 to 8 Word 62 bits 15 to 8
Single word DMA mode currently active Single word DMA mode currently active
@@ -332,28 +328,28 @@ typedef struct
bit 10 indicates DMA is supported and bit 15 indicates DMADIR bit bit 10 indicates DMA is supported and bit 15 indicates DMADIR bit
in PACKET is required for DMA transfers in PACKET is required for DMA transfers
*/ */
uint8_t DMAActive; uint8_t DMAActive;
/* /*
Word 63 bits 7 to 0 Word 63 bits 7 to 0
Multiword DMA modes available Multiword DMA modes available
*/ */
uint8_t MDMASupported; uint8_t MDMASupported;
/* /*
Word 63 bits 15 to 8 Word 63 bits 15 to 8
Multiword DMA mode currently active Multiword DMA mode currently active
*/ */
uint8_t MDMAActive; uint8_t MDMAActive;
/* /*
Word 64 bits 7 to 0 Word 64 bits 7 to 0
Supported Advanced PIO transfer modes Supported Advanced PIO transfer modes
*/ */
uint8_t APIOSupported; uint8_t APIOSupported;
/* /*
Word 64 bits 15 to 8 Word 64 bits 15 to 8
Reserved Reserved
*/ */
uint8_t ReservedWord64; uint8_t ReservedWord64;
/* /*
Word 65 Word 65
Minimum MDMA transfer cycle time per word in nanoseconds Minimum MDMA transfer cycle time per word in nanoseconds
@@ -481,12 +477,12 @@ typedef struct
Word 88 bits 7 to 0 Word 88 bits 7 to 0
Supported Ultra DMA transfer modes Supported Ultra DMA transfer modes
*/ */
uint8_t UDMASupported; uint8_t UDMASupported;
/* /*
Word 88 bits 15 to 8 Word 88 bits 15 to 8
Selected Ultra DMA transfer modes Selected Ultra DMA transfer modes
*/ */
uint8_t UDMAActive; uint8_t UDMAActive;
/* /*
Word 89 Word 89
@@ -680,7 +676,7 @@ typedef struct
Words 170 to 173 Words 170 to 173
Additional product identifier Additional product identifier
*/ */
uint8_t AdditionalPID[8]; uint8_t AdditionalPID[8];
/* /*
Word 174 Word 174
@@ -774,12 +770,12 @@ typedef struct
Word 219 bits 7 to 0 Word 219 bits 7 to 0
Estimated device spin up in seconds Estimated device spin up in seconds
*/ */
uint8_t NVEstimatedSpinUp; uint8_t NVEstimatedSpinUp;
/* /*
Word 219 bits 15 to 8 Word 219 bits 15 to 8
NV Cache reserved NV Cache reserved
*/ */
uint8_t NVReserved; uint8_t NVReserved;
/* /*
Word 220 bits 7 to 0 Word 220 bits 7 to 0
@@ -851,19 +847,44 @@ typedef struct
uint8_t Checksum; uint8_t Checksum;
} IdentifyDevice; } IdentifyDevice;
unsigned char *AtaToCString(unsigned char* string, int len); unsigned char *AtaToCString (unsigned char *string, int len);
int SendAtaCommandChs(int fd, AtaRegistersCHS registers, AtaErrorRegistersCHS **errorRegisters, int protocol, int transferRegister, unsigned char *buffer, unsigned int buffer_len, int transferBlocks);
int SendAtaCommandLba28(int fd, AtaRegistersLBA28 registers, AtaErrorRegistersLBA28 **errorRegisters, int protocol, int transferRegister, unsigned char *buffer, unsigned int buffer_len, int transferBlocks); int SendAtaCommandChs (int fd, AtaRegistersCHS registers, AtaErrorRegistersCHS **errorRegisters, int protocol,
int SendAtaCommandLba48(int fd, AtaRegistersLBA48 registers, AtaErrorRegistersLBA48 **errorRegisters, int protocol, int transferRegister, unsigned char *buffer, unsigned int buffer_len, int transferBlocks); int transferRegister, unsigned char *buffer, unsigned int buffer_len, int transferBlocks);
int Identify(int fd, unsigned char **buffer, AtaErrorRegistersCHS **errorRegisters);
int Read(int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegisters, int retry, uint16_t cylinder, uint8_t head, uint8_t sector, uint8_t count); int SendAtaCommandLba28 (int fd, AtaRegistersLBA28 registers, AtaErrorRegistersLBA28 **errorRegisters, int protocol,
int ReadLong(int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegisters, int retry, uint16_t cylinder, uint8_t head, uint8_t sector, uint32_t blockSize); int transferRegister, unsigned char *buffer, unsigned int buffer_len, int transferBlocks);
int Seek(int fd, AtaErrorRegistersCHS **statusRegisters, uint16_t cylinder, uint8_t head, uint8_t sector);
int ReadDma(int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegisters, int retry, uint16_t cylinder, uint8_t head, uint8_t sector, uint8_t count); int SendAtaCommandLba48 (int fd, AtaRegistersLBA48 registers, AtaErrorRegistersLBA48 **errorRegisters, int protocol,
int ReadDmaLba(int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRegisters, int retry, uint32_t lba, uint8_t count); int transferRegister, unsigned char *buffer, unsigned int buffer_len, int transferBlocks);
int ReadLba(int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRegisters, int retry, uint32_t lba, uint8_t count);
int ReadLongLba(int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRegisters, int retry, uint32_t lba, uint32_t blockSize); int Identify (int fd, unsigned char **buffer, AtaErrorRegistersCHS **errorRegisters);
int SeekLba(int fd, AtaErrorRegistersLBA28 **statusRegisters, uint32_t lba);
int ReadDmaLba48(int fd, unsigned char **buffer, AtaErrorRegistersLBA48 **statusRegisters, uint64_t lba, uint16_t count); int Read (int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegisters, int retry, uint16_t cylinder,
int ReadLba48(int fd, unsigned char **buffer, AtaErrorRegistersLBA48 **statusRegisters, uint64_t lba, uint16_t count); uint8_t head, uint8_t sector, uint8_t count);
int ReadLong (int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegisters, int retry, uint16_t cylinder,
uint8_t head, uint8_t sector, uint32_t blockSize);
int Seek (int fd, AtaErrorRegistersCHS **statusRegisters, uint16_t cylinder, uint8_t head, uint8_t sector);
int ReadDma (int fd, unsigned char **buffer, AtaErrorRegistersCHS **statusRegisters, int retry, uint16_t cylinder,
uint8_t head, uint8_t sector, uint8_t count);
int ReadDmaLba (int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRegisters, int retry, uint32_t lba,
uint8_t count);
int ReadLba (int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRegisters, int retry, uint32_t lba,
uint8_t count);
int ReadLongLba (int fd, unsigned char **buffer, AtaErrorRegistersLBA28 **statusRegisters, int retry, uint32_t lba,
uint32_t blockSize);
int SeekLba (int fd, AtaErrorRegistersLBA28 **statusRegisters, uint32_t lba);
int
ReadDmaLba48 (int fd, unsigned char **buffer, AtaErrorRegistersLBA48 **statusRegisters, uint64_t lba, uint16_t count);
int ReadLba48 (int fd, unsigned char **buffer, AtaErrorRegistersLBA48 **statusRegisters, uint64_t lba, uint16_t count);
#endif //DISCIMAGECHEF_DEVICE_REPORT_ATA_H #endif //DISCIMAGECHEF_DEVICE_REPORT_ATA_H

385
DiscImageChef.Device.Report/ata_report.c
View File

@@ -10,14 +10,14 @@
void AtaReport(int fd, xmlTextWriterPtr xmlWriter) void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
{ {
unsigned char *ata_ident = NULL; unsigned char *ata_ident = NULL;
unsigned char *buffer = NULL; unsigned char *buffer = NULL;
AtaErrorRegistersCHS *ata_error_chs; AtaErrorRegistersCHS *ata_error_chs;
AtaErrorRegistersLBA28 *ata_error_lba; AtaErrorRegistersLBA28 *ata_error_lba;
AtaErrorRegistersLBA48 *ata_error_lba48; AtaErrorRegistersLBA48 *ata_error_lba48;
int error; int error;
int removable = FALSE; int removable = FALSE;
char user_response = ' '; char user_response = ' ';
printf("Querying ATA IDENTIFY...\n"); printf("Querying ATA IDENTIFY...\n");
error = Identify(fd, &ata_ident, &ata_error_chs); error = Identify(fd, &ata_ident, &ata_error_chs);
@@ -45,7 +45,7 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Is the media removable from the reading/writing elements (flash memories ARE NOT removable)? (Y/N): "); printf("Is the media removable from the reading/writing elements (flash memories ARE NOT removable)? (Y/N): ");
scanf("%c", &user_response); scanf("%c", &user_response);
printf("\n"); printf("\n");
} while(user_response != 'Y' && user_response != 'y' && user_response != 'N' && user_response != 'n'); }while(user_response != 'Y' && user_response != 'y' && user_response != 'N' && user_response != 'n');
removable = (user_response == 'Y' || user_response == 'y'); removable = (user_response == 'Y' || user_response == 'y');
} }
@@ -64,15 +64,18 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
if((uint64_t)*identify->AdditionalPID != 0 && (uint64_t)*identify->AdditionalPID != 0x2020202020202020) if((uint64_t)*identify->AdditionalPID != 0 && (uint64_t)*identify->AdditionalPID != 0x2020202020202020)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "AdditionalPid", AtaToCString(identify->AdditionalPID, 8)); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "AdditionalPid", AtaToCString(identify->AdditionalPID, 8));
if(identify->APIOSupported) if(identify->APIOSupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "APIOSupported", DecodeTransferMode(le16toh(identify->APIOSupported))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "APIOSupported",
DecodeTransferMode(le16toh(identify->APIOSupported)));
if(identify->BufferType) if(identify->BufferType)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BufferType", "%u", le16toh(identify->BufferType)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BufferType", "%u", le16toh(identify->BufferType));
if(identify->BufferSize) if(identify->BufferSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BufferSize", "%u", le16toh(identify->BufferSize)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BufferSize", "%u", le16toh(identify->BufferSize));
if(identify->Capabilities) if(identify->Capabilities)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities", DecodeCapabilities(le16toh(identify->Capabilities))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities",
DecodeCapabilities(le16toh(identify->Capabilities)));
if(identify->Capabilities2) if(identify->Capabilities2)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities2", DecodeCapabilities2(le16toh(identify->Capabilities2))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities2",
DecodeCapabilities2(le16toh(identify->Capabilities2)));
if(identify->Capabilities3) if(identify->Capabilities3)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities3", DecodeCapabilities3(identify->Capabilities3)); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities3", DecodeCapabilities3(identify->Capabilities3));
if(identify->CFAPowerMode) if(identify->CFAPowerMode)
@@ -94,127 +97,173 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
if(identify->DataSetMgmt) if(identify->DataSetMgmt)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DataSetMgmt", DecodeDataSetMgmt(le16toh(identify->DataSetMgmt))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DataSetMgmt", DecodeDataSetMgmt(le16toh(identify->DataSetMgmt)));
if(identify->DataSetMgmtSize) if(identify->DataSetMgmtSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DataSetMgmtSize", "%u", le16toh(identify->DataSetMgmtSize)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DataSetMgmtSize", "%u",
le16toh(identify->DataSetMgmtSize));
if(identify->DeviceFormFactor) if(identify->DeviceFormFactor)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DeviceFormFactor", DecodeDeviceFormFactor(le16toh(identify->DeviceFormFactor))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DeviceFormFactor",
DecodeDeviceFormFactor(le16toh(identify->DeviceFormFactor)));
if(identify->DMAActive) if(identify->DMAActive)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMAActive", DecodeTransferMode(le16toh(identify->DMAActive))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMAActive", DecodeTransferMode(le16toh(identify->DMAActive)));
if(identify->DMASupported) if(identify->DMASupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMASupported", DecodeTransferMode(le16toh(identify->DMASupported))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMASupported",
DecodeTransferMode(le16toh(identify->DMASupported)));
if(identify->DMATransferTimingMode) if(identify->DMATransferTimingMode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DMATransferTimingMode", "%u", identify->DMATransferTimingMode); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DMATransferTimingMode", "%u",
identify->DMATransferTimingMode);
if(identify->EnhancedSecurityEraseTime) if(identify->EnhancedSecurityEraseTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "EnhancedSecurityEraseTime", "%u", le16toh(identify->EnhancedSecurityEraseTime)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "EnhancedSecurityEraseTime", "%u",
le16toh(identify->EnhancedSecurityEraseTime));
if(identify->EnabledCommandSet) if(identify->EnabledCommandSet)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet", DecodeCommandSet(le16toh(identify->EnabledCommandSet))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet",
DecodeCommandSet(le16toh(identify->EnabledCommandSet)));
if(identify->EnabledCommandSet2) if(identify->EnabledCommandSet2)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet2", DecodeCommandSet2(le16toh(identify->EnabledCommandSet2))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet2",
DecodeCommandSet2(le16toh(identify->EnabledCommandSet2)));
if(identify->EnabledCommandSet3) if(identify->EnabledCommandSet3)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet3", DecodeCommandSet3(le16toh(identify->EnabledCommandSet3))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet3",
DecodeCommandSet3(le16toh(identify->EnabledCommandSet3)));
if(identify->EnabledCommandSet4) if(identify->EnabledCommandSet4)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet4", DecodeCommandSet4(le16toh(identify->EnabledCommandSet4))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet4",
DecodeCommandSet4(le16toh(identify->EnabledCommandSet4)));
if(identify->EnabledSATAFeatures) if(identify->EnabledSATAFeatures)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledSATAFeatures", DecodeSATAFeatures(le16toh(identify->EnabledSATAFeatures))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledSATAFeatures",
DecodeSATAFeatures(le16toh(identify->EnabledSATAFeatures)));
if(identify->ExtendedUserSectors) if(identify->ExtendedUserSectors)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ExtendedUserSectors", "%llu", le64toh(identify->ExtendedUserSectors)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ExtendedUserSectors", "%llu",
le64toh(identify->ExtendedUserSectors));
if(identify->FreeFallSensitivity) if(identify->FreeFallSensitivity)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "FreeFallSensitivity", "%u", identify->FreeFallSensitivity); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "FreeFallSensitivity", "%u", identify->FreeFallSensitivity);
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "FirmwareRevision", AtaToCString(identify->FirmwareRevision, 8)); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "FirmwareRevision", AtaToCString(identify->FirmwareRevision, 8));
if(identify->GeneralConfiguration) if(identify->GeneralConfiguration)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "GeneralConfiguration", DecodeGeneralConfiguration(le16toh(identify->GeneralConfiguration))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "GeneralConfiguration",
DecodeGeneralConfiguration(le16toh(identify->GeneralConfiguration)));
if(identify->HardwareResetResult) if(identify->HardwareResetResult)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "HardwareResetResult", "%u", le16toh(identify->HardwareResetResult)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "HardwareResetResult", "%u",
le16toh(identify->HardwareResetResult));
if(identify->InterseekDelay) if(identify->InterseekDelay)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "InterseekDelay", "%u", le16toh(identify->InterseekDelay)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "InterseekDelay", "%u", le16toh(identify->InterseekDelay));
if(identify->MajorVersion) if(identify->MajorVersion)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MajorVersion", DecodeMajorVersion(le16toh(identify->MajorVersion))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MajorVersion",
DecodeMajorVersion(le16toh(identify->MajorVersion)));
if(identify->MasterPasswordRevisionCode) if(identify->MasterPasswordRevisionCode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MasterPasswordRevisionCode", "%u", le16toh(identify->MasterPasswordRevisionCode)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MasterPasswordRevisionCode", "%u",
le16toh(identify->MasterPasswordRevisionCode));
if(identify->MaxDownloadMicroMode3) if(identify->MaxDownloadMicroMode3)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxDownloadMicroMode3", "%u", le16toh(identify->MaxDownloadMicroMode3)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxDownloadMicroMode3", "%u",
le16toh(identify->MaxDownloadMicroMode3));
if(identify->MaxQueueDepth) if(identify->MaxQueueDepth)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxQueueDepth", "%u", le16toh(identify->MaxQueueDepth)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxQueueDepth", "%u", le16toh(identify->MaxQueueDepth));
if(identify->MDMAActive) if(identify->MDMAActive)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMAActive", DecodeTransferMode(le16toh(identify->MDMAActive))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMAActive", DecodeTransferMode(le16toh(identify->MDMAActive)));
if(identify->MDMASupported) if(identify->MDMASupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMASupported", DecodeTransferMode(le16toh(identify->MDMASupported))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMASupported",
DecodeTransferMode(le16toh(identify->MDMASupported)));
if(identify->MinDownloadMicroMode3) if(identify->MinDownloadMicroMode3)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinDownloadMicroMode3", "%u", le16toh(identify->MinDownloadMicroMode3)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinDownloadMicroMode3", "%u",
le16toh(identify->MinDownloadMicroMode3));
if(identify->MinMDMACycleTime) if(identify->MinMDMACycleTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinMDMACycleTime", "%u", le16toh(identify->MinMDMACycleTime)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinMDMACycleTime", "%u",
le16toh(identify->MinMDMACycleTime));
if(identify->MinorVersion) if(identify->MinorVersion)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinorVersion", "%u", le16toh(identify->MinorVersion)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinorVersion", "%u", le16toh(identify->MinorVersion));
if(identify->MinPIOCycleTimeNoFlow) if(identify->MinPIOCycleTimeNoFlow)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinPIOCycleTimeNoFlow", "%u", le16toh(identify->MinPIOCycleTimeNoFlow)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinPIOCycleTimeNoFlow", "%u",
le16toh(identify->MinPIOCycleTimeNoFlow));
if(identify->MinPIOCycleTimeFlow) if(identify->MinPIOCycleTimeFlow)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinPIOCycleTimeFlow", "%u", le16toh(identify->MinPIOCycleTimeFlow)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinPIOCycleTimeFlow", "%u",
le16toh(identify->MinPIOCycleTimeFlow));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Model", AtaToCString(identify->Model, 40)); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Model", AtaToCString(identify->Model, 40));
if(identify->MultipleMaxSectors) if(identify->MultipleMaxSectors)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleMaxSectors", "%u", identify->MultipleMaxSectors); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleMaxSectors", "%u", identify->MultipleMaxSectors);
if(identify->MultipleSectorNumber) if(identify->MultipleSectorNumber)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleSectorNumber", "%u", identify->MultipleSectorNumber); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleSectorNumber", "%u",
identify->MultipleSectorNumber);
if(identify->NVCacheCaps) if(identify->NVCacheCaps)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheCaps", "%u", le16toh(identify->NVCacheCaps)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheCaps", "%u", le16toh(identify->NVCacheCaps));
if(identify->NVCacheSize) if(identify->NVCacheSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheSize", "%u", le32toh(identify->NVCacheSize)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheSize", "%u", le32toh(identify->NVCacheSize));
if(identify->NVCacheWriteSpeed) if(identify->NVCacheWriteSpeed)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheWriteSpeed", "%u", le16toh(identify->NVCacheWriteSpeed)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheWriteSpeed", "%u",
le16toh(identify->NVCacheWriteSpeed));
if(identify->NVEstimatedSpinUp) if(identify->NVEstimatedSpinUp)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVEstimatedSpinUp", "%u", identify->NVEstimatedSpinUp); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVEstimatedSpinUp", "%u", identify->NVEstimatedSpinUp);
if(identify->PacketBusRelease) if(identify->PacketBusRelease)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PacketBusRelease", "%u", le16toh(identify->PacketBusRelease)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PacketBusRelease", "%u",
le16toh(identify->PacketBusRelease));
if(identify->PIOTransferTimingMode) if(identify->PIOTransferTimingMode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PIOTransferTimingMode", "%u", identify->PIOTransferTimingMode); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PIOTransferTimingMode", "%u",
identify->PIOTransferTimingMode);
if(identify->RecommendedAAM) if(identify->RecommendedAAM)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecommendedAAM", "%u", identify->RecommendedAAM); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecommendedAAM", "%u", identify->RecommendedAAM);
if(identify->RecMDMACycleTime) if(identify->RecMDMACycleTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecMDMACycleTime", "%u", le16toh(identify->RecMDMACycleTime)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecMDMACycleTime", "%u",
le16toh(identify->RecMDMACycleTime));
if(identify->RemovableStatusSet) if(identify->RemovableStatusSet)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RemovableStatusSet", "%u", le16toh(identify->RemovableStatusSet)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RemovableStatusSet", "%u",
le16toh(identify->RemovableStatusSet));
if(identify->SATACapabilities) if(identify->SATACapabilities)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities", DecodeSATACapabilities(le16toh(identify->SATACapabilities))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities",
DecodeSATACapabilities(le16toh(identify->SATACapabilities)));
if(identify->SATACapabilities2) if(identify->SATACapabilities2)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities2", DecodeSATACapabilities2(le16toh(identify->SATACapabilities2))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities2",
DecodeSATACapabilities2(le16toh(identify->SATACapabilities2)));
if(identify->SATAFeatures) if(identify->SATAFeatures)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATAFeatures", DecodeSATAFeatures(le16toh(identify->SATAFeatures))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATAFeatures",
DecodeSATAFeatures(le16toh(identify->SATAFeatures)));
if(identify->SCTCommandTransport) if(identify->SCTCommandTransport)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SCTCommandTransport", DecodeSCTCommandTransport(le16toh(identify->SCTCommandTransport))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SCTCommandTransport",
DecodeSCTCommandTransport(le16toh(identify->SCTCommandTransport)));
if(identify->SectorsPerCard) if(identify->SectorsPerCard)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SectorsPerCard", "%u", le32toh(identify->SectorsPerCard)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SectorsPerCard", "%u", le32toh(identify->SectorsPerCard));
if(identify->SecurityEraseTime) if(identify->SecurityEraseTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SecurityEraseTime", "%u", le16toh(identify->SecurityEraseTime)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SecurityEraseTime", "%u",
le16toh(identify->SecurityEraseTime));
if(identify->SecurityStatus) if(identify->SecurityStatus)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SecurityStatus", DecodeSecurityStatus(le16toh(identify->SecurityStatus))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SecurityStatus",
DecodeSecurityStatus(le16toh(identify->SecurityStatus)));
if(identify->ServiceBusyClear) if(identify->ServiceBusyClear)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ServiceBusyClear", "%u", le16toh(identify->ServiceBusyClear)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ServiceBusyClear", "%u",
le16toh(identify->ServiceBusyClear));
if(identify->SpecificConfiguration) if(identify->SpecificConfiguration)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SpecificConfiguration", DecodeSpecificConfiguration(le16toh(identify->SpecificConfiguration))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SpecificConfiguration",
DecodeSpecificConfiguration(le16toh(identify->SpecificConfiguration)));
if(identify->StreamAccessLatency) if(identify->StreamAccessLatency)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamAccessLatency", "%u", le16toh(identify->StreamAccessLatency)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamAccessLatency", "%u",
le16toh(identify->StreamAccessLatency));
if(identify->StreamMinReqSize) if(identify->StreamMinReqSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamMinReqSize", "%u", le16toh(identify->StreamMinReqSize)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamMinReqSize", "%u",
le16toh(identify->StreamMinReqSize));
if(identify->StreamPerformanceGranularity) if(identify->StreamPerformanceGranularity)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamPerformanceGranularity", "%u", le32toh(identify->StreamPerformanceGranularity)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamPerformanceGranularity", "%u",
le32toh(identify->StreamPerformanceGranularity));
if(identify->StreamTransferTimeDMA) if(identify->StreamTransferTimeDMA)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimeDMA", "%u", le16toh(identify->StreamTransferTimeDMA)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimeDMA", "%u",
le16toh(identify->StreamTransferTimeDMA));
if(identify->StreamTransferTimePIO) if(identify->StreamTransferTimePIO)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimePIO", "%u", le16toh(identify->StreamTransferTimePIO)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimePIO", "%u",
le16toh(identify->StreamTransferTimePIO));
if(identify->TransportMajorVersion) if(identify->TransportMajorVersion)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMajorVersion", "%u", le16toh(identify->TransportMajorVersion)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMajorVersion", "%u",
le16toh(identify->TransportMajorVersion));
if(identify->TransportMinorVersion) if(identify->TransportMinorVersion)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMinorVersion", "%u", le16toh(identify->TransportMinorVersion)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMinorVersion", "%u",
le16toh(identify->TransportMinorVersion));
if(identify->TrustedComputing) if(identify->TrustedComputing)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "TrustedComputing", DecodeTrustedComputing(le16toh(identify->TrustedComputing))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "TrustedComputing",
DecodeTrustedComputing(le16toh(identify->TrustedComputing)));
if(identify->UDMAActive) if(identify->UDMAActive)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMAActive", DecodeTransferMode(le16toh(identify->UDMAActive))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMAActive", DecodeTransferMode(le16toh(identify->UDMAActive)));
if(identify->UDMASupported) if(identify->UDMASupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMASupported", DecodeTransferMode(le16toh(identify->UDMASupported))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMASupported",
DecodeTransferMode(le16toh(identify->UDMASupported)));
if(identify->WRVMode) if(identify->WRVMode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVMode", "%u", identify->WRVMode); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVMode", "%u", identify->WRVMode);
if(identify->WRVSectorCountMode3) if(identify->WRVSectorCountMode3)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVSectorCountMode3", "%u", le32toh(identify->WRVSectorCountMode3)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVSectorCountMode3", "%u",
le32toh(identify->WRVSectorCountMode3));
if(identify->WRVSectorCountMode2) if(identify->WRVSectorCountMode2)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVSectorCountMode2", "%u", le32toh(identify->WRVSectorCountMode2)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVSectorCountMode2", "%u",
le32toh(identify->WRVSectorCountMode2));
xmlTextWriterStartElement(xmlWriter, BAD_CAST "Identify"); xmlTextWriterStartElement(xmlWriter, BAD_CAST "Identify");
xmlTextWriterWriteBase64(xmlWriter, ata_ident, 0, 512); xmlTextWriterWriteBase64(xmlWriter, ata_ident, 0, 512);
@@ -273,42 +322,53 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
memcpy(identify, ata_ident, 512); memcpy(identify, ata_ident, 512);
if(identify->UnformattedBPT) if(identify->UnformattedBPT)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPT", "%u", le16toh(identify->UnformattedBPT)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPT", "%u",
le16toh(identify->UnformattedBPT));
if(identify->UnformattedBPS) if(identify->UnformattedBPS)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPS", "%u", le16toh(identify->UnformattedBPS)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPS", "%u",
le16toh(identify->UnformattedBPS));
uint64_t blocks; uint64_t blocks;
if(identify->Cylinders > 0 && identify->Heads > 0 && identify->SectorsPerTrack != 0) if(identify->Cylinders > 0 && identify->Heads > 0 && identify->SectorsPerTrack != 0)
{ {
xmlTextWriterStartElement(xmlWriter, BAD_CAST "CHS"); // <CHS> xmlTextWriterStartElement(xmlWriter, BAD_CAST "CHS"); // <CHS>
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Cylinders", "%u", le16toh(identify->Cylinders)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Cylinders", "%u",
le16toh(identify->Cylinders));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Heads", "%u", le16toh(identify->Heads)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Heads", "%u", le16toh(identify->Heads));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Sectors", "%u", le16toh(identify->SectorsPerTrack)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Sectors", "%u",
blocks = le16toh(identify->Cylinders) * le16toh(identify->Heads) * le16toh(identify->SectorsPerTrack); le16toh(identify->SectorsPerTrack));
blocks = le16toh(identify->Cylinders) * le16toh(identify->Heads) *
le16toh(identify->SectorsPerTrack);
xmlTextWriterEndElement(xmlWriter); // </CHS> xmlTextWriterEndElement(xmlWriter); // </CHS>
} }
if(identify->CurrentCylinders > 0 && identify->CurrentHeads > 0 && identify->CurrentSectorsPerTrack != 0) if(identify->CurrentCylinders > 0 && identify->CurrentHeads > 0 &&
identify->CurrentSectorsPerTrack != 0)
{ {
xmlTextWriterStartElement(xmlWriter, BAD_CAST "CurrentCHS"); // <CurrentCHS> xmlTextWriterStartElement(xmlWriter, BAD_CAST "CurrentCHS"); // <CurrentCHS>
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Cylinders", "%u", le16toh(identify->CurrentCylinders)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Cylinders", "%u",
le16toh(identify->CurrentCylinders));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Heads", "%u", le16toh(identify->CurrentHeads)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Heads", "%u", le16toh(identify->CurrentHeads));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Sectors", "%u", le16toh(identify->CurrentSectorsPerTrack)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Sectors", "%u",
le16toh(identify->CurrentSectorsPerTrack));
if(blocks == 0) if(blocks == 0)
blocks = le16toh(identify->CurrentCylinders) * le16toh(identify->CurrentHeads) * le16toh(identify->CurrentSectorsPerTrack); blocks = le16toh(identify->CurrentCylinders) * le16toh(identify->CurrentHeads) *
le16toh(identify->CurrentSectorsPerTrack);
xmlTextWriterEndElement(xmlWriter); // </CurrentCHS> xmlTextWriterEndElement(xmlWriter); // </CurrentCHS>
} }
if(le16toh(identify->Capabilities) & 0x0200) if(le16toh(identify->Capabilities) & 0x0200)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LBASectors", "%u", le32toh(identify->LBASectors)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LBASectors", "%u",
le32toh(identify->LBASectors));
blocks = le32toh(identify->LBASectors); blocks = le32toh(identify->LBASectors);
} }
if(le16toh(identify->CommandSet2) & 0x0400) if(le16toh(identify->CommandSet2) & 0x0400)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LBA48Sectors", "%llu", le64toh(identify->LBA48Sectors)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LBA48Sectors", "%llu",
le64toh(identify->LBA48Sectors));
blocks = le64toh(identify->LBA48Sectors); blocks = le64toh(identify->LBA48Sectors);
} }
@@ -319,15 +379,16 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
else else
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SolidStateDevice", "%s", "TRUE"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SolidStateDevice", "%s", "TRUE");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NominalRotationRate", "%u", le16toh(identify->NominalRotationRate)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NominalRotationRate", "%u",
le16toh(identify->NominalRotationRate));
} }
} }
uint32_t logicalsectorsize = 0; uint32_t logicalsectorsize = 0;
uint32_t physicalsectorsize = 0; uint32_t physicalsectorsize = 0;
if((le16toh(identify->PhysLogSectorSize) & 0x8000) == 0x0000 && if((le16toh(identify->PhysLogSectorSize) & 0x8000) == 0x0000 &&
(le16toh(identify->PhysLogSectorSize) & 0x4000) == 0x4000) (le16toh(identify->PhysLogSectorSize) & 0x4000) == 0x4000)
{ {
if(le16toh(identify->PhysLogSectorSize) & 0x1000) if(le16toh(identify->PhysLogSectorSize) & 0x1000)
{ {
@@ -346,7 +407,7 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
} }
else else
{ {
logicalsectorsize = 512; logicalsectorsize = 512;
physicalsectorsize = 512; physicalsectorsize = 512;
} }
@@ -355,94 +416,133 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PhysicalBlockSize", "%u", physicalsectorsize); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PhysicalBlockSize", "%u", physicalsectorsize);
if((le16toh(identify->LogicalAlignment) & 0x8000) == 0x0000 && if((le16toh(identify->LogicalAlignment) & 0x8000) == 0x0000 &&
(le16toh(identify->LogicalAlignment) & 0x4000) == 0x4000) (le16toh(identify->LogicalAlignment) & 0x4000) == 0x4000)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LogicalAlignment", "%u", le16toh(identify->LogicalAlignment) & 0x3FFF); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LogicalAlignment", "%u",
le16toh(identify->LogicalAlignment) & 0x3FFF);
} }
uint16_t longblocksize = 0; uint16_t longblocksize = 0;
if(identify->EccBytes != 0x0000 && identify->EccBytes != 0xFFFF) if(identify->EccBytes != 0x0000 && identify->EccBytes != 0xFFFF)
longblocksize = le16toh(identify->EccBytes); longblocksize = le16toh(identify->EccBytes);
if(le16toh(identify->UnformattedBPS) > logicalsectorsize && (longblocksize == 0 || longblocksize == 516)) if(le16toh(identify->UnformattedBPS) > logicalsectorsize &&
(longblocksize == 0 || longblocksize == 516))
longblocksize = le16toh(identify->UnformattedBPS); longblocksize = le16toh(identify->UnformattedBPS);
if(longblocksize > 0) if(longblocksize > 0)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LongBlockSize", "%u", longblocksize); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LongBlockSize", "%u", longblocksize);
if((le16toh(identify->CommandSet3) & 0x8000) == 0x0000 && if((le16toh(identify->CommandSet3) & 0x8000) == 0x0000 &&
(le16toh(identify->CommandSet3) & 0x4000) == 0x4000 && (le16toh(identify->CommandSet3) & 0x4000) == 0x4000 &&
(le16toh(identify->EnabledCommandSet3) & 0x0004) == 0x0004) (le16toh(identify->EnabledCommandSet3) & 0x0004) == 0x0004)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "CanReadMediaSerial", "%s", "TRUE"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "CanReadMediaSerial", "%s", "TRUE");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Manufacturer", "%s", AtaToCString(identify->MediaManufacturer, 20)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Manufacturer", "%s",
AtaToCString(identify->MediaManufacturer, 20));
} }
else else
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Manufacturer", "%s", mediaManufacturer); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Manufacturer", "%s", mediaManufacturer);
printf("Trying READ SECTOR(S) in CHS mode...\n"); printf("Trying READ SECTOR(S) in CHS mode...\n");
error = Read(fd, &buffer, &ata_error_chs, FALSE, 0, 0, 1, 1); error = Read(fd, &buffer, &ata_error_chs, FALSE, 0, 0, 1, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 &&
ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ SECTOR(S) RETRY in CHS mode...\n"); printf("Trying READ SECTOR(S) RETRY in CHS mode...\n");
error = Read(fd, &buffer, &ata_error_chs, TRUE, 0, 0, 1, 1); error = Read(fd, &buffer, &ata_error_chs, TRUE, 0, 0, 1, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadRetry", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadRetry", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 &&
ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ DMA in CHS mode...\n"); printf("Trying READ DMA in CHS mode...\n");
error = ReadDma(fd, &buffer, &ata_error_chs, FALSE, 0, 0, 1, 1); error = ReadDma(fd, &buffer, &ata_error_chs, FALSE, 0, 0, 1, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDma", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDma", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 &&
ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ DMA RETRY in CHS mode...\n"); printf("Trying READ DMA RETRY in CHS mode...\n");
error = ReadDma(fd, &buffer, &ata_error_chs, TRUE, 0, 0, 1, 1); error = ReadDma(fd, &buffer, &ata_error_chs, TRUE, 0, 0, 1, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaRetry", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaRetry", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 &&
ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying SEEK in CHS mode...\n"); printf("Trying SEEK in CHS mode...\n");
error = Seek(fd, &ata_error_chs, 0, 0, 1); error = Seek(fd, &ata_error_chs, 0, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsSeek", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsSeek", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 &&
ata_error_chs->error == 0) ? "true" : "false");
printf("Trying READ SECTOR(S) in LBA mode...\n"); printf("Trying READ SECTOR(S) in LBA mode...\n");
error = ReadLba(fd, &buffer, &ata_error_lba, FALSE, 0, 1); error = ReadLba(fd, &buffer, &ata_error_lba, FALSE, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 &&
ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ SECTOR(S) RETRY in LBA mode...\n"); printf("Trying READ SECTOR(S) RETRY in LBA mode...\n");
error = ReadLba(fd, &buffer, &ata_error_lba, TRUE, 0, 1); error = ReadLba(fd, &buffer, &ata_error_lba, TRUE, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadRetryLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadRetryLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 &&
ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ DMA in LBA mode...\n"); printf("Trying READ DMA in LBA mode...\n");
error = ReadDmaLba(fd, &buffer, &ata_error_lba, FALSE, 0, 1); error = ReadDmaLba(fd, &buffer, &ata_error_lba, FALSE, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 &&
ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ DMA RETRY in LBA mode...\n"); printf("Trying READ DMA RETRY in LBA mode...\n");
error = ReadDmaLba(fd, &buffer, &ata_error_lba, TRUE, 0, 1); error = ReadDmaLba(fd, &buffer, &ata_error_lba, TRUE, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaRetryLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaRetryLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 &&
ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying SEEK in LBA mode...\n"); printf("Trying SEEK in LBA mode...\n");
error = SeekLba(fd, &ata_error_lba, 0); error = SeekLba(fd, &ata_error_lba, 0);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsSeekLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsSeekLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 &&
ata_error_lba->error == 0) ? "true" : "false");
printf("Trying READ SECTOR(S) in LBA48 mode...\n"); printf("Trying READ SECTOR(S) in LBA48 mode...\n");
error = ReadLba48(fd, &buffer, &ata_error_lba48, 0, 1); error = ReadLba48(fd, &buffer, &ata_error_lba48, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLba48", "%s", (!error && (ata_error_lba48->status & 0x01) != 0x01 && ata_error_lba48->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLba48", "%s",
(!error && (ata_error_lba48->status & 0x01) != 0x01 &&
ata_error_lba48->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ DMA in LBA48 mode...\n"); printf("Trying READ DMA in LBA48 mode...\n");
error = ReadDmaLba48(fd, &buffer, &ata_error_lba48, 0, 1); error = ReadDmaLba48(fd, &buffer, &ata_error_lba48, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaLba48", "%s", (!error && (ata_error_lba48->status & 0x01) != 0x01 && ata_error_lba48->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaLba48", "%s",
(!error && (ata_error_lba48->status & 0x01) != 0x01 &&
ata_error_lba48->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ LONG in CHS mode...\n"); printf("Trying READ LONG in CHS mode...\n");
error = ReadLong(fd, &buffer, &ata_error_chs, FALSE, 0, 0, 1, longblocksize); error = ReadLong(fd, &buffer, &ata_error_chs, FALSE, 0, 0, 1, longblocksize);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLong", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0 && buffer != NULL && (uint64_t)(*buffer) != 0) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLong", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 &&
ata_error_chs->error == 0 && buffer != NULL &&
(uint64_t)(*buffer) != 0) ? "true" : "false");
printf("Trying READ LONG RETRY in CHS mode...\n"); printf("Trying READ LONG RETRY in CHS mode...\n");
error = ReadLong(fd, &buffer, &ata_error_chs, TRUE, 0, 0, 1, longblocksize); error = ReadLong(fd, &buffer, &ata_error_chs, TRUE, 0, 0, 1, longblocksize);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLongRetry", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0 && buffer != NULL && (uint64_t)(*buffer) != 0) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLongRetry", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 &&
ata_error_chs->error == 0 && buffer != NULL &&
(uint64_t)(*buffer) != 0) ? "true" : "false");
printf("Trying READ LONG in LBA mode...\n"); printf("Trying READ LONG in LBA mode...\n");
error = ReadLongLba(fd, &buffer, &ata_error_lba, FALSE, 0, longblocksize); error = ReadLongLba(fd, &buffer, &ata_error_lba, FALSE, 0, longblocksize);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLongLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0 && buffer != NULL && (uint64_t)(*buffer) != 0) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLongLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 &&
ata_error_lba->error == 0 && buffer != NULL &&
(uint64_t)(*buffer) != 0) ? "true" : "false");
printf("Trying READ LONG RETRY in LBA mode...\n"); printf("Trying READ LONG RETRY in LBA mode...\n");
error = ReadLongLba(fd, &buffer, &ata_error_lba, TRUE, 0, longblocksize); error = ReadLongLba(fd, &buffer, &ata_error_lba, TRUE, 0, longblocksize);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLongRetryLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0 && buffer != NULL && (uint64_t)(*buffer) != 0) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLongRetryLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 &&
ata_error_lba->error == 0 && buffer != NULL &&
(uint64_t)(*buffer) != 0) ? "true" : "false");
xmlTextWriterEndElement(xmlWriter); // </testedMediaType> xmlTextWriterEndElement(xmlWriter); // </testedMediaType>
@@ -465,9 +565,11 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
memcpy(identify, ata_ident, 512); memcpy(identify, ata_ident, 512);
if(identify->UnformattedBPT) if(identify->UnformattedBPT)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPT", "%u", le16toh(identify->UnformattedBPT)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPT", "%u",
le16toh(identify->UnformattedBPT));
if(identify->UnformattedBPS) if(identify->UnformattedBPS)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPS", "%u", le16toh(identify->UnformattedBPS)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPS", "%u",
le16toh(identify->UnformattedBPS));
uint64_t blocks; uint64_t blocks;
@@ -486,9 +588,11 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
xmlTextWriterStartElement(xmlWriter, BAD_CAST "CurrentCHS"); // <CurrentCHS> xmlTextWriterStartElement(xmlWriter, BAD_CAST "CurrentCHS"); // <CurrentCHS>
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Cylinders", "%u", le16toh(identify->CurrentCylinders)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Cylinders", "%u", le16toh(identify->CurrentCylinders));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Heads", "%u", le16toh(identify->CurrentHeads)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Heads", "%u", le16toh(identify->CurrentHeads));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Sectors", "%u", le16toh(identify->CurrentSectorsPerTrack)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Sectors", "%u",
le16toh(identify->CurrentSectorsPerTrack));
if(blocks == 0) if(blocks == 0)
blocks = le16toh(identify->CurrentCylinders) * le16toh(identify->CurrentHeads) * le16toh(identify->CurrentSectorsPerTrack); blocks = le16toh(identify->CurrentCylinders) * le16toh(identify->CurrentHeads) *
le16toh(identify->CurrentSectorsPerTrack);
xmlTextWriterEndElement(xmlWriter); // </CurrentCHS> xmlTextWriterEndElement(xmlWriter); // </CurrentCHS>
} }
@@ -500,7 +604,8 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
if(le16toh(identify->CommandSet2) & 0x0400) if(le16toh(identify->CommandSet2) & 0x0400)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LBA48Sectors", "%llu", le64toh(identify->LBA48Sectors)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LBA48Sectors", "%llu",
le64toh(identify->LBA48Sectors));
blocks = le64toh(identify->LBA48Sectors); blocks = le64toh(identify->LBA48Sectors);
} }
@@ -511,11 +616,12 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
else else
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SolidStateDevice", "%s", "TRUE"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SolidStateDevice", "%s", "TRUE");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NominalRotationRate", "%u", le16toh(identify->NominalRotationRate)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NominalRotationRate", "%u",
le16toh(identify->NominalRotationRate));
} }
} }
uint32_t logicalsectorsize = 0; uint32_t logicalsectorsize = 0;
uint32_t physicalsectorsize = 0; uint32_t physicalsectorsize = 0;
if((le16toh(identify->PhysLogSectorSize) & 0x8000) == 0x0000 && if((le16toh(identify->PhysLogSectorSize) & 0x8000) == 0x0000 &&
@@ -538,7 +644,7 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
} }
else else
{ {
logicalsectorsize = 512; logicalsectorsize = 512;
physicalsectorsize = 512; physicalsectorsize = 512;
} }
@@ -548,7 +654,8 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PhysicalBlockSize", "%u", physicalsectorsize); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PhysicalBlockSize", "%u", physicalsectorsize);
if((le16toh(identify->LogicalAlignment) & 0x8000) == 0x0000 && if((le16toh(identify->LogicalAlignment) & 0x8000) == 0x0000 &&
(le16toh(identify->LogicalAlignment) & 0x4000) == 0x4000) (le16toh(identify->LogicalAlignment) & 0x4000) == 0x4000)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LogicalAlignment", "%u", le16toh(identify->LogicalAlignment) & 0x3FFF); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LogicalAlignment", "%u",
le16toh(identify->LogicalAlignment) & 0x3FFF);
} }
uint16_t longblocksize = 0; uint16_t longblocksize = 0;
@@ -561,78 +668,114 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
if(longblocksize > 0) if(longblocksize > 0)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LongBlockSize", "%u", longblocksize); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LongBlockSize", "%u", longblocksize);
if((le16toh(identify->CommandSet3) & 0x8000) == 0x0000 && if((le16toh(identify->CommandSet3) & 0x8000) == 0x0000 && (le16toh(identify->CommandSet3) & 0x4000) == 0x4000 &&
(le16toh(identify->CommandSet3) & 0x4000) == 0x4000 &&
(le16toh(identify->EnabledCommandSet3) & 0x0004) == 0x0004) (le16toh(identify->EnabledCommandSet3) & 0x0004) == 0x0004)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "CanReadMediaSerial", "%s", "TRUE"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "CanReadMediaSerial", "%s", "TRUE");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Manufacturer", "%s", AtaToCString(identify->MediaManufacturer, 20)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Manufacturer", "%s",
AtaToCString(identify->MediaManufacturer, 20));
} }
printf("Trying READ SECTOR(S) in CHS mode...\n"); printf("Trying READ SECTOR(S) in CHS mode...\n");
error = Read(fd, &buffer, &ata_error_chs, FALSE, 0, 0, 1, 1); error = Read(fd, &buffer, &ata_error_chs, FALSE, 0, 0, 1, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 &&
ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ SECTOR(S) RETRY in CHS mode...\n"); printf("Trying READ SECTOR(S) RETRY in CHS mode...\n");
error = Read(fd, &buffer, &ata_error_chs, TRUE, 0, 0, 1, 1); error = Read(fd, &buffer, &ata_error_chs, TRUE, 0, 0, 1, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadRetry", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadRetry", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 &&
ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ DMA in CHS mode...\n"); printf("Trying READ DMA in CHS mode...\n");
error = ReadDma(fd, &buffer, &ata_error_chs, FALSE, 0, 0, 1, 1); error = ReadDma(fd, &buffer, &ata_error_chs, FALSE, 0, 0, 1, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDma", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDma", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 &&
ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ DMA RETRY in CHS mode...\n"); printf("Trying READ DMA RETRY in CHS mode...\n");
error = ReadDma(fd, &buffer, &ata_error_chs, TRUE, 0, 0, 1, 1); error = ReadDma(fd, &buffer, &ata_error_chs, TRUE, 0, 0, 1, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaRetry", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaRetry", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 &&
ata_error_chs->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying SEEK in CHS mode...\n"); printf("Trying SEEK in CHS mode...\n");
error = Seek(fd, &ata_error_chs, 0, 0, 1); error = Seek(fd, &ata_error_chs, 0, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsSeek", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsSeek", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0)
? "true" : "false");
printf("Trying READ SECTOR(S) in LBA mode...\n"); printf("Trying READ SECTOR(S) in LBA mode...\n");
error = ReadLba(fd, &buffer, &ata_error_lba, FALSE, 0, 1); error = ReadLba(fd, &buffer, &ata_error_lba, FALSE, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 &&
ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ SECTOR(S) RETRY in LBA mode...\n"); printf("Trying READ SECTOR(S) RETRY in LBA mode...\n");
error = ReadLba(fd, &buffer, &ata_error_lba, TRUE, 0, 1); error = ReadLba(fd, &buffer, &ata_error_lba, TRUE, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadRetryLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadRetryLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 &&
ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ DMA in LBA mode...\n"); printf("Trying READ DMA in LBA mode...\n");
error = ReadDmaLba(fd, &buffer, &ata_error_lba, FALSE, 0, 1); error = ReadDmaLba(fd, &buffer, &ata_error_lba, FALSE, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 &&
ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ DMA RETRY in LBA mode...\n"); printf("Trying READ DMA RETRY in LBA mode...\n");
error = ReadDmaLba(fd, &buffer, &ata_error_lba, TRUE, 0, 1); error = ReadDmaLba(fd, &buffer, &ata_error_lba, TRUE, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaRetryLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaRetryLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 &&
ata_error_lba->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying SEEK in LBA mode...\n"); printf("Trying SEEK in LBA mode...\n");
error = SeekLba(fd, &ata_error_lba, 0); error = SeekLba(fd, &ata_error_lba, 0);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsSeekLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsSeekLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0)
? "true" : "false");
printf("Trying READ SECTOR(S) in LBA48 mode...\n"); printf("Trying READ SECTOR(S) in LBA48 mode...\n");
error = ReadLba48(fd, &buffer, &ata_error_lba48, 0, 1); error = ReadLba48(fd, &buffer, &ata_error_lba48, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLba48", "%s", (!error && (ata_error_lba48->status & 0x01) != 0x01 && ata_error_lba48->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLba48", "%s",
(!error && (ata_error_lba48->status & 0x01) != 0x01 &&
ata_error_lba48->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ DMA in LBA48 mode...\n"); printf("Trying READ DMA in LBA48 mode...\n");
error = ReadDmaLba48(fd, &buffer, &ata_error_lba48, 0, 1); error = ReadDmaLba48(fd, &buffer, &ata_error_lba48, 0, 1);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaLba48", "%s", (!error && (ata_error_lba48->status & 0x01) != 0x01 && ata_error_lba48->error == 0 && buffer != NULL) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadDmaLba48", "%s",
(!error && (ata_error_lba48->status & 0x01) != 0x01 &&
ata_error_lba48->error == 0 && buffer != NULL) ? "true" : "false");
printf("Trying READ LONG in CHS mode...\n"); printf("Trying READ LONG in CHS mode...\n");
error = ReadLong(fd, &buffer, &ata_error_chs, FALSE, 0, 0, 1, longblocksize); error = ReadLong(fd, &buffer, &ata_error_chs, FALSE, 0, 0, 1, longblocksize);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLong", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0 && buffer != NULL && (uint64_t)(*buffer) != 0) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLong", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 &&
ata_error_chs->error == 0 && buffer != NULL && (uint64_t)(*buffer) != 0)
? "true" : "false");
printf("Trying READ LONG RETRY in CHS mode...\n"); printf("Trying READ LONG RETRY in CHS mode...\n");
error = ReadLong(fd, &buffer, &ata_error_chs, TRUE, 0, 0, 1, longblocksize); error = ReadLong(fd, &buffer, &ata_error_chs, TRUE, 0, 0, 1, longblocksize);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLongRetry", "%s", (!error && (ata_error_chs->status & 0x01) != 0x01 && ata_error_chs->error == 0 && buffer != NULL && (uint64_t)(*buffer) != 0) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLongRetry", "%s",
(!error && (ata_error_chs->status & 0x01) != 0x01 &&
ata_error_chs->error == 0 && buffer != NULL && (uint64_t)(*buffer) != 0)
? "true" : "false");
printf("Trying READ LONG in LBA mode...\n"); printf("Trying READ LONG in LBA mode...\n");
error = ReadLongLba(fd, &buffer, &ata_error_lba, FALSE, 0, longblocksize); error = ReadLongLba(fd, &buffer, &ata_error_lba, FALSE, 0, longblocksize);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLongLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0 && buffer != NULL && (uint64_t)(*buffer) != 0) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLongLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 &&
ata_error_lba->error == 0 && buffer != NULL && (uint64_t)(*buffer) != 0)
? "true" : "false");
printf("Trying READ LONG RETRY in LBA mode...\n"); printf("Trying READ LONG RETRY in LBA mode...\n");
error = ReadLongLba(fd, &buffer, &ata_error_lba, TRUE, 0, longblocksize); error = ReadLongLba(fd, &buffer, &ata_error_lba, TRUE, 0, longblocksize);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLongRetryLba", "%s", (!error && (ata_error_lba->status & 0x01) != 0x01 && ata_error_lba->error == 0 && buffer != NULL && (uint64_t)(*buffer) != 0) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLongRetryLba", "%s",
(!error && (ata_error_lba->status & 0x01) != 0x01 &&
ata_error_lba->error == 0 && buffer != NULL && (uint64_t)(*buffer) != 0)
? "true" : "false");
xmlTextWriterEndElement(xmlWriter); // </ReadCapabilities> xmlTextWriterEndElement(xmlWriter); // </ReadCapabilities>
} }

2
DiscImageChef.Device.Report/ata_report.h
View File

@@ -5,5 +5,7 @@
#ifndef DISCIMAGECHEF_DEVICE_REPORT_ATA_REPORT_H #ifndef DISCIMAGECHEF_DEVICE_REPORT_ATA_REPORT_H
#define DISCIMAGECHEF_DEVICE_REPORT_ATA_REPORT_H #define DISCIMAGECHEF_DEVICE_REPORT_ATA_REPORT_H
#define DIC_ATA_REPORT_ELEMENT "ATA" #define DIC_ATA_REPORT_ELEMENT "ATA"
void AtaReport(int fd, xmlTextWriterPtr xmlWriter); void AtaReport(int fd, xmlTextWriterPtr xmlWriter);
#endif //DISCIMAGECHEF_DEVICE_REPORT_ATA_REPORT_H #endif //DISCIMAGECHEF_DEVICE_REPORT_ATA_REPORT_H

4
DiscImageChef.Device.Report/atapi.c
View File

@@ -4,6 +4,7 @@
#include <malloc.h> #include <malloc.h>
#include <string.h> #include <string.h>
#include <stdint.h>
#include "ata.h" #include "ata.h"
#include "atapi.h" #include "atapi.h"
@@ -16,7 +17,8 @@ int IdentifyPacket(int fd, unsigned char **buffer, AtaErrorRegistersCHS **errorR
registers.command = ATA_IDENTIFY_PACKET_DEVICE; registers.command = ATA_IDENTIFY_PACKET_DEVICE;
int error = SendAtaCommandChs(fd, registers, errorRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_NONE, *buffer, 512, 0); int error = SendAtaCommandChs(fd, registers, errorRegisters, ATA_PROTOCOL_PIO_IN, ATA_TRANSFER_NONE, *buffer, 512,
0);
return error; return error;
} }

2
DiscImageChef.Device.Report/atapi.h
View File

@@ -4,5 +4,7 @@
#ifndef DISCIMAGECHEF_DEVICE_REPORT_ATAPI_H #ifndef DISCIMAGECHEF_DEVICE_REPORT_ATAPI_H
#define DISCIMAGECHEF_DEVICE_REPORT_ATAPI_H #define DISCIMAGECHEF_DEVICE_REPORT_ATAPI_H
int IdentifyPacket(int fd, unsigned char **buffer, AtaErrorRegistersCHS **errorRegisters); int IdentifyPacket(int fd, unsigned char **buffer, AtaErrorRegistersCHS **errorRegisters);
#endif //DISCIMAGECHEF_DEVICE_REPORT_ATAPI_H #endif //DISCIMAGECHEF_DEVICE_REPORT_ATAPI_H

151
DiscImageChef.Device.Report/atapi_report.c
View File

@@ -11,9 +11,9 @@
void AtapiReport(int fd, xmlTextWriterPtr xmlWriter) void AtapiReport(int fd, xmlTextWriterPtr xmlWriter)
{ {
unsigned char *atapi_ident = NULL; unsigned char *atapi_ident = NULL;
AtaErrorRegistersCHS *ata_error_chs; AtaErrorRegistersCHS *ata_error_chs;
int error; int error;
printf("Querying ATAPI IDENTIFY...\n"); printf("Querying ATAPI IDENTIFY...\n");
@@ -33,7 +33,8 @@ void AtapiReport(int fd, xmlTextWriterPtr xmlWriter)
if((uint64_t)*identify->AdditionalPID != 0 && (uint64_t)*identify->AdditionalPID != 0x2020202020202020) if((uint64_t)*identify->AdditionalPID != 0 && (uint64_t)*identify->AdditionalPID != 0x2020202020202020)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "AdditionalPid", AtaToCString(identify->AdditionalPID, 8)); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "AdditionalPid", AtaToCString(identify->AdditionalPID, 8));
if(identify->APIOSupported) if(identify->APIOSupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "APIOSupported", DecodeTransferMode(le16toh(identify->APIOSupported))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "APIOSupported",
DecodeTransferMode(le16toh(identify->APIOSupported)));
if(identify->ATAPIByteCount) if(identify->ATAPIByteCount)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ATAPIByteCount", "%u", le16toh(identify->ATAPIByteCount)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ATAPIByteCount", "%u", le16toh(identify->ATAPIByteCount));
if(identify->BufferType) if(identify->BufferType)
@@ -41,9 +42,11 @@ void AtapiReport(int fd, xmlTextWriterPtr xmlWriter)
if(identify->BufferSize) if(identify->BufferSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BufferSize", "%u", le16toh(identify->BufferSize)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BufferSize", "%u", le16toh(identify->BufferSize));
if(identify->Capabilities) if(identify->Capabilities)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities", DecodeCapabilities(le16toh(identify->Capabilities))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities",
DecodeCapabilities(le16toh(identify->Capabilities)));
if(identify->Capabilities2) if(identify->Capabilities2)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities2", DecodeCapabilities2(le16toh(identify->Capabilities2))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities2",
DecodeCapabilities2(le16toh(identify->Capabilities2)));
if(identify->Capabilities3) if(identify->Capabilities3)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities3", DecodeCapabilities3(identify->Capabilities3)); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities3", DecodeCapabilities3(identify->Capabilities3));
if(identify->CFAPowerMode) if(identify->CFAPowerMode)
@@ -65,127 +68,173 @@ void AtapiReport(int fd, xmlTextWriterPtr xmlWriter)
if(identify->DataSetMgmt) if(identify->DataSetMgmt)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DataSetMgmt", DecodeDataSetMgmt(le16toh(identify->DataSetMgmt))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DataSetMgmt", DecodeDataSetMgmt(le16toh(identify->DataSetMgmt)));
if(identify->DataSetMgmtSize) if(identify->DataSetMgmtSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DataSetMgmtSize", "%u", le16toh(identify->DataSetMgmtSize)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DataSetMgmtSize", "%u",
le16toh(identify->DataSetMgmtSize));
if(identify->DeviceFormFactor) if(identify->DeviceFormFactor)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DeviceFormFactor", DecodeDeviceFormFactor(le16toh(identify->DeviceFormFactor))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DeviceFormFactor",
DecodeDeviceFormFactor(le16toh(identify->DeviceFormFactor)));
if(identify->DMAActive) if(identify->DMAActive)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMAActive", DecodeTransferMode(le16toh(identify->DMAActive))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMAActive", DecodeTransferMode(le16toh(identify->DMAActive)));
if(identify->DMASupported) if(identify->DMASupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMASupported", DecodeTransferMode(le16toh(identify->DMASupported))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMASupported",
DecodeTransferMode(le16toh(identify->DMASupported)));
if(identify->DMATransferTimingMode) if(identify->DMATransferTimingMode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DMATransferTimingMode", "%u", identify->DMATransferTimingMode); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DMATransferTimingMode", "%u",
identify->DMATransferTimingMode);
if(identify->EnhancedSecurityEraseTime) if(identify->EnhancedSecurityEraseTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "EnhancedSecurityEraseTime", "%u", le16toh(identify->EnhancedSecurityEraseTime)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "EnhancedSecurityEraseTime", "%u",
le16toh(identify->EnhancedSecurityEraseTime));
if(identify->EnabledCommandSet) if(identify->EnabledCommandSet)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet", DecodeCommandSet(le16toh(identify->EnabledCommandSet))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet",
DecodeCommandSet(le16toh(identify->EnabledCommandSet)));
if(identify->EnabledCommandSet2) if(identify->EnabledCommandSet2)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet2", DecodeCommandSet2(le16toh(identify->EnabledCommandSet2))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet2",
DecodeCommandSet2(le16toh(identify->EnabledCommandSet2)));
if(identify->EnabledCommandSet3) if(identify->EnabledCommandSet3)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet3", DecodeCommandSet3(le16toh(identify->EnabledCommandSet3))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet3",
DecodeCommandSet3(le16toh(identify->EnabledCommandSet3)));
if(identify->EnabledCommandSet4) if(identify->EnabledCommandSet4)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet4", DecodeCommandSet4(le16toh(identify->EnabledCommandSet4))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet4",
DecodeCommandSet4(le16toh(identify->EnabledCommandSet4)));
if(identify->EnabledSATAFeatures) if(identify->EnabledSATAFeatures)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledSATAFeatures", DecodeSATAFeatures(le16toh(identify->EnabledSATAFeatures))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledSATAFeatures",
DecodeSATAFeatures(le16toh(identify->EnabledSATAFeatures)));
if(identify->ExtendedUserSectors) if(identify->ExtendedUserSectors)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ExtendedUserSectors", "%llu", le64toh(identify->ExtendedUserSectors)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ExtendedUserSectors", "%llu",
le64toh(identify->ExtendedUserSectors));
if(identify->FreeFallSensitivity) if(identify->FreeFallSensitivity)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "FreeFallSensitivity", "%u", identify->FreeFallSensitivity); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "FreeFallSensitivity", "%u", identify->FreeFallSensitivity);
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "FirmwareRevision", AtaToCString(identify->FirmwareRevision, 8)); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "FirmwareRevision", AtaToCString(identify->FirmwareRevision, 8));
if(identify->GeneralConfiguration) if(identify->GeneralConfiguration)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "GeneralConfiguration", DecodeGeneralConfiguration(le16toh(identify->GeneralConfiguration))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "GeneralConfiguration",
DecodeGeneralConfiguration(le16toh(identify->GeneralConfiguration)));
if(identify->HardwareResetResult) if(identify->HardwareResetResult)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "HardwareResetResult", "%u", le16toh(identify->HardwareResetResult)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "HardwareResetResult", "%u",
le16toh(identify->HardwareResetResult));
if(identify->InterseekDelay) if(identify->InterseekDelay)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "InterseekDelay", "%u", le16toh(identify->InterseekDelay)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "InterseekDelay", "%u", le16toh(identify->InterseekDelay));
if(identify->MajorVersion) if(identify->MajorVersion)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MajorVersion", DecodeMajorVersion(le16toh(identify->MajorVersion))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MajorVersion",
DecodeMajorVersion(le16toh(identify->MajorVersion)));
if(identify->MasterPasswordRevisionCode) if(identify->MasterPasswordRevisionCode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MasterPasswordRevisionCode", "%u", le16toh(identify->MasterPasswordRevisionCode)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MasterPasswordRevisionCode", "%u",
le16toh(identify->MasterPasswordRevisionCode));
if(identify->MaxDownloadMicroMode3) if(identify->MaxDownloadMicroMode3)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxDownloadMicroMode3", "%u", le16toh(identify->MaxDownloadMicroMode3)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxDownloadMicroMode3", "%u",
le16toh(identify->MaxDownloadMicroMode3));
if(identify->MaxQueueDepth) if(identify->MaxQueueDepth)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxQueueDepth", "%u", le16toh(identify->MaxQueueDepth)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxQueueDepth", "%u", le16toh(identify->MaxQueueDepth));
if(identify->MDMAActive) if(identify->MDMAActive)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMAActive", DecodeTransferMode(le16toh(identify->MDMAActive))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMAActive", DecodeTransferMode(le16toh(identify->MDMAActive)));
if(identify->MDMASupported) if(identify->MDMASupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMASupported", DecodeTransferMode(le16toh(identify->MDMASupported))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMASupported",
DecodeTransferMode(le16toh(identify->MDMASupported)));
if(identify->MinDownloadMicroMode3) if(identify->MinDownloadMicroMode3)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinDownloadMicroMode3", "%u", le16toh(identify->MinDownloadMicroMode3)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinDownloadMicroMode3", "%u",
le16toh(identify->MinDownloadMicroMode3));
if(identify->MinMDMACycleTime) if(identify->MinMDMACycleTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinMDMACycleTime", "%u", le16toh(identify->MinMDMACycleTime)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinMDMACycleTime", "%u",
le16toh(identify->MinMDMACycleTime));
if(identify->MinorVersion) if(identify->MinorVersion)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinorVersion", "%u", le16toh(identify->MinorVersion)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinorVersion", "%u", le16toh(identify->MinorVersion));
if(identify->MinPIOCycleTimeNoFlow) if(identify->MinPIOCycleTimeNoFlow)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinPIOCycleTimeNoFlow", "%u", le16toh(identify->MinPIOCycleTimeNoFlow)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinPIOCycleTimeNoFlow", "%u",
le16toh(identify->MinPIOCycleTimeNoFlow));
if(identify->MinPIOCycleTimeFlow) if(identify->MinPIOCycleTimeFlow)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinPIOCycleTimeFlow", "%u", le16toh(identify->MinPIOCycleTimeFlow)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinPIOCycleTimeFlow", "%u",
le16toh(identify->MinPIOCycleTimeFlow));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Model", AtaToCString(identify->Model, 40)); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Model", AtaToCString(identify->Model, 40));
if(identify->MultipleMaxSectors) if(identify->MultipleMaxSectors)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleMaxSectors", "%u", identify->MultipleMaxSectors); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleMaxSectors", "%u", identify->MultipleMaxSectors);
if(identify->MultipleSectorNumber) if(identify->MultipleSectorNumber)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleSectorNumber", "%u", identify->MultipleSectorNumber); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleSectorNumber", "%u",
identify->MultipleSectorNumber);
if(identify->NVCacheCaps) if(identify->NVCacheCaps)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheCaps", "%u", le16toh(identify->NVCacheCaps)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheCaps", "%u", le16toh(identify->NVCacheCaps));
if(identify->NVCacheSize) if(identify->NVCacheSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheSize", "%u", le32toh(identify->NVCacheSize)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheSize", "%u", le32toh(identify->NVCacheSize));
if(identify->NVCacheWriteSpeed) if(identify->NVCacheWriteSpeed)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheWriteSpeed", "%u", le16toh(identify->NVCacheWriteSpeed)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheWriteSpeed", "%u",
le16toh(identify->NVCacheWriteSpeed));
if(identify->NVEstimatedSpinUp) if(identify->NVEstimatedSpinUp)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVEstimatedSpinUp", "%u", identify->NVEstimatedSpinUp); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVEstimatedSpinUp", "%u", identify->NVEstimatedSpinUp);
if(identify->PacketBusRelease) if(identify->PacketBusRelease)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PacketBusRelease", "%u", le16toh(identify->PacketBusRelease)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PacketBusRelease", "%u",
le16toh(identify->PacketBusRelease));
if(identify->PIOTransferTimingMode) if(identify->PIOTransferTimingMode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PIOTransferTimingMode", "%u", identify->PIOTransferTimingMode); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PIOTransferTimingMode", "%u",
identify->PIOTransferTimingMode);
if(identify->RecommendedAAM) if(identify->RecommendedAAM)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecommendedAAM", "%u", identify->RecommendedAAM); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecommendedAAM", "%u", identify->RecommendedAAM);
if(identify->RecMDMACycleTime) if(identify->RecMDMACycleTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecMDMACycleTime", "%u", le16toh(identify->RecMDMACycleTime)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecMDMACycleTime", "%u",
le16toh(identify->RecMDMACycleTime));
if(identify->RemovableStatusSet) if(identify->RemovableStatusSet)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RemovableStatusSet", "%u", le16toh(identify->RemovableStatusSet)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RemovableStatusSet", "%u",
le16toh(identify->RemovableStatusSet));
if(identify->SATACapabilities) if(identify->SATACapabilities)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities", DecodeSATACapabilities(le16toh(identify->SATACapabilities))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities",
DecodeSATACapabilities(le16toh(identify->SATACapabilities)));
if(identify->SATACapabilities2) if(identify->SATACapabilities2)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities2", DecodeSATACapabilities2(le16toh(identify->SATACapabilities2))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities2",
DecodeSATACapabilities2(le16toh(identify->SATACapabilities2)));
if(identify->SATAFeatures) if(identify->SATAFeatures)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATAFeatures", DecodeSATAFeatures(le16toh(identify->SATAFeatures))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATAFeatures",
DecodeSATAFeatures(le16toh(identify->SATAFeatures)));
if(identify->SCTCommandTransport) if(identify->SCTCommandTransport)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SCTCommandTransport", DecodeSCTCommandTransport(le16toh(identify->SCTCommandTransport))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SCTCommandTransport",
DecodeSCTCommandTransport(le16toh(identify->SCTCommandTransport)));
if(identify->SectorsPerCard) if(identify->SectorsPerCard)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SectorsPerCard", "%u", le32toh(identify->SectorsPerCard)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SectorsPerCard", "%u", le32toh(identify->SectorsPerCard));
if(identify->SecurityEraseTime) if(identify->SecurityEraseTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SecurityEraseTime", "%u", le16toh(identify->SecurityEraseTime)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SecurityEraseTime", "%u",
le16toh(identify->SecurityEraseTime));
if(identify->SecurityStatus) if(identify->SecurityStatus)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SecurityStatus", DecodeSecurityStatus(le16toh(identify->SecurityStatus))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SecurityStatus",
DecodeSecurityStatus(le16toh(identify->SecurityStatus)));
if(identify->ServiceBusyClear) if(identify->ServiceBusyClear)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ServiceBusyClear", "%u", le16toh(identify->ServiceBusyClear)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ServiceBusyClear", "%u",
le16toh(identify->ServiceBusyClear));
if(identify->SpecificConfiguration) if(identify->SpecificConfiguration)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SpecificConfiguration", DecodeSpecificConfiguration(le16toh(identify->SpecificConfiguration))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SpecificConfiguration",
DecodeSpecificConfiguration(le16toh(identify->SpecificConfiguration)));
if(identify->StreamAccessLatency) if(identify->StreamAccessLatency)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamAccessLatency", "%u", le16toh(identify->StreamAccessLatency)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamAccessLatency", "%u",
le16toh(identify->StreamAccessLatency));
if(identify->StreamMinReqSize) if(identify->StreamMinReqSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamMinReqSize", "%u", le16toh(identify->StreamMinReqSize)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamMinReqSize", "%u",
le16toh(identify->StreamMinReqSize));
if(identify->StreamPerformanceGranularity) if(identify->StreamPerformanceGranularity)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamPerformanceGranularity", "%u", le32toh(identify->StreamPerformanceGranularity)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamPerformanceGranularity", "%u",
le32toh(identify->StreamPerformanceGranularity));
if(identify->StreamTransferTimeDMA) if(identify->StreamTransferTimeDMA)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimeDMA", "%u", le16toh(identify->StreamTransferTimeDMA)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimeDMA", "%u",
le16toh(identify->StreamTransferTimeDMA));
if(identify->StreamTransferTimePIO) if(identify->StreamTransferTimePIO)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimePIO", "%u", le16toh(identify->StreamTransferTimePIO)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimePIO", "%u",
le16toh(identify->StreamTransferTimePIO));
if(identify->TransportMajorVersion) if(identify->TransportMajorVersion)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMajorVersion", "%u", le16toh(identify->TransportMajorVersion)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMajorVersion", "%u",
le16toh(identify->TransportMajorVersion));
if(identify->TransportMinorVersion) if(identify->TransportMinorVersion)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMinorVersion", "%u", le16toh(identify->TransportMinorVersion)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMinorVersion", "%u",
le16toh(identify->TransportMinorVersion));
if(identify->TrustedComputing) if(identify->TrustedComputing)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "TrustedComputing", DecodeTrustedComputing(le16toh(identify->TrustedComputing))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "TrustedComputing",
DecodeTrustedComputing(le16toh(identify->TrustedComputing)));
if(identify->UDMAActive) if(identify->UDMAActive)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMAActive", DecodeTransferMode(le16toh(identify->UDMAActive))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMAActive", DecodeTransferMode(le16toh(identify->UDMAActive)));
if(identify->UDMASupported) if(identify->UDMASupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMASupported", DecodeTransferMode(le16toh(identify->UDMASupported))); xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMASupported",
DecodeTransferMode(le16toh(identify->UDMASupported)));
if(identify->WRVMode) if(identify->WRVMode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVMode", "%u", identify->WRVMode); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVMode", "%u", identify->WRVMode);
if(identify->WRVSectorCountMode3) if(identify->WRVSectorCountMode3)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVSectorCountMode3", "%u", le32toh(identify->WRVSectorCountMode3)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVSectorCountMode3", "%u",
le32toh(identify->WRVSectorCountMode3));
if(identify->WRVSectorCountMode2) if(identify->WRVSectorCountMode2)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVSectorCountMode2", "%u", le32toh(identify->WRVSectorCountMode2)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVSectorCountMode2", "%u",
le32toh(identify->WRVSectorCountMode2));
xmlTextWriterStartElement(xmlWriter, BAD_CAST "Identify"); // <Identify> xmlTextWriterStartElement(xmlWriter, BAD_CAST "Identify"); // <Identify>
xmlTextWriterWriteBase64(xmlWriter, atapi_ident, 0, 512); xmlTextWriterWriteBase64(xmlWriter, atapi_ident, 0, 512);

2
DiscImageChef.Device.Report/atapi_report.h
View File

@@ -5,8 +5,8 @@
#ifndef DISCIMAGECHEF_DEVICE_REPORT_ATAPI_REPORT_H #ifndef DISCIMAGECHEF_DEVICE_REPORT_ATAPI_REPORT_H
#define DISCIMAGECHEF_DEVICE_REPORT_ATAPI_REPORT_H #define DISCIMAGECHEF_DEVICE_REPORT_ATAPI_REPORT_H
#include <libxml/xmlwriter.h>
#define DIC_ATAPI_REPORT_ELEMENT "ATAPI" #define DIC_ATAPI_REPORT_ELEMENT "ATAPI"
void AtapiReport(int fd, xmlTextWriterPtr xmlWriter); void AtapiReport(int fd, xmlTextWriterPtr xmlWriter);
#endif //DISCIMAGECHEF_DEVICE_REPORT_ATAPI_REPORT_H #endif //DISCIMAGECHEF_DEVICE_REPORT_ATAPI_REPORT_H

176
DiscImageChef.Device.Report/cdrom_mode.h
View File

@@ -8,9 +8,9 @@
#pragma pack(push, 1) #pragma pack(push, 1)
typedef struct typedef struct
{ {
uint8_t Reserved1; uint8_t Reserved1;
uint8_t RotationControl : 3; uint8_t RotationControl : 3;
uint8_t Reserved2 : 5; uint8_t Reserved2 : 5;
uint16_t WriteSpeed; uint16_t WriteSpeed;
} ModePage_2A_WriteDescriptor; } ModePage_2A_WriteDescriptor;
#pragma pack(pop) #pragma pack(pop)
@@ -18,95 +18,95 @@ typedef struct
#pragma pack(push, 1) #pragma pack(push, 1)
typedef struct typedef struct
{ {
uint8_t PageCode : 6; uint8_t PageCode : 6;
uint8_t Reserved1 : 1; uint8_t Reserved1 : 1;
/* Parameters can be saved */ /* Parameters can be saved */
uint8_t PS : 1; uint8_t PS : 1;
uint8_t PageLength; uint8_t PageLength;
uint8_t ReadCDR : 1; uint8_t ReadCDR : 1;
uint8_t ReadCDRW : 1; uint8_t ReadCDRW : 1;
uint8_t Method2 : 1; uint8_t Method2 : 1;
uint8_t ReadDVDROM : 1; uint8_t ReadDVDROM : 1;
uint8_t ReadDVDR : 1; uint8_t ReadDVDR : 1;
uint8_t ReadDVDRAM : 1; uint8_t ReadDVDRAM : 1;
uint8_t Reserved2 : 2; uint8_t Reserved2 : 2;
uint8_t WriteCDR : 1; uint8_t WriteCDR : 1;
uint8_t WriteCDRW : 1; uint8_t WriteCDRW : 1;
uint8_t TestWrite : 1; uint8_t TestWrite : 1;
uint8_t Reserved3 : 1; uint8_t Reserved3 : 1;
uint8_t WriteDVDR : 1; uint8_t WriteDVDR : 1;
uint8_t WriteDVDRAM : 1; uint8_t WriteDVDRAM : 1;
uint8_t Reserved4 : 2; uint8_t Reserved4 : 2;
/* Drive is capable of playing audio */ /* Drive is capable of playing audio */
uint8_t AudioPlay : 1; uint8_t AudioPlay : 1;
uint8_t Composite : 1; uint8_t Composite : 1;
uint8_t DigitalPort1 : 1; uint8_t DigitalPort1 : 1;
uint8_t DigitalPort2 : 1; uint8_t DigitalPort2 : 1;
/* Drive is capable of reading sectors in Mode 2 Form 1 format */ /* Drive is capable of reading sectors in Mode 2 Form 1 format */
uint8_t Mode2Form1 : 1; uint8_t Mode2Form1 : 1;
/* Drive is capable of reading sectors in Mode 2 Form 2 format */ /* Drive is capable of reading sectors in Mode 2 Form 2 format */
uint8_t Mode2Form2 : 1; uint8_t Mode2Form2 : 1;
/* Drive supports multi-session and/or Photo-CD */ /* Drive supports multi-session and/or Photo-CD */
uint8_t MultiSession : 1; uint8_t MultiSession : 1;
uint8_t BUF : 1; uint8_t BUF : 1;
/* Audio can be read as digital data */ /* Audio can be read as digital data */
uint8_t CDDACommand : 1; uint8_t CDDACommand : 1;
/* Drive can continue from a loss of streaming on audio reading */ /* Drive can continue from a loss of streaming on audio reading */
uint8_t AccurateCDDA : 1; uint8_t AccurateCDDA : 1;
/* Drive can read interleaved and uncorrected R-W subchannels */ /* Drive can read interleaved and uncorrected R-W subchannels */
uint8_t Subchannel : 1; uint8_t Subchannel : 1;
/* Drive can read, deinterlave and correct R-W subchannels */ /* Drive can read, deinterlave and correct R-W subchannels */
uint8_t DeinterlaveSubchannel : 1; uint8_t DeinterlaveSubchannel : 1;
/* Drive can return C2 pointers */ /* Drive can return C2 pointers */
uint8_t C2Pointer : 1; uint8_t C2Pointer : 1;
/* Drive can return the media catalogue number */ /* Drive can return the media catalogue number */
uint8_t UPC : 1; uint8_t UPC : 1;
/* Drive can return the ISRC */ /* Drive can return the ISRC */
uint8_t ISRC : 1; uint8_t ISRC : 1;
uint8_t ReadBarcode : 1; uint8_t ReadBarcode : 1;
/* Drive can lock media */ /* Drive can lock media */
uint8_t Lock : 1; uint8_t Lock : 1;
/* Current lock status */ /* Current lock status */
uint8_t LockState : 1; uint8_t LockState : 1;
/* Drive's optional prevent jumper status */ /* Drive's optional prevent jumper status */
uint8_t PreventJumper : 1; uint8_t PreventJumper : 1;
/* Drive can eject discs */ /* Drive can eject discs */
uint8_t Eject : 1; uint8_t Eject : 1;
uint8_t Reserved5 : 1; uint8_t Reserved5 : 1;
/* Loading Mechanism Type */ /* Loading Mechanism Type */
uint8_t LoadingMechanism : 3; uint8_t LoadingMechanism : 3;
/* Each channel's volume can be controlled independently */ /* Each channel's volume can be controlled independently */
uint8_t SeparateChannelVolume : 1; uint8_t SeparateChannelVolume : 1;
/* Each channel can be muted independently */ /* Each channel can be muted independently */
uint8_t SeparateChannelMute : 1; uint8_t SeparateChannelMute : 1;
uint8_t SDP : 1; uint8_t SDP : 1;
uint8_t SSS : 1; uint8_t SSS : 1;
uint8_t SCC : 1; uint8_t SCC : 1;
uint8_t LeadInPW : 1; uint8_t LeadInPW : 1;
uint8_t Reserved6 : 2; uint8_t Reserved6 : 2;
/* Maximum drive speed in Kbytes/second */ /* Maximum drive speed in Kbytes/second */
uint16_t MaximumSpeed ; uint16_t MaximumSpeed;
/* Supported volume levels */ /* Supported volume levels */
uint16_t SupportedVolumeLevels; uint16_t SupportedVolumeLevels;
/* Buffer size in Kbytes */ /* Buffer size in Kbytes */
uint16_t BufferSize; uint16_t BufferSize;
/* Current drive speed in Kbytes/second */ /* Current drive speed in Kbytes/second */
uint16_t CurrentSpeed; uint16_t CurrentSpeed;
uint8_t Reserved7; uint8_t Reserved7;
uint8_t Reserved8 : 1; uint8_t Reserved8 : 1;
uint8_t BCK : 1; uint8_t BCK : 1;
uint8_t RCK : 1; uint8_t RCK : 1;
uint8_t LSBF : 1; uint8_t LSBF : 1;
uint8_t Length : 2; uint8_t Length : 2;
uint8_t Reserved9 : 2; uint8_t Reserved9 : 2;
uint16_t MaxWriteSpeed; uint16_t MaxWriteSpeed;
uint16_t CurrentWriteSpeed; uint16_t CurrentWriteSpeed;
uint16_t CMRSupported; uint16_t CMRSupported;
uint8_t Reserved10[3]; uint8_t Reserved10[3];
uint8_t RotationControlSelected : 2; uint8_t RotationControlSelected : 2;
uint8_t Reserved11 : 6; uint8_t Reserved11 : 6;
uint16_t CurrentWriteSpeedSelected; uint16_t CurrentWriteSpeedSelected;
uint16_t LogicalWriteSpeedDescriptors; uint16_t LogicalWriteSpeedDescriptors;
ModePage_2A_WriteDescriptor WriteSpeedPerformanceDescriptors[56]; ModePage_2A_WriteDescriptor WriteSpeedPerformanceDescriptors[56];
} ModePage_2A; } ModePage_2A;
#pragma pack(pop) #pragma pack(pop)

24
DiscImageChef.Device.Report/identify_decode.c
View File

@@ -11,7 +11,7 @@
char *DecodeGeneralConfiguration(uint16_t configuration) char *DecodeGeneralConfiguration(uint16_t configuration)
{ {
char* decoded = malloc(MAX_STRING_SIZE); char *decoded = malloc(MAX_STRING_SIZE);
memset(decoded, 0, MAX_STRING_SIZE); memset(decoded, 0, MAX_STRING_SIZE);
int set = 0; int set = 0;
@@ -223,7 +223,7 @@ char *DecodeTransferMode(uint16_t transferMode)
char *DecodeCapabilities(uint16_t capabilities) char *DecodeCapabilities(uint16_t capabilities)
{ {
char* decoded = malloc(MAX_STRING_SIZE); char *decoded = malloc(MAX_STRING_SIZE);
memset(decoded, 0, MAX_STRING_SIZE); memset(decoded, 0, MAX_STRING_SIZE);
int set = 0; int set = 0;
@@ -361,7 +361,7 @@ char *DecodeCapabilities(uint16_t capabilities)
char *DecodeCapabilities2(uint16_t capabilities) char *DecodeCapabilities2(uint16_t capabilities)
{ {
char* decoded = malloc(MAX_STRING_SIZE); char *decoded = malloc(MAX_STRING_SIZE);
memset(decoded, 0, MAX_STRING_SIZE); memset(decoded, 0, MAX_STRING_SIZE);
int set = 0; int set = 0;
@@ -499,14 +499,12 @@ char *DecodeCapabilities2(uint16_t capabilities)
char *DecodeCapabilities3(uint8_t capabilities) char *DecodeCapabilities3(uint8_t capabilities)
{ {
char* decoded = malloc(MAX_STRING_SIZE); char *decoded = malloc(MAX_STRING_SIZE);
memset(decoded, 0, MAX_STRING_SIZE); memset(decoded, 0, MAX_STRING_SIZE);
int set = 0; int set = 0;
if(capabilities & 0x80) if(capabilities & 0x80)
{ {
if(set)
strcat(decoded, " ");
strcat(decoded, "BlockErase"); strcat(decoded, "BlockErase");
set = 1; set = 1;
} }
@@ -575,7 +573,7 @@ char *DecodeCapabilities3(uint8_t capabilities)
char *DecodeCommandSet(uint16_t commandset) char *DecodeCommandSet(uint16_t commandset)
{ {
char* decoded = malloc(MAX_STRING_SIZE); char *decoded = malloc(MAX_STRING_SIZE);
memset(decoded, 0, MAX_STRING_SIZE); memset(decoded, 0, MAX_STRING_SIZE);
int set = 0; int set = 0;
@@ -713,7 +711,7 @@ char *DecodeCommandSet(uint16_t commandset)
char *DecodeCommandSet2(uint16_t commandset) char *DecodeCommandSet2(uint16_t commandset)
{ {
char* decoded = malloc(MAX_STRING_SIZE); char *decoded = malloc(MAX_STRING_SIZE);
memset(decoded, 0, MAX_STRING_SIZE); memset(decoded, 0, MAX_STRING_SIZE);
int set = 0; int set = 0;
@@ -851,7 +849,7 @@ char *DecodeCommandSet2(uint16_t commandset)
char *DecodeCommandSet3(uint16_t commandset) char *DecodeCommandSet3(uint16_t commandset)
{ {
char* decoded = malloc(MAX_STRING_SIZE); char *decoded = malloc(MAX_STRING_SIZE);
memset(decoded, 0, MAX_STRING_SIZE); memset(decoded, 0, MAX_STRING_SIZE);
int set = 0; int set = 0;
@@ -989,7 +987,7 @@ char *DecodeCommandSet3(uint16_t commandset)
char *DecodeCommandSet4(uint16_t commandset) char *DecodeCommandSet4(uint16_t commandset)
{ {
char* decoded = malloc(MAX_STRING_SIZE); char *decoded = malloc(MAX_STRING_SIZE);
memset(decoded, 0, MAX_STRING_SIZE); memset(decoded, 0, MAX_STRING_SIZE);
int set = 0; int set = 0;
@@ -1127,7 +1125,7 @@ char *DecodeCommandSet4(uint16_t commandset)
char *DecodeCommandSet5(uint16_t commandset) char *DecodeCommandSet5(uint16_t commandset)
{ {
char* decoded = malloc(MAX_STRING_SIZE); char *decoded = malloc(MAX_STRING_SIZE);
memset(decoded, 0, MAX_STRING_SIZE); memset(decoded, 0, MAX_STRING_SIZE);
int set = 0; int set = 0;
@@ -1265,7 +1263,7 @@ char *DecodeCommandSet5(uint16_t commandset)
char *DecodeDataSetMgmt(uint16_t datasetmgmt) char *DecodeDataSetMgmt(uint16_t datasetmgmt)
{ {
char* decoded = malloc(MAX_STRING_SIZE); char *decoded = malloc(MAX_STRING_SIZE);
memset(decoded, 0, MAX_STRING_SIZE); memset(decoded, 0, MAX_STRING_SIZE);
int set = 0; int set = 0;
@@ -2269,7 +2267,7 @@ char *DecodeSpecificConfiguration(uint16_t configuration)
char *DecodeTrustedComputing(uint16_t trutedcomputing) char *DecodeTrustedComputing(uint16_t trutedcomputing)
{ {
char* decoded = malloc(MAX_STRING_SIZE); char *decoded = malloc(MAX_STRING_SIZE);
memset(decoded, 0, MAX_STRING_SIZE); memset(decoded, 0, MAX_STRING_SIZE);
int set = 0; int set = 0;

21
DiscImageChef.Device.Report/identify_decode.h
View File

@@ -4,24 +4,45 @@
#ifndef DISCIMAGECHEF_DEVICE_REPORT_IDENTIFY_DECODE_H #ifndef DISCIMAGECHEF_DEVICE_REPORT_IDENTIFY_DECODE_H
#define DISCIMAGECHEF_DEVICE_REPORT_IDENTIFY_DECODE_H #define DISCIMAGECHEF_DEVICE_REPORT_IDENTIFY_DECODE_H
char *DecodeGeneralConfiguration(uint16_t configuration); char *DecodeGeneralConfiguration(uint16_t configuration);
char *DecodeTransferMode(uint16_t transferMode); char *DecodeTransferMode(uint16_t transferMode);
char *DecodeCapabilities(uint16_t capabilities); char *DecodeCapabilities(uint16_t capabilities);
char *DecodeCapabilities2(uint16_t capabilities); char *DecodeCapabilities2(uint16_t capabilities);
char *DecodeCapabilities3(uint8_t capabilities); char *DecodeCapabilities3(uint8_t capabilities);
char *DecodeCommandSet(uint16_t commandset); char *DecodeCommandSet(uint16_t commandset);
char *DecodeCommandSet2(uint16_t commandset); char *DecodeCommandSet2(uint16_t commandset);
char *DecodeCommandSet3(uint16_t commandset); char *DecodeCommandSet3(uint16_t commandset);
char *DecodeCommandSet4(uint16_t commandset); char *DecodeCommandSet4(uint16_t commandset);
char *DecodeCommandSet5(uint16_t commandset); char *DecodeCommandSet5(uint16_t commandset);
char *DecodeDataSetMgmt(uint16_t datasetmgmt); char *DecodeDataSetMgmt(uint16_t datasetmgmt);
char *DecodeDeviceFormFactor(uint16_t formfactor); char *DecodeDeviceFormFactor(uint16_t formfactor);
char *DecodeSATAFeatures(uint16_t features); char *DecodeSATAFeatures(uint16_t features);
char *DecodeMajorVersion(uint16_t capabilities); char *DecodeMajorVersion(uint16_t capabilities);
char *DecodeSATACapabilities(uint16_t capabilities); char *DecodeSATACapabilities(uint16_t capabilities);
char *DecodeSATACapabilities2(uint16_t transport); char *DecodeSATACapabilities2(uint16_t transport);
char *DecodeSCTCommandTransport(uint16_t transport); char *DecodeSCTCommandTransport(uint16_t transport);
char *DecodeSecurityStatus(uint16_t status); char *DecodeSecurityStatus(uint16_t status);
char *DecodeSpecificConfiguration(uint16_t configuration); char *DecodeSpecificConfiguration(uint16_t configuration);
char *DecodeTrustedComputing(uint16_t trutedcomputing); char *DecodeTrustedComputing(uint16_t trutedcomputing);
#endif //DISCIMAGECHEF_DEVICE_REPORT_IDENTIFY_DECODE_H #endif //DISCIMAGECHEF_DEVICE_REPORT_IDENTIFY_DECODE_H

6
DiscImageChef.Device.Report/inquiry_decode.h
View File

@@ -5,10 +5,12 @@
#ifndef DISCIMAGECHEF_DEVICE_REPORT_INQUIRY_DECODE_H #ifndef DISCIMAGECHEF_DEVICE_REPORT_INQUIRY_DECODE_H
#define DISCIMAGECHEF_DEVICE_REPORT_INQUIRY_DECODE_H #define DISCIMAGECHEF_DEVICE_REPORT_INQUIRY_DECODE_H
#include <stdint.h>
char *DecodeTPGSValues(uint8_t capabilities); char *DecodeTPGSValues(uint8_t capabilities);
char *DecodePeripheralDeviceType(uint8_t capabilities); char *DecodePeripheralDeviceType(uint8_t capabilities);
char *DecodePeripheralQualifier(uint8_t capabilities); char *DecodePeripheralQualifier(uint8_t capabilities);
char *DecodeSPIClocking(uint8_t capabilities); char *DecodeSPIClocking(uint8_t capabilities);
#endif //DISCIMAGECHEF_DEVICE_REPORT_INQUIRY_DECODE_H #endif //DISCIMAGECHEF_DEVICE_REPORT_INQUIRY_DECODE_H

38
DiscImageChef.Device.Report/main.c
View File

@@ -4,6 +4,8 @@
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include <malloc.h> #include <malloc.h>
#include <stdint.h>
#include <libxml/xmlwriter.h>
#include "scsi.h" #include "scsi.h"
#include "ata.h" #include "ata.h"
#include "main.h" #include "main.h"
@@ -11,7 +13,6 @@
#include "atapi_report.h" #include "atapi_report.h"
#include "scsi_report.h" #include "scsi_report.h"
#include "ata_report.h" #include "ata_report.h"
#include <libxml/xmlwriter.h>
#define DIC_VERSION "3.99.6.0" #define DIC_VERSION "3.99.6.0"
#define DIC_COPYRIGHT "Copyright © 2011-2017 Natalia Portillo" #define DIC_COPYRIGHT "Copyright © 2011-2017 Natalia Portillo"
@@ -20,20 +21,20 @@
int main(int argc, void *argv[]) int main(int argc, void *argv[])
{ {
int fd, rc; int fd, rc;
unsigned char *scsi_sense = NULL; unsigned char *scsi_sense = NULL;
unsigned char *scsi_inq_data = NULL; unsigned char *scsi_inq_data = NULL;
unsigned char *ata_ident = NULL; unsigned char *ata_ident = NULL;
unsigned char *atapi_ident = NULL; unsigned char *atapi_ident = NULL;
AtaErrorRegistersCHS *ata_error_chs; AtaErrorRegistersCHS *ata_error_chs;
int scsi_error, ata_error; int scsi_error, ata_error;
unsigned char* manufacturer; unsigned char *manufacturer;
unsigned char* product; unsigned char *product;
unsigned char* revision; unsigned char *revision;
int deviceType = DEVICE_TYPE_UNKNOWN; int deviceType = DEVICE_TYPE_UNKNOWN;
char* xmlFilename = malloc(NAME_MAX + 1); char *xmlFilename = malloc(NAME_MAX + 1);
xmlTextWriterPtr xmlWriter; xmlTextWriterPtr xmlWriter;
const char* ataName = "ATA"; const char *ataName = "ATA";
printf("The Disc Image Chef Device Reporter for Linux %s\n", DIC_VERSION); printf("The Disc Image Chef Device Reporter for Linux %s\n", DIC_VERSION);
printf("%s\n", DIC_COPYRIGHT); printf("%s\n", DIC_COPYRIGHT);
@@ -81,15 +82,15 @@ int main(int argc, void *argv[])
deviceType = DEVICE_TYPE_ATAPI; deviceType = DEVICE_TYPE_ATAPI;
} }
if(scsi_inq_data == NULL || !strncmp((const char *)manufacturer,ataName, 3)) if(scsi_inq_data == NULL || !strncmp((const char *)manufacturer, ataName, 3))
{ {
ata_error = Identify(fd, &ata_ident, &ata_error_chs); ata_error = Identify(fd, &ata_ident, &ata_error_chs);
if(!ata_error) if(!ata_error)
{ {
deviceType = DEVICE_TYPE_ATA; deviceType = DEVICE_TYPE_ATA;
revision = AtaToCString(ata_ident + (23*2), 8); revision = AtaToCString(ata_ident + (23 * 2), 8);
product = AtaToCString(ata_ident + (27*2), 40); product = AtaToCString(ata_ident + (27 * 2), 40);
} }
} }
@@ -98,7 +99,7 @@ int main(int argc, void *argv[])
printf("Product: %s\n", product); printf("Product: %s\n", product);
printf("Revision: %s\n", revision); printf("Revision: %s\n", revision);
if(deviceType != DEVICE_TYPE_ATA && deviceType!=DEVICE_TYPE_ATAPI && deviceType != DEVICE_TYPE_SCSI) if(deviceType != DEVICE_TYPE_ATA && deviceType != DEVICE_TYPE_ATAPI && deviceType != DEVICE_TYPE_SCSI)
{ {
printf("Unsupported device type %s.", DeviceType[deviceType]); printf("Unsupported device type %s.", DeviceType[deviceType]);
return 3; return 3;
@@ -127,7 +128,7 @@ int main(int argc, void *argv[])
return 4; return 4;
} }
char* xmlComment = malloc(255); char *xmlComment = malloc(255);
sprintf(xmlComment, "Report created with DiscImageChef.Device.Report v%s", DIC_VERSION); sprintf(xmlComment, "Report created with DiscImageChef.Device.Report v%s", DIC_VERSION);
rc = xmlTextWriterWriteComment(xmlWriter, xmlComment); rc = xmlTextWriterWriteComment(xmlWriter, xmlComment);
if(rc < 0) if(rc < 0)
@@ -146,7 +147,8 @@ int main(int argc, void *argv[])
AtaReport(fd, xmlWriter); AtaReport(fd, xmlWriter);
rc = xmlTextWriterEndDocument(xmlWriter); rc = xmlTextWriterEndDocument(xmlWriter);
if (rc < 0) { if(rc < 0)
{
printf("Could not close XML report file.\n"); printf("Could not close XML report file.\n");
return 4; return 4;
} }

3
DiscImageChef.Device.Report/main.h
View File

@@ -17,5 +17,6 @@ typedef enum
DEVICE_TYPE_SD DEVICE_TYPE_SD
} DeviceTypes; } DeviceTypes;
const char* DeviceType[] = { "Unknown", "SCSI", "ATA", "ATAPI", "USB", "FireWire", "PCMCIA", "MultiMediaCard", "SecureDigital" }; const char *DeviceType[] = {"Unknown", "SCSI", "ATA", "ATAPI", "USB", "FireWire", "PCMCIA", "MultiMediaCard",
"SecureDigital"};
#endif //DISCIMAGECHEF_DEVICE_REPORT_MAIN_H #endif //DISCIMAGECHEF_DEVICE_REPORT_MAIN_H

745
DiscImageChef.Device.Report/mmc_report.c
View File

File diff suppressed because it is too large Load Diff

12
DiscImageChef.Device.Report/mmc_report.h
View File

@@ -5,19 +5,19 @@
#ifndef DISCIMAGECHEF_DEVICE_REPORT_MMC_REPORT_H #ifndef DISCIMAGECHEF_DEVICE_REPORT_MMC_REPORT_H
#define DISCIMAGECHEF_DEVICE_REPORT_MMC_REPORT_H #define DISCIMAGECHEF_DEVICE_REPORT_MMC_REPORT_H
void MmcReport(int fd, xmlTextWriterPtr xmlWriter, unsigned char* cdromMode); void MmcReport(int fd, xmlTextWriterPtr xmlWriter, unsigned char *cdromMode);
typedef struct typedef struct
{ {
int present; int present;
size_t len; size_t len;
unsigned char* data; unsigned char *data;
} FeatureDescriptors; } FeatureDescriptors;
typedef struct typedef struct
{ {
uint32_t DataLength; uint32_t DataLength;
uint16_t CurrentProfile; uint16_t CurrentProfile;
FeatureDescriptors Descriptors[65536]; FeatureDescriptors Descriptors[65536];
} SeparatedFeatures; } SeparatedFeatures;
#endif //DISCIMAGECHEF_DEVICE_REPORT_MMC_REPORT_H #endif //DISCIMAGECHEF_DEVICE_REPORT_MMC_REPORT_H

399
DiscImageChef.Device.Report/scsi.c
View File

@@ -8,13 +8,13 @@
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <errno.h> #include <errno.h>
#include <string.h> #include <string.h>
#include <stdint.h>
#include "scsi.h" #include "scsi.h"
#define FALSE 0 #define FALSE 0
#define TRUE 1 #define TRUE 1
int SendScsiCommand(int fd, void *cdb, unsigned char cdb_len, unsigned char *buffer, unsigned int buffer_len, unsigned char **senseBuffer, int direction) int SendScsiCommand(int fd, void *cdb, unsigned char cdb_len, unsigned char *buffer, unsigned int buffer_len,
unsigned char **senseBuffer, int direction)
{ {
if(buffer == NULL || cdb == NULL) if(buffer == NULL || cdb == NULL)
return -1; return -1;
@@ -25,15 +25,15 @@ int SendScsiCommand(int fd, void *cdb, unsigned char cdb_len, unsigned char *buf
sg_io_hdr_t io_hdr; sg_io_hdr_t io_hdr;
memset(&io_hdr, 0, sizeof(sg_io_hdr_t)); memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
io_hdr.interface_id = 'S'; io_hdr.interface_id = 'S';
io_hdr.cmd_len = cdb_len; io_hdr.cmd_len = cdb_len;
io_hdr.mx_sb_len = 32; io_hdr.mx_sb_len = 32;
io_hdr.dxfer_direction = direction; io_hdr.dxfer_direction = direction;
io_hdr.dxfer_len = buffer_len; io_hdr.dxfer_len = buffer_len;
io_hdr.dxferp = buffer; io_hdr.dxferp = buffer;
io_hdr.cmdp = cdb; io_hdr.cmdp = cdb;
io_hdr.sbp = *senseBuffer; io_hdr.sbp = *senseBuffer;
io_hdr.timeout = 10000; io_hdr.timeout = 10000;
int error = ioctl(fd, SG_IO, &io_hdr); int error = ioctl(fd, SG_IO, &io_hdr);
@@ -86,7 +86,7 @@ int AllowMediumRemoval(int fd, unsigned char **senseBuffer)
int PreventAllowMediumRemoval(int fd, unsigned char **senseBuffer, int persistent, int prevent) int PreventAllowMediumRemoval(int fd, unsigned char **senseBuffer, int persistent, int prevent)
{ {
unsigned char cmd_len = 6; unsigned char cmd_len = 6;
char cdb[] = {SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL, 0, 0, 0, 0, 0}; char cdb[] = {SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL, 0, 0, 0, 0, 0};
unsigned char *buffer = malloc(0); unsigned char *buffer = malloc(0);
if(prevent) if(prevent)
@@ -111,18 +111,19 @@ int EjectTray(int fd, unsigned char **senseBuffer)
int StartUnit(int fd, unsigned char **senseBuffer) int StartUnit(int fd, unsigned char **senseBuffer)
{ {
return StartStopUnit(fd, senseBuffer, FALSE, 0, 0, FALSE, FALSE, TRUE); return StartStopUnit(fd, senseBuffer, FALSE, 0, 0, FALSE, FALSE, TRUE);
} }
int StopUnit(int fd, unsigned char **senseBuffer) int StopUnit(int fd, unsigned char **senseBuffer)
{ {
return StartStopUnit(fd, senseBuffer, FALSE, 0, 0, FALSE, FALSE, FALSE); return StartStopUnit(fd, senseBuffer, FALSE, 0, 0, FALSE, FALSE, FALSE);
} }
int StartStopUnit(int fd, unsigned char **senseBuffer, int immediate, uint8_t formatLayer, uint8_t powerConditions, int changeFormatLayer, int loadEject, int start) int StartStopUnit(int fd, unsigned char **senseBuffer, int immediate, uint8_t formatLayer, uint8_t powerConditions,
int changeFormatLayer, int loadEject, int start)
{ {
unsigned char cmd_len = 6; unsigned char cmd_len = 6;
char cdb[] = {SCSI_START_STOP_UNIT, 0, 0, 0, 0, 0}; char cdb[] = {SCSI_START_STOP_UNIT, 0, 0, 0, 0, 0};
unsigned char *buffer = malloc(0); unsigned char *buffer = malloc(0);
if(immediate) if(immediate)
@@ -159,7 +160,7 @@ int SpcAllowMediumRemoval(int fd, unsigned char **senseBuffer)
int SpcPreventAllowMediumRemoval(int fd, unsigned char **senseBuffer, uint8_t preventMode) int SpcPreventAllowMediumRemoval(int fd, unsigned char **senseBuffer, uint8_t preventMode)
{ {
unsigned char cmd_len = 6; unsigned char cmd_len = 6;
char cdb[] = {SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL, 0, 0, 0, 0, 0}; char cdb[] = {SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL, 0, 0, 0, 0, 0};
unsigned char *buffer = malloc(0); unsigned char *buffer = malloc(0);
cdb[4] = (preventMode & 0x03); cdb[4] = (preventMode & 0x03);
@@ -170,18 +171,18 @@ int SpcPreventAllowMediumRemoval(int fd, unsigned char **senseBuffer, uint8_t pr
int Load(int fd, unsigned char **senseBuffer) int Load(int fd, unsigned char **senseBuffer)
{ {
return LoadUnload(fd, senseBuffer, FALSE, TRUE, FALSE, FALSE, FALSE); return LoadUnload(fd, senseBuffer, FALSE, TRUE, FALSE, FALSE, FALSE);
} }
int Unload(int fd, unsigned char **senseBuffer) int Unload(int fd, unsigned char **senseBuffer)
{ {
return LoadUnload(fd, senseBuffer, FALSE, FALSE, FALSE, FALSE, FALSE); return LoadUnload(fd, senseBuffer, FALSE, FALSE, FALSE, FALSE, FALSE);
} }
int LoadUnload(int fd, unsigned char **senseBuffer, int immediate, int load, int retense, int endOfTape, int hold) int LoadUnload(int fd, unsigned char **senseBuffer, int immediate, int load, int retense, int endOfTape, int hold)
{ {
unsigned char cmd_len = 6; unsigned char cmd_len = 6;
char cdb[] = {SCSI_LOAD_UNLOAD, 0, 0, 0, 0, 0}; char cdb[] = {SCSI_LOAD_UNLOAD, 0, 0, 0, 0, 0};
unsigned char *buffer = malloc(0); unsigned char *buffer = malloc(0);
if(immediate) if(immediate)
cdb[1] = 0x01; cdb[1] = 0x01;
@@ -199,10 +200,12 @@ int LoadUnload(int fd, unsigned char **senseBuffer, int immediate, int load, int
return error; return error;
} }
int ModeSense6(int fd, unsigned char **buffer, unsigned char **senseBuffer, int DBD, uint8_t pageControl, uint8_t pageCode, uint8_t subPageCode) int
ModeSense6(int fd, unsigned char **buffer, unsigned char **senseBuffer, int DBD, uint8_t pageControl, uint8_t pageCode,
uint8_t subPageCode)
{ {
unsigned char cmd_len = 6; unsigned char cmd_len = 6;
unsigned int buffer_len = 255; unsigned int buffer_len = 255;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
@@ -211,8 +214,8 @@ int ModeSense6(int fd, unsigned char **buffer, unsigned char **senseBuffer, int
cdb[1] |= 0x08; cdb[1] |= 0x08;
cdb[2] |= pageControl; cdb[2] |= pageControl;
cdb[2] |= (pageCode & 0x3F); cdb[2] |= (pageCode & 0x3F);
cdb[3] = subPageCode; cdb[3] = subPageCode;
cdb[4] = (uint8_t)(buffer_len & 0xFF); cdb[4] = (uint8_t)(buffer_len & 0xFF);
int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV); int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV);
@@ -231,10 +234,11 @@ int ModeSense6(int fd, unsigned char **buffer, unsigned char **senseBuffer, int
return error; return error;
} }
int ModeSense10(int fd, unsigned char **buffer, unsigned char **senseBuffer, int LLBAA, int DBD, uint8_t pageControl, uint8_t pageCode, uint8_t subPageCode) int ModeSense10(int fd, unsigned char **buffer, unsigned char **senseBuffer, int LLBAA, int DBD, uint8_t pageControl,
uint8_t pageCode, uint8_t subPageCode)
{ {
unsigned char cmd_len = 10; unsigned char cmd_len = 10;
unsigned int buffer_len = 4096; unsigned int buffer_len = 4096;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
@@ -245,10 +249,10 @@ int ModeSense10(int fd, unsigned char **buffer, unsigned char **senseBuffer, int
cdb[1] |= 0x08; cdb[1] |= 0x08;
cdb[2] |= pageControl; cdb[2] |= pageControl;
cdb[2] |= (pageCode & 0x3F); cdb[2] |= (pageCode & 0x3F);
cdb[3] = subPageCode; cdb[3] = subPageCode;
cdb[7] = (uint8_t)((buffer_len & 0xFF00) >> 8); cdb[7] = (uint8_t)((buffer_len & 0xFF00) >> 8);
cdb[8] = (uint8_t)(buffer_len & 0xFF); cdb[8] = (uint8_t)(buffer_len & 0xFF);
cdb[9] = 0; cdb[9] = 0;
int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV); int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV);
@@ -270,8 +274,8 @@ int ModeSense10(int fd, unsigned char **buffer, unsigned char **senseBuffer, int
int ReadCapacity(int fd, unsigned char **buffer, unsigned char **senseBuffer, int RelAddr, uint32_t address, int PMI) int ReadCapacity(int fd, unsigned char **buffer, unsigned char **senseBuffer, int RelAddr, uint32_t address, int PMI)
{ {
unsigned char cmd_len = 10; unsigned char cmd_len = 10;
unsigned int buffer_len = 8; unsigned int buffer_len = 8;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
@@ -279,7 +283,7 @@ int ReadCapacity(int fd, unsigned char **buffer, unsigned char **senseBuffer, in
if(PMI) if(PMI)
{ {
cdb[8] = 0x01; cdb[8] = 0x01;
if(RelAddr) if(RelAddr)
cdb[1] = 0x01; cdb[1] = 0x01;
@@ -296,8 +300,8 @@ int ReadCapacity(int fd, unsigned char **buffer, unsigned char **senseBuffer, in
int ReadCapacity16(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint64_t address, int PMI) int ReadCapacity16(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint64_t address, int PMI)
{ {
unsigned char cmd_len = 16; unsigned char cmd_len = 16;
unsigned int buffer_len = 32; unsigned int buffer_len = 32;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
@@ -306,14 +310,14 @@ int ReadCapacity16(int fd, unsigned char **buffer, unsigned char **senseBuffer,
if(PMI) if(PMI)
{ {
cdb[14] = 0x01; cdb[14] = 0x01;
cdb[2] = (uint8_t)((address & 0xFF00000000000000ULL) >> 56); cdb[2] = (uint8_t)((address & 0xFF00000000000000ULL) >> 56);
cdb[3] = (uint8_t)((address & 0xFF000000000000ULL) >> 48); cdb[3] = (uint8_t)((address & 0xFF000000000000ULL) >> 48);
cdb[4] = (uint8_t)((address & 0xFF0000000000ULL) >> 40); cdb[4] = (uint8_t)((address & 0xFF0000000000ULL) >> 40);
cdb[5] = (uint8_t)((address & 0xFF00000000ULL) >> 32); cdb[5] = (uint8_t)((address & 0xFF00000000ULL) >> 32);
cdb[6] = (uint8_t)((address & 0xFF000000ULL) >> 24); cdb[6] = (uint8_t)((address & 0xFF000000ULL) >> 24);
cdb[7] = (uint8_t)((address & 0xFF0000ULL) >> 16); cdb[7] = (uint8_t)((address & 0xFF0000ULL) >> 16);
cdb[8] = (uint8_t)((address & 0xFF00ULL) >> 8); cdb[8] = (uint8_t)((address & 0xFF00ULL) >> 8);
cdb[9] = (uint8_t)(address & 0xFFULL); cdb[9] = (uint8_t)(address & 0xFFULL);
} }
cdb[10] = (uint8_t)((buffer_len & 0xFF000000) >> 24); cdb[10] = (uint8_t)((buffer_len & 0xFF000000) >> 24);
@@ -326,10 +330,11 @@ int ReadCapacity16(int fd, unsigned char **buffer, unsigned char **senseBuffer,
return error; return error;
} }
int Read6(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize, uint8_t transferLength) int Read6(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize,
uint8_t transferLength)
{ {
unsigned char cmd_len = 6; unsigned char cmd_len = 6;
unsigned int buflen = transferLength == 0 ? 256 * blockSize : transferLength * blockSize; unsigned int buflen = transferLength == 0 ? 256 * blockSize : transferLength * blockSize;
*buffer = malloc(buflen); *buffer = malloc(buflen);
memset(*buffer, 0, buflen); memset(*buffer, 0, buflen);
@@ -345,10 +350,11 @@ int Read6(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t
return error; return error;
} }
int Read10(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t rdprotect, int dpo, int fua, int fuaNv, int relAddr, uint32_t lba, uint32_t blockSize, uint8_t groupNumber, uint16_t transferLength) int Read10(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t rdprotect, int dpo, int fua, int fuaNv,
int relAddr, uint32_t lba, uint32_t blockSize, uint8_t groupNumber, uint16_t transferLength)
{ {
unsigned char cmd_len = 10; unsigned char cmd_len = 10;
unsigned int buflen = transferLength * blockSize; unsigned int buflen = transferLength * blockSize;
*buffer = malloc(buflen); *buffer = malloc(buflen);
memset(*buffer, 0, buflen); memset(*buffer, 0, buflen);
@@ -376,16 +382,17 @@ int Read10(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t
return error; return error;
} }
int Read12(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t rdprotect, int dpo, int fua, int fuaNv, int relAddr, uint32_t lba, uint32_t blockSize, uint8_t groupNumber, uint32_t transferLength, int streaming) int Read12(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t rdprotect, int dpo, int fua, int fuaNv,
int relAddr, uint32_t lba, uint32_t blockSize, uint8_t groupNumber, uint32_t transferLength, int streaming)
{ {
unsigned char cmd_len = 12; unsigned char cmd_len = 12;
unsigned int buflen = transferLength * blockSize; unsigned int buflen = transferLength * blockSize;
*buffer = malloc(buflen); *buffer = malloc(buflen);
memset(*buffer, 0, buflen); memset(*buffer, 0, buflen);
unsigned char cdb[] = {SCSI_READ_12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; unsigned char cdb[] = {SCSI_READ_12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cdb[1] = (uint8_t)((rdprotect & 0x07) << 5); cdb[1] = (uint8_t)((rdprotect & 0x07) << 5);
if(dpo) if(dpo)
cdb[1] += 0x10; cdb[1] += 0x10;
if(fua) if(fua)
@@ -394,14 +401,14 @@ int Read12(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t
cdb[1] += 0x02; cdb[1] += 0x02;
if(relAddr) if(relAddr)
cdb[1] += 0x01; cdb[1] += 0x01;
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24); cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16); cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8); cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF); cdb[5] = (uint8_t)(lba & 0xFF);
cdb[6] = (uint8_t)((transferLength & 0xFF000000) >> 24); cdb[6] = (uint8_t)((transferLength & 0xFF000000) >> 24);
cdb[7] = (uint8_t)((transferLength & 0xFF0000) >> 16); cdb[7] = (uint8_t)((transferLength & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((transferLength & 0xFF00) >> 8); cdb[8] = (uint8_t)((transferLength & 0xFF00) >> 8);
cdb[9] = (uint8_t)(transferLength & 0xFF); cdb[9] = (uint8_t)(transferLength & 0xFF);
cdb[10] = (uint8_t)(groupNumber & 0x1F); cdb[10] = (uint8_t)(groupNumber & 0x1F);
if(streaming) if(streaming)
cdb[10] += 0x80; cdb[10] += 0x80;
@@ -411,30 +418,31 @@ int Read12(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t
return error; return error;
} }
int Read16(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t rdprotect, int dpo, int fua, int fuaNv, uint64_t lba, uint32_t blockSize, uint8_t groupNumber, uint32_t transferLength, int streaming) int Read16(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t rdprotect, int dpo, int fua, int fuaNv,
uint64_t lba, uint32_t blockSize, uint8_t groupNumber, uint32_t transferLength, int streaming)
{ {
unsigned char cmd_len = 16; unsigned char cmd_len = 16;
unsigned int buflen = transferLength * blockSize; unsigned int buflen = transferLength * blockSize;
*buffer = malloc(buflen); *buffer = malloc(buflen);
memset(*buffer, 0, buflen); memset(*buffer, 0, buflen);
unsigned char cdb[] = {SCSI_READ_16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; unsigned char cdb[] = {SCSI_READ_16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cdb[1] = (uint8_t)((rdprotect & 0x07) << 5); cdb[1] = (uint8_t)((rdprotect & 0x07) << 5);
if(dpo) if(dpo)
cdb[1] += 0x10; cdb[1] += 0x10;
if(fua) if(fua)
cdb[1] += 0x08; cdb[1] += 0x08;
if(fuaNv) if(fuaNv)
cdb[1] += 0x02; cdb[1] += 0x02;
cdb[2] = (uint8_t)((lba & 0xFF00000000000000ULL) >> 56); cdb[2] = (uint8_t)((lba & 0xFF00000000000000ULL) >> 56);
cdb[3] = (uint8_t)((lba & 0xFF000000000000ULL) >> 48); cdb[3] = (uint8_t)((lba & 0xFF000000000000ULL) >> 48);
cdb[4] = (uint8_t)((lba & 0xFF0000000000ULL) >> 40); cdb[4] = (uint8_t)((lba & 0xFF0000000000ULL) >> 40);
cdb[5] = (uint8_t)((lba & 0xFF00000000ULL) >> 32); cdb[5] = (uint8_t)((lba & 0xFF00000000ULL) >> 32);
cdb[6] = (uint8_t)((lba & 0xFF000000ULL) >> 24); cdb[6] = (uint8_t)((lba & 0xFF000000ULL) >> 24);
cdb[7] = (uint8_t)((lba & 0xFF0000ULL) >> 16); cdb[7] = (uint8_t)((lba & 0xFF0000ULL) >> 16);
cdb[8] = (uint8_t)((lba & 0xFF00ULL) >> 8); cdb[8] = (uint8_t)((lba & 0xFF00ULL) >> 8);
cdb[9] = (uint8_t)(lba & 0xFFULL); cdb[9] = (uint8_t)(lba & 0xFFULL);
cdb[10] = (uint8_t)((transferLength & 0xFF000000) >> 24); cdb[10] = (uint8_t)((transferLength & 0xFF000000) >> 24);
cdb[11] = (uint8_t)((transferLength & 0xFF0000) >> 16); cdb[11] = (uint8_t)((transferLength & 0xFF0000) >> 16);
cdb[12] = (uint8_t)((transferLength & 0xFF00) >> 8); cdb[12] = (uint8_t)((transferLength & 0xFF00) >> 8);
@@ -448,7 +456,8 @@ int Read16(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t
return error; return error;
} }
int ReadLong10(int fd, unsigned char **buffer, unsigned char **senseBuffer, int correct, int relAddr, uint32_t lba, uint16_t transferBytes) int ReadLong10(int fd, unsigned char **buffer, unsigned char **senseBuffer, int correct, int relAddr, uint32_t lba,
uint16_t transferBytes)
{ {
unsigned char cmd_len = 10; unsigned char cmd_len = 10;
*buffer = malloc(transferBytes); *buffer = malloc(transferBytes);
@@ -460,19 +469,20 @@ int ReadLong10(int fd, unsigned char **buffer, unsigned char **senseBuffer, int
cdb[1] += 0x02; cdb[1] += 0x02;
if(relAddr) if(relAddr)
cdb[1] += 0x01; cdb[1] += 0x01;
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24); cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16); cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8); cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF); cdb[5] = (uint8_t)(lba & 0xFF);
cdb[7] = (uint8_t)((transferBytes & 0xFF00) >> 8); cdb[7] = (uint8_t)((transferBytes & 0xFF00) >> 8);
cdb[8] = (uint8_t)(transferBytes & 0xFF); cdb[8] = (uint8_t)(transferBytes & 0xFF);
int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, transferBytes, senseBuffer, SG_DXFER_FROM_DEV); int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, transferBytes, senseBuffer, SG_DXFER_FROM_DEV);
return error; return error;
} }
int ReadLong16(int fd, unsigned char **buffer, unsigned char **senseBuffer, int correct, uint64_t lba, uint32_t transferBytes) int ReadLong16(int fd, unsigned char **buffer, unsigned char **senseBuffer, int correct, uint64_t lba,
uint32_t transferBytes)
{ {
unsigned char cmd_len = 16; unsigned char cmd_len = 16;
*buffer = malloc(transferBytes); *buffer = malloc(transferBytes);
@@ -480,14 +490,14 @@ int ReadLong16(int fd, unsigned char **buffer, unsigned char **senseBuffer, int
unsigned char cdb[] = {SCSI_SERVICE_ACTION_IN, SCSI_READ_LONG_16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; unsigned char cdb[] = {SCSI_SERVICE_ACTION_IN, SCSI_READ_LONG_16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cdb[2] = (uint8_t)((lba & 0xFF00000000000000ULL) >> 56); cdb[2] = (uint8_t)((lba & 0xFF00000000000000ULL) >> 56);
cdb[3] = (uint8_t)((lba & 0xFF000000000000ULL) >> 48); cdb[3] = (uint8_t)((lba & 0xFF000000000000ULL) >> 48);
cdb[4] = (uint8_t)((lba & 0xFF0000000000ULL) >> 40); cdb[4] = (uint8_t)((lba & 0xFF0000000000ULL) >> 40);
cdb[5] = (uint8_t)((lba & 0xFF00000000ULL) >> 32); cdb[5] = (uint8_t)((lba & 0xFF00000000ULL) >> 32);
cdb[6] = (uint8_t)((lba & 0xFF000000ULL) >> 24); cdb[6] = (uint8_t)((lba & 0xFF000000ULL) >> 24);
cdb[7] = (uint8_t)((lba & 0xFF0000ULL) >> 16); cdb[7] = (uint8_t)((lba & 0xFF0000ULL) >> 16);
cdb[8] = (uint8_t)((lba & 0xFF00ULL) >> 8); cdb[8] = (uint8_t)((lba & 0xFF00ULL) >> 8);
cdb[9] = (uint8_t)(lba & 0xFFULL); cdb[9] = (uint8_t)(lba & 0xFFULL);
cdb[12] = (uint8_t)((transferBytes & 0xFF00) >> 8); cdb[12] = (uint8_t)((transferBytes & 0xFF00) >> 8);
cdb[13] = (uint8_t)(transferBytes & 0xFF); cdb[13] = (uint8_t)(transferBytes & 0xFF);
if(correct) if(correct)
@@ -501,7 +511,7 @@ int ReadLong16(int fd, unsigned char **buffer, unsigned char **senseBuffer, int
int Seek6(int fd, unsigned char **senseBuffer, uint32_t lba) int Seek6(int fd, unsigned char **senseBuffer, uint32_t lba)
{ {
unsigned char cmd_len = 6; unsigned char cmd_len = 6;
char cdb[] = {SCSI_SEEK, 0, 0, 0, 0, 0}; char cdb[] = {SCSI_SEEK, 0, 0, 0, 0, 0};
unsigned char *buffer = malloc(0); unsigned char *buffer = malloc(0);
cdb[1] = (uint8_t)((lba & 0x1F0000) >> 16); cdb[1] = (uint8_t)((lba & 0x1F0000) >> 16);
@@ -516,7 +526,7 @@ int Seek6(int fd, unsigned char **senseBuffer, uint32_t lba)
int Seek10(int fd, unsigned char **senseBuffer, uint32_t lba) int Seek10(int fd, unsigned char **senseBuffer, uint32_t lba)
{ {
unsigned char cmd_len = 10; unsigned char cmd_len = 10;
char cdb[] = {SCSI_SEEK_10, 0, 0, 0, 0, 0, 0, 0, 0, 0}; char cdb[] = {SCSI_SEEK_10, 0, 0, 0, 0, 0, 0, 0, 0, 0};
unsigned char *buffer = malloc(0); unsigned char *buffer = malloc(0);
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24); cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
@@ -532,7 +542,7 @@ int Seek10(int fd, unsigned char **senseBuffer, uint32_t lba)
int TestUnitReady(int fd, unsigned char **senseBuffer) int TestUnitReady(int fd, unsigned char **senseBuffer)
{ {
unsigned char cmd_len = 6; unsigned char cmd_len = 6;
char cdb[] = {SCSI_TEST_UNIT_READY, 0, 0, 0, 0, 0}; char cdb[] = {SCSI_TEST_UNIT_READY, 0, 0, 0, 0, 0};
unsigned char *buffer = malloc(0); unsigned char *buffer = malloc(0);
int error = SendScsiCommand(fd, &cdb, cmd_len, buffer, 0, senseBuffer, SG_DXFER_NONE); int error = SendScsiCommand(fd, &cdb, cmd_len, buffer, 0, senseBuffer, SG_DXFER_NONE);
@@ -540,10 +550,11 @@ int TestUnitReady(int fd, unsigned char **senseBuffer)
return error; return error;
} }
int GetConfiguration(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint16_t startingFeatureNumber, uint8_t RT) int GetConfiguration(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint16_t startingFeatureNumber,
uint8_t RT)
{ {
unsigned char cmd_len = 10; unsigned char cmd_len = 10;
uint16_t buffer_len = 8; uint16_t buffer_len = 8;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
char cdb[] = {MMC_GET_CONFIGURATION, 0, 0, 0, 0, 0, 0, 0, 0, 0}; char cdb[] = {MMC_GET_CONFIGURATION, 0, 0, 0, 0, 0, 0, 0, 0, 0};
@@ -573,11 +584,12 @@ int GetConfiguration(int fd, unsigned char **buffer, unsigned char **senseBuffer
return error; return error;
} }
int ReadTocPmaAtip(int fd, unsigned char **buffer, unsigned char **senseBuffer, int MSF, uint8_t format, uint8_t trackSessionNumber) int ReadTocPmaAtip(int fd, unsigned char **buffer, unsigned char **senseBuffer, int MSF, uint8_t format,
uint8_t trackSessionNumber)
{ {
unsigned char cmd_len = 10; unsigned char cmd_len = 10;
uint16_t buffer_len = 1024; uint16_t buffer_len = 1024;
char cdb[] = {MMC_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 0, 0}; char cdb[] = {MMC_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 0, 0};
if((format & 0xF) == 5) if((format & 0xF) == 5)
buffer_len = 32768; buffer_len = 32768;
@@ -587,10 +599,10 @@ int ReadTocPmaAtip(int fd, unsigned char **buffer, unsigned char **senseBuffer,
if(MSF) if(MSF)
cdb[1] = 0x02; cdb[1] = 0x02;
cdb[2] = (uint8_t)(format & 0x0F); cdb[2] = (uint8_t)(format & 0x0F);
cdb[6] = trackSessionNumber; cdb[6] = trackSessionNumber;
cdb[7] = (uint8_t)((buffer_len & 0xFF00) >> 8); cdb[7] = (uint8_t)((buffer_len & 0xFF00) >> 8);
cdb[8] = (uint8_t)(buffer_len & 0xFF); cdb[8] = (uint8_t)(buffer_len & 0xFF);
int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV); int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV);
@@ -610,23 +622,24 @@ int ReadTocPmaAtip(int fd, unsigned char **buffer, unsigned char **senseBuffer,
return error; return error;
} }
int ReadDiscStructure(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t mediaType, uint32_t address, uint8_t layerNumber, uint8_t format, uint8_t AGID) int ReadDiscStructure(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t mediaType, uint32_t address,
uint8_t layerNumber, uint8_t format, uint8_t AGID)
{ {
unsigned char cmd_len = 12; unsigned char cmd_len = 12;
uint16_t buffer_len = 8; uint16_t buffer_len = 8;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
char cdb[] = {MMC_READ_DISC_STRUCTURE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; char cdb[] = {MMC_READ_DISC_STRUCTURE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cdb[1] = (uint8_t)((uint8_t)mediaType & 0x0F); cdb[1] = (uint8_t)((uint8_t)mediaType & 0x0F);
cdb[2] = (uint8_t)((address & 0xFF000000) >> 24); cdb[2] = (uint8_t)((address & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((address & 0xFF0000) >> 16); cdb[3] = (uint8_t)((address & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((address & 0xFF00) >> 8); cdb[4] = (uint8_t)((address & 0xFF00) >> 8);
cdb[5] = (uint8_t)(address & 0xFF); cdb[5] = (uint8_t)(address & 0xFF);
cdb[6] = layerNumber; cdb[6] = layerNumber;
cdb[7] = (uint8_t)format; cdb[7] = (uint8_t)format;
cdb[8] = (uint8_t)((buffer_len & 0xFF00) >> 8); cdb[8] = (uint8_t)((buffer_len & 0xFF00) >> 8);
cdb[9] = (uint8_t)(buffer_len & 0xFF); cdb[9] = (uint8_t)(buffer_len & 0xFF);
cdb[10] = (uint8_t)((AGID & 0x03) << 6); cdb[10] = (uint8_t)((AGID & 0x03) << 6);
int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV); int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV);
@@ -647,28 +660,29 @@ int ReadDiscStructure(int fd, unsigned char **buffer, unsigned char **senseBuffe
return error; return error;
} }
int ReadCd(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize, uint32_t transferLength, uint8_t expectedSectorType, int ReadCd(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize,
int DAP, int relAddr, int sync, uint8_t headerCodes, int userData, int edcEcc, uint8_t C2Error, uint8_t subchannel) uint32_t transferLength, uint8_t expectedSectorType, int DAP, int relAddr, int sync, uint8_t headerCodes,
int userData, int edcEcc, uint8_t C2Error, uint8_t subchannel)
{ {
unsigned char cmd_len = 12; unsigned char cmd_len = 12;
uint32_t buffer_len = transferLength * blockSize; uint32_t buffer_len = transferLength * blockSize;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
char cdb[] = {MMC_READ_CD, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; char cdb[] = {MMC_READ_CD, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cdb[1] = (uint8_t)((uint8_t)expectedSectorType << 2); cdb[1] = (uint8_t)((uint8_t)expectedSectorType << 2);
if(DAP) if(DAP)
cdb[1] += 0x02; cdb[1] += 0x02;
if(relAddr) if(relAddr)
cdb[1] += 0x01; cdb[1] += 0x01;
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24); cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16); cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8); cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF); cdb[5] = (uint8_t)(lba & 0xFF);
cdb[6] = (uint8_t)((transferLength & 0xFF0000) >> 16); cdb[6] = (uint8_t)((transferLength & 0xFF0000) >> 16);
cdb[7] = (uint8_t)((transferLength & 0xFF00) >> 8); cdb[7] = (uint8_t)((transferLength & 0xFF00) >> 8);
cdb[8] = (uint8_t)(transferLength & 0xFF); cdb[8] = (uint8_t)(transferLength & 0xFF);
cdb[9] = (uint8_t)((uint8_t)C2Error << 1); cdb[9] = (uint8_t)((uint8_t)C2Error << 1);
cdb[9] += (uint8_t)((uint8_t)headerCodes << 5); cdb[9] += (uint8_t)((uint8_t)headerCodes << 5);
if(sync) if(sync)
cdb[9] += 0x80; cdb[9] += 0x80;
@@ -683,22 +697,23 @@ int DAP, int relAddr, int sync, uint8_t headerCodes, int userData, int edcEcc, u
return error; return error;
} }
int ReadCdMsf(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t startMsf, uint32_t endMsf, uint32_t blockSize, uint8_t expectedSectorType, int ReadCdMsf(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t startMsf, uint32_t endMsf,
int DAP, int sync, uint8_t headerCodes, int userData, int edcEcc, uint8_t C2Error, uint8_t subchannel) uint32_t blockSize, uint8_t expectedSectorType, int DAP, int sync, uint8_t headerCodes, int userData,
int edcEcc, uint8_t C2Error, uint8_t subchannel)
{ {
unsigned char cmd_len = 12; unsigned char cmd_len = 12;
char cdb[] = {MMC_READ_CD_MSF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; char cdb[] = {MMC_READ_CD_MSF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cdb[1] = (uint8_t)((uint8_t)expectedSectorType << 2); cdb[1] = (uint8_t)((uint8_t)expectedSectorType << 2);
if(DAP) if(DAP)
cdb[1] += 0x02; cdb[1] += 0x02;
cdb[3] = (uint8_t)((startMsf & 0xFF0000) >> 16); cdb[3] = (uint8_t)((startMsf & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((startMsf & 0xFF00) >> 8); cdb[4] = (uint8_t)((startMsf & 0xFF00) >> 8);
cdb[5] = (uint8_t)(startMsf & 0xFF); cdb[5] = (uint8_t)(startMsf & 0xFF);
cdb[6] = (uint8_t)((endMsf & 0xFF0000) >> 16); cdb[6] = (uint8_t)((endMsf & 0xFF0000) >> 16);
cdb[7] = (uint8_t)((endMsf & 0xFF00) >> 8); cdb[7] = (uint8_t)((endMsf & 0xFF00) >> 8);
cdb[8] = (uint8_t)(endMsf & 0xFF); cdb[8] = (uint8_t)(endMsf & 0xFF);
cdb[9] = (uint8_t)((uint8_t)C2Error << 1); cdb[9] = (uint8_t)((uint8_t)C2Error << 1);
cdb[9] += (uint8_t)((uint8_t)headerCodes << 5); cdb[9] += (uint8_t)((uint8_t)headerCodes << 5);
if(sync) if(sync)
cdb[9] += 0x80; cdb[9] += 0x80;
@@ -708,8 +723,8 @@ int DAP, int sync, uint8_t headerCodes, int userData, int edcEcc, uint8_t C2Erro
cdb[9] += 0x08; cdb[9] += 0x08;
cdb[10] = (uint8_t)subchannel; cdb[10] = (uint8_t)subchannel;
uint32_t transferLength = (uint32_t)((cdb[6] - cdb[3]) * 60 * 75 + (cdb[7] - cdb[4]) * 75 + (cdb[8] - cdb[5])); uint32_t transferLength = (uint32_t)((cdb[6] - cdb[3]) * 60 * 75 + (cdb[7] - cdb[4]) * 75 + (cdb[8] - cdb[5]));
uint32_t buffer_len = transferLength * blockSize; uint32_t buffer_len = transferLength * blockSize;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
@@ -718,22 +733,23 @@ int DAP, int sync, uint8_t headerCodes, int userData, int edcEcc, uint8_t C2Erro
return error; return error;
} }
int PlextorReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize, uint32_t transferLength, uint8_t subchannel) int PlextorReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize,
uint32_t transferLength, uint8_t subchannel)
{ {
unsigned char cmd_len = 12; unsigned char cmd_len = 12;
uint32_t buffer_len = transferLength * blockSize; uint32_t buffer_len = transferLength * blockSize;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
char cdb[] = {PIONEER_READ_CDDA, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; char cdb[] = {PIONEER_READ_CDDA, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24); cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16); cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8); cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF); cdb[5] = (uint8_t)(lba & 0xFF);
cdb[6] = (uint8_t)((transferLength & 0xFF000000) >> 24); cdb[6] = (uint8_t)((transferLength & 0xFF000000) >> 24);
cdb[7] = (uint8_t)((transferLength & 0xFF0000) >> 16); cdb[7] = (uint8_t)((transferLength & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((transferLength & 0xFF00) >> 8); cdb[8] = (uint8_t)((transferLength & 0xFF00) >> 8);
cdb[9] = (uint8_t)(transferLength & 0xFF); cdb[9] = (uint8_t)(transferLength & 0xFF);
cdb[10] = (uint8_t)subchannel; cdb[10] = (uint8_t)subchannel;
int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV); int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV);
@@ -741,10 +757,11 @@ int PlextorReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer,
return error; return error;
} }
int PlextorReadRawDvd(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t transferLength) int
PlextorReadRawDvd(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t transferLength)
{ {
unsigned char cmd_len = 10; unsigned char cmd_len = 10;
uint32_t buffer_len = transferLength * 2064; uint32_t buffer_len = transferLength * 2064;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
char cdb[] = {SCSI_READ_BUFFER, 0, 0, 0, 0, 0, 0, 0, 0, 0}; char cdb[] = {SCSI_READ_BUFFER, 0, 0, 0, 0, 0, 0, 0, 0, 0};
@@ -762,21 +779,22 @@ int PlextorReadRawDvd(int fd, unsigned char **buffer, unsigned char **senseBuffe
return error; return error;
} }
int PioneerReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize, uint32_t transferLength, uint8_t subchannel) int PioneerReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize,
uint32_t transferLength, uint8_t subchannel)
{ {
unsigned char cmd_len = 12; unsigned char cmd_len = 12;
uint32_t buffer_len = transferLength * blockSize; uint32_t buffer_len = transferLength * blockSize;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
char cdb[] = {PIONEER_READ_CDDA, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; char cdb[] = {PIONEER_READ_CDDA, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24); cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16); cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8); cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF); cdb[5] = (uint8_t)(lba & 0xFF);
cdb[7] = (uint8_t)((transferLength & 0xFF0000) >> 16); cdb[7] = (uint8_t)((transferLength & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((transferLength & 0xFF00) >> 8); cdb[8] = (uint8_t)((transferLength & 0xFF00) >> 8);
cdb[9] = (uint8_t)(transferLength & 0xFF); cdb[9] = (uint8_t)(transferLength & 0xFF);
cdb[10] = (uint8_t)subchannel; cdb[10] = (uint8_t)subchannel;
int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV); int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV);
@@ -784,21 +802,22 @@ int PioneerReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer,
return error; return error;
} }
int PioneerReadCdDaMsf(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t startMsf, uint32_t endMsf, uint32_t blockSize, uint8_t subchannel) int PioneerReadCdDaMsf(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t startMsf, uint32_t endMsf,
uint32_t blockSize, uint8_t subchannel)
{ {
unsigned char cmd_len = 12; unsigned char cmd_len = 12;
char cdb[] = {PIONEER_READ_CDDA_MSF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; char cdb[] = {PIONEER_READ_CDDA_MSF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cdb[3] = (uint8_t)((startMsf & 0xFF0000) >> 16); cdb[3] = (uint8_t)((startMsf & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((startMsf & 0xFF00) >> 8); cdb[4] = (uint8_t)((startMsf & 0xFF00) >> 8);
cdb[5] = (uint8_t)(startMsf & 0xFF); cdb[5] = (uint8_t)(startMsf & 0xFF);
cdb[7] = (uint8_t)((endMsf & 0xFF0000) >> 16); cdb[7] = (uint8_t)((endMsf & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((endMsf & 0xFF00) >> 8); cdb[8] = (uint8_t)((endMsf & 0xFF00) >> 8);
cdb[9] = (uint8_t)(endMsf & 0xFF); cdb[9] = (uint8_t)(endMsf & 0xFF);
cdb[10] = (uint8_t)subchannel; cdb[10] = (uint8_t)subchannel;
uint32_t transferLength = (uint)((cdb[7] - cdb[3]) * 60 * 75 + (cdb[8] - cdb[4]) * 75 + (cdb[9] - cdb[5])); uint32_t transferLength = (uint)((cdb[7] - cdb[3]) * 60 * 75 + (cdb[8] - cdb[4]) * 75 + (cdb[9] - cdb[5]));
uint32_t buffer_len = transferLength * blockSize; uint32_t buffer_len = transferLength * blockSize;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
@@ -809,8 +828,8 @@ int PioneerReadCdDaMsf(int fd, unsigned char **buffer, unsigned char **senseBuff
int NecReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t transferLength) int NecReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t transferLength)
{ {
unsigned char cmd_len = 12; unsigned char cmd_len = 12;
uint32_t buffer_len = transferLength * 2352; uint32_t buffer_len = transferLength * 2352;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
char cdb[] = {NEC_READ_CDDA, 0, 0, 0, 0, 0, 0, 0, 0, 0}; char cdb[] = {NEC_READ_CDDA, 0, 0, 0, 0, 0, 0, 0, 0, 0};
@@ -829,16 +848,16 @@ int NecReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer, uin
int HlDtStReadRawDvd(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t transferLength) int HlDtStReadRawDvd(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t transferLength)
{ {
unsigned char cmd_len = 12; unsigned char cmd_len = 12;
uint32_t buffer_len = transferLength * 2064; uint32_t buffer_len = transferLength * 2064;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
char cdb[] = {HLDTST_VENDOR, 0x48, 0x49, 0x54, 0x01, 0, 0, 0, 0, 0, 0, 0}; char cdb[] = {HLDTST_VENDOR, 0x48, 0x49, 0x54, 0x01, 0, 0, 0, 0, 0, 0, 0};
cdb[6] = (uint8_t)((lba & 0xFF000000) >> 24); cdb[6] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[7] = (uint8_t)((lba & 0xFF0000) >> 16); cdb[7] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((lba & 0xFF00) >> 8); cdb[8] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[9] = (uint8_t)(lba & 0xFF); cdb[9] = (uint8_t)(lba & 0xFF);
cdb[10] = (uint8_t)((buffer_len & 0xFF00) >> 8); cdb[10] = (uint8_t)((buffer_len & 0xFF00) >> 8);
cdb[11] = (uint8_t)(buffer_len & 0xFF); cdb[11] = (uint8_t)(buffer_len & 0xFF);
@@ -849,8 +868,8 @@ int HlDtStReadRawDvd(int fd, unsigned char **buffer, unsigned char **senseBuffer
int ReadBlockLimits(int fd, unsigned char **buffer, unsigned char **senseBuffer) int ReadBlockLimits(int fd, unsigned char **buffer, unsigned char **senseBuffer)
{ {
unsigned char cmd_len = 6; unsigned char cmd_len = 6;
unsigned int buffer_len = 6; unsigned int buffer_len = 6;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
@@ -863,8 +882,8 @@ int ReadBlockLimits(int fd, unsigned char **buffer, unsigned char **senseBuffer)
int ReportDensitySupport(int fd, unsigned char **buffer, unsigned char **senseBuffer, int mediumType, int currentMedia) int ReportDensitySupport(int fd, unsigned char **buffer, unsigned char **senseBuffer, int mediumType, int currentMedia)
{ {
unsigned char cmd_len = 10; unsigned char cmd_len = 10;
unsigned int buffer_len = 256; unsigned int buffer_len = 256;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
@@ -873,8 +892,8 @@ int ReportDensitySupport(int fd, unsigned char **buffer, unsigned char **senseBu
cdb[1] |= 0x01; cdb[1] |= 0x01;
if(mediumType) if(mediumType)
cdb[1] |= 0x02; cdb[1] |= 0x02;
cdb[7] = (uint8_t)((buffer_len & 0xFF00) >> 8); cdb[7] = (uint8_t)((buffer_len & 0xFF00) >> 8);
cdb[8] = (uint8_t)(buffer_len & 0xFF); cdb[8] = (uint8_t)(buffer_len & 0xFF);
int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV); int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, buffer_len, senseBuffer, SG_DXFER_FROM_DEV);
@@ -897,8 +916,8 @@ int ReportDensitySupport(int fd, unsigned char **buffer, unsigned char **senseBu
int ReadMediaSerialNumber(int fd, unsigned char **buffer, unsigned char **senseBuffer) int ReadMediaSerialNumber(int fd, unsigned char **buffer, unsigned char **senseBuffer)
{ {
unsigned char cmd_len = 12; unsigned char cmd_len = 12;
unsigned int buffer_len = 256; unsigned int buffer_len = 256;
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len); memset(*buffer, 0, buffer_len);
@@ -913,7 +932,9 @@ int ReadMediaSerialNumber(int fd, unsigned char **buffer, unsigned char **senseB
if(error) if(error)
return error; return error;
buffer_len = (unsigned int)((*(*buffer + 0) << 24) + (*(*buffer + 1) << 16)) + (*(*buffer + 2) << 8) + *(*buffer + 3) + 4; buffer_len =
(unsigned int)((*(*buffer + 0) << 24) + (*(*buffer + 1) << 16)) + (*(*buffer + 2) << 8) + *(*buffer + 3) +
4;
free(*buffer); free(*buffer);
*buffer = malloc(buffer_len); *buffer = malloc(buffer_len);

433
DiscImageChef.Device.Report/scsi.h
View File

@@ -5,104 +5,162 @@
#ifndef DISCIMAGECHEF_DEVICE_REPORT_SCSI_H #ifndef DISCIMAGECHEF_DEVICE_REPORT_SCSI_H
#define DISCIMAGECHEF_DEVICE_REPORT_SCSI_H #define DISCIMAGECHEF_DEVICE_REPORT_SCSI_H
#include <stdint.h> int SendScsiCommand(int fd, void *cdb, unsigned char cdb_len, unsigned char *buffer, unsigned int buffer_len,
unsigned char **senseBuffer, int direction);
int SendScsiCommand(int fd, void *cdb, unsigned char cdb_len, unsigned char *buffer, unsigned int buffer_len, unsigned char **senseBuffer, int direction);
int Inquiry(int fd, unsigned char **buffer, unsigned char **senseBuffer); int Inquiry(int fd, unsigned char **buffer, unsigned char **senseBuffer);
int PreventMediumRemoval(int fd, unsigned char **senseBuffer); int PreventMediumRemoval(int fd, unsigned char **senseBuffer);
int AllowMediumRemoval(int fd, unsigned char **senseBuffer); int AllowMediumRemoval(int fd, unsigned char **senseBuffer);
int PreventAllowMediumRemoval(int fd, unsigned char **senseBuffer, int persistent, int prevent); int PreventAllowMediumRemoval(int fd, unsigned char **senseBuffer, int persistent, int prevent);
int LoadTray(int fd, unsigned char **senseBuffer); int LoadTray(int fd, unsigned char **senseBuffer);
int EjectTray(int fd, unsigned char **senseBuffer); int EjectTray(int fd, unsigned char **senseBuffer);
int StartUnit(int fd, unsigned char **senseBuffer); int StartUnit(int fd, unsigned char **senseBuffer);
int StopUnit(int fd, unsigned char **senseBuffer); int StopUnit(int fd, unsigned char **senseBuffer);
int StartStopUnit(int fd, unsigned char **senseBuffer, int immediate, uint8_t formatLayer, uint8_t powerConditions, int changeFormatLayer, int loadEject, int start);
int StartStopUnit(int fd, unsigned char **senseBuffer, int immediate, uint8_t formatLayer, uint8_t powerConditions,
int changeFormatLayer, int loadEject, int start);
int SpcPreventMediumRemoval(int fd, unsigned char **senseBuffer); int SpcPreventMediumRemoval(int fd, unsigned char **senseBuffer);
int SpcAllowMediumRemoval(int fd, unsigned char **senseBuffer); int SpcAllowMediumRemoval(int fd, unsigned char **senseBuffer);
int SpcPreventAllowMediumRemoval(int fd, unsigned char **senseBuffer, uint8_t preventMode); int SpcPreventAllowMediumRemoval(int fd, unsigned char **senseBuffer, uint8_t preventMode);
int Load(int fd, unsigned char **senseBuffer); int Load(int fd, unsigned char **senseBuffer);
int Unload(int fd, unsigned char **senseBuffer); int Unload(int fd, unsigned char **senseBuffer);
int LoadUnload(int fd, unsigned char **senseBuffer, int immediate, int load, int retense, int endOfTape, int hold); int LoadUnload(int fd, unsigned char **senseBuffer, int immediate, int load, int retense, int endOfTape, int hold);
int ModeSense6(int fd, unsigned char **buffer, unsigned char **senseBuffer, int DBD, uint8_t pageControl, uint8_t pageCode, uint8_t subPageCode);
int ModeSense10(int fd, unsigned char **buffer, unsigned char **senseBuffer, int LLBAA, int DBD, uint8_t pageContorl, uint8_t pageCode, uint8_t subPageCode); int
ModeSense6(int fd, unsigned char **buffer, unsigned char **senseBuffer, int DBD, uint8_t pageControl, uint8_t pageCode,
uint8_t subPageCode);
int ModeSense10(int fd, unsigned char **buffer, unsigned char **senseBuffer, int LLBAA, int DBD, uint8_t pageContorl,
uint8_t pageCode, uint8_t subPageCode);
int ReadCapacity(int fd, unsigned char **buffer, unsigned char **senseBuffer, int RelAddr, uint32_t address, int PMI); int ReadCapacity(int fd, unsigned char **buffer, unsigned char **senseBuffer, int RelAddr, uint32_t address, int PMI);
int ReadCapacity16(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint64_t address, int PMI); int ReadCapacity16(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint64_t address, int PMI);
int Read6(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize, uint8_t transferLength);
int Read10(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t rdprotect, int dpo, int fua, int fuaNv, int relAddr, uint32_t lba, uint32_t blockSize, uint8_t groupNumber, uint16_t transferLength); int Read6(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize,
int Read12(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t rdprotect, int dpo, int fua, int fuaNv, int relAddr, uint32_t lba, uint32_t blockSize, uint8_t groupNumber, uint32_t transferLength, int streaming); uint8_t transferLength);
int Read16(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t rdprotect, int dpo, int fua, int fuaNv, uint64_t lba, uint32_t blockSize, uint8_t groupNumber, uint32_t transferLength, int streaming);
int ReadLong10(int fd, unsigned char **buffer, unsigned char **senseBuffer, int correct, int relAddr, uint32_t lba, uint16_t transferBytes); int Read10(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t rdprotect, int dpo, int fua, int fuaNv,
int ReadLong16(int fd, unsigned char **buffer, unsigned char **senseBuffer, int correct, uint64_t lba, uint32_t transferBytes); int relAddr, uint32_t lba, uint32_t blockSize, uint8_t groupNumber, uint16_t transferLength);
int Read12(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t rdprotect, int dpo, int fua, int fuaNv,
int relAddr, uint32_t lba, uint32_t blockSize, uint8_t groupNumber, uint32_t transferLength, int streaming);
int Read16(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t rdprotect, int dpo, int fua, int fuaNv,
uint64_t lba, uint32_t blockSize, uint8_t groupNumber, uint32_t transferLength, int streaming);
int ReadLong10(int fd, unsigned char **buffer, unsigned char **senseBuffer, int correct, int relAddr, uint32_t lba,
uint16_t transferBytes);
int ReadLong16(int fd, unsigned char **buffer, unsigned char **senseBuffer, int correct, uint64_t lba,
uint32_t transferBytes);
int Seek6(int fd, unsigned char **senseBuffer, uint32_t lba); int Seek6(int fd, unsigned char **senseBuffer, uint32_t lba);
int Seek10(int fd, unsigned char **senseBuffer, uint32_t lba); int Seek10(int fd, unsigned char **senseBuffer, uint32_t lba);
int TestUnitReady(int fd, unsigned char **senseBuffer); int TestUnitReady(int fd, unsigned char **senseBuffer);
int GetConfiguration(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint16_t startingFeatureNumber, uint8_t RT);
int ReadTocPmaAtip(int fd, unsigned char **buffer, unsigned char **senseBuffer, int MSF, uint8_t format, uint8_t trackSessionNumber); int GetConfiguration(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint16_t startingFeatureNumber,
int ReadDiscStructure(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t mediaType, uint32_t address, uint8_t layerNumber, uint8_t format, uint8_t AGID); uint8_t RT);
int ReadCd(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize, uint32_t transferLength, uint8_t expectedSectorType, int DAP, int relAddr, int sync, uint8_t headerCodes, int userData, int edcEcc, uint8_t C2Error, uint8_t subchannel);
int ReadCdMsf(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t startMsf, uint32_t endMsf, uint32_t blockSize, uint8_t expectedSectorType, int DAP, int sync, uint8_t headerCodes, int userData, int edcEcc, uint8_t C2Error, uint8_t subchannel); int ReadTocPmaAtip(int fd, unsigned char **buffer, unsigned char **senseBuffer, int MSF, uint8_t format,
int PlextorReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize, uint32_t transferLength, uint8_t subchannel); uint8_t trackSessionNumber);
int PlextorReadRawDvd(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t transferLength);
int PioneerReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize, uint32_t transferLength, uint8_t subchannel); int ReadDiscStructure(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t mediaType, uint32_t address,
int PioneerReadCdDaMsf(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t startMsf, uint32_t endMsf, uint32_t blockSize, uint8_t subchannel); uint8_t layerNumber, uint8_t format, uint8_t AGID);
int ReadCd(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize,
uint32_t transferLength, uint8_t expectedSectorType, int DAP, int relAddr, int sync, uint8_t headerCodes,
int userData, int edcEcc, uint8_t C2Error, uint8_t subchannel);
int ReadCdMsf(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t startMsf, uint32_t endMsf,
uint32_t blockSize, uint8_t expectedSectorType, int DAP, int sync, uint8_t headerCodes, int userData,
int edcEcc, uint8_t C2Error, uint8_t subchannel);
int PlextorReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize,
uint32_t transferLength, uint8_t subchannel);
int
PlextorReadRawDvd(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t transferLength);
int PioneerReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t blockSize,
uint32_t transferLength, uint8_t subchannel);
int PioneerReadCdDaMsf(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t startMsf, uint32_t endMsf,
uint32_t blockSize, uint8_t subchannel);
int NecReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t transferLength); int NecReadCdDa(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t transferLength);
int HlDtStReadRawDvd(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t transferLength);
int
HlDtStReadRawDvd(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t lba, uint32_t transferLength);
int ReadBlockLimits(int fd, unsigned char **buffer, unsigned char **senseBuffer); int ReadBlockLimits(int fd, unsigned char **buffer, unsigned char **senseBuffer);
int ReportDensitySupport(int fd, unsigned char **buffer, unsigned char **senseBuffer, int mediumType, int currentMedia); int ReportDensitySupport(int fd, unsigned char **buffer, unsigned char **senseBuffer, int mediumType, int currentMedia);
int ReadMediaSerialNumber(int fd, unsigned char **buffer, unsigned char **senseBuffer); int ReadMediaSerialNumber(int fd, unsigned char **buffer, unsigned char **senseBuffer);
typedef enum typedef enum
{ {
SCSI_TEST_UNIT_READY = 0x00, SCSI_TEST_UNIT_READY = 0x00,
SCSI_READ_BLOCK_LIMITS = 0x05, SCSI_READ_BLOCK_LIMITS = 0x05,
SCSI_READ = 0x08, SCSI_READ = 0x08,
SCSI_SEEK = 0x0B, SCSI_SEEK = 0x0B,
SCSI_INQUIRY = 0x12, SCSI_INQUIRY = 0x12,
SCSI_START_STOP_UNIT = 0x1B, SCSI_START_STOP_UNIT = 0x1B,
SCSI_LOAD_UNLOAD = SCSI_START_STOP_UNIT, SCSI_LOAD_UNLOAD = SCSI_START_STOP_UNIT,
SCSI_MODE_SENSE = 0x1A, SCSI_MODE_SENSE = 0x1A,
SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL = 0x1E, SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL = 0x1E,
SCSI_READ_CAPACITY = 0x25, SCSI_READ_CAPACITY = 0x25,
SCSI_READ_10 = 0x28, SCSI_READ_10 = 0x28,
SCSI_READ_LONG = 0x3E, SCSI_READ_LONG = 0x3E,
SCSI_SEEK_10 = 0x2B, SCSI_SEEK_10 = 0x2B,
SCSI_READ_BUFFER = 0x3C, SCSI_READ_BUFFER = 0x3C,
MMC_READ_TOC_PMA_ATIP = 0x43, MMC_READ_TOC_PMA_ATIP = 0x43,
SCSI_REPORT_DENSITY_SUPPORT = 0x44, SCSI_REPORT_DENSITY_SUPPORT = 0x44,
MMC_GET_CONFIGURATION = 0x46, MMC_GET_CONFIGURATION = 0x46,
SCSI_MODE_SENSE_10 = 0x5A, SCSI_MODE_SENSE_10 = 0x5A,
SCSI_ATA_PASSTHROUGH_16 = 0x85, SCSI_ATA_PASSTHROUGH_16 = 0x85,
SCSI_READ_16 = 0x88, SCSI_READ_16 = 0x88,
SCSI_SERVICE_ACTION_IN = 0x9E, SCSI_SERVICE_ACTION_IN = 0x9E,
SCSI_READ_12 = 0xA8, SCSI_READ_12 = 0xA8,
SCSI_READ_MEDIA_SERIAL = 0xAB, SCSI_READ_MEDIA_SERIAL = 0xAB,
MMC_READ_DISC_STRUCTURE = 0xAD, MMC_READ_DISC_STRUCTURE = 0xAD,
MMC_READ_CD_MSF = 0xB9, MMC_READ_CD_MSF = 0xB9,
MMC_READ_CD = 0xBE, MMC_READ_CD = 0xBE,
NEC_READ_CDDA = 0xD4, NEC_READ_CDDA = 0xD4,
PIONEER_READ_CDDA = 0xD8, PIONEER_READ_CDDA = 0xD8,
PIONEER_READ_CDDA_MSF = 0xD9, PIONEER_READ_CDDA_MSF = 0xD9,
HLDTST_VENDOR = 0xE7, HLDTST_VENDOR = 0xE7,
} ScsiCommands; } ScsiCommands;
typedef enum typedef enum
{ {
MODE_PAGE_CURRENT = 0x00, MODE_PAGE_CURRENT = 0x00, MODE_PAGE_CHANGEABLE = 0x40, MODE_PAGE_DEFAULT = 0x80, MODE_PAGE_SAVED = 0xC0
MODE_PAGE_CHANGEABLE = 0x40,
MODE_PAGE_DEFAULT = 0x80,
MODE_PAGE_SAVED = 0xC0
} ScsiModeSensePageControl; } ScsiModeSensePageControl;
typedef enum typedef enum
{ {
SCSI_READ_CAPACITY_16 = 0x10, SCSI_READ_CAPACITY_16 = 0x10, SCSI_READ_LONG_16 = 0x11,
SCSI_READ_LONG_16 = 0x11,
} ScsiServiceActionIn; } ScsiServiceActionIn;
typedef enum typedef enum
{ {
DISC_STRUCTURE_DVD = 0x00, DISC_STRUCTURE_DVD = 0x00, DISC_STRUCTURE_BD = 0x01,
DISC_STRUCTURE_BD = 0x01,
} MmcDiscStructureMediaType; } MmcDiscStructureMediaType;
// TODO: Stylize this // TODO: Stylize this
@@ -113,236 +171,183 @@ typedef enum
/// <summary> /// <summary>
/// AACS Volume Identifier /// AACS Volume Identifier
/// </summary> /// </summary>
DISC_STRUCTURE_AACSVolId = 0x80, DISC_STRUCTURE_AACSVolId = 0x80, /// <summary>
/// <summary>
/// AACS Pre-recorded Media Serial Number /// AACS Pre-recorded Media Serial Number
/// </summary> /// </summary>
DISC_STRUCTURE_AACSMediaSerial = 0x81, DISC_STRUCTURE_AACSMediaSerial = 0x81, /// <summary>
/// <summary>
/// AACS Media Identifier /// AACS Media Identifier
/// </summary> /// </summary>
DISC_STRUCTURE_AACSMediaId = 0x82, DISC_STRUCTURE_AACSMediaId = 0x82, /// <summary>
/// <summary>
/// AACS Lead-in Media Key Block /// AACS Lead-in Media Key Block
/// </summary> /// </summary>
DISC_STRUCTURE_AACSMKB = 0x83, DISC_STRUCTURE_AACSMKB = 0x83, /// <summary>
/// <summary>
/// AACS Data Keys /// AACS Data Keys
/// </summary> /// </summary>
DISC_STRUCTURE_AACSDataKeys = 0x84, DISC_STRUCTURE_AACSDataKeys = 0x84, /// <summary>
/// <summary>
/// AACS LBA extents /// AACS LBA extents
/// </summary> /// </summary>
DISC_STRUCTURE_AACSLBAExtents = 0x85, DISC_STRUCTURE_AACSLBAExtents = 0x85, /// <summary>
/// <summary>
/// CPRM Media Key Block specified by AACS /// CPRM Media Key Block specified by AACS
/// </summary> /// </summary>
DISC_STRUCTURE_AACSMKBCPRM = 0x86, DISC_STRUCTURE_AACSMKBCPRM = 0x86, /// <summary>
/// <summary>
/// Recognized format layers /// Recognized format layers
/// </summary> /// </summary>
DISC_STRUCTURE_RecognizedFormatLayers = 0x90, DISC_STRUCTURE_RecognizedFormatLayers = 0x90, /// <summary>
/// <summary>
/// Write protection status /// Write protection status
/// </summary> /// </summary>
DISC_STRUCTURE_WriteProtectionStatus = 0xC0, DISC_STRUCTURE_WriteProtectionStatus = 0xC0, /// <summary>
/// <summary>
/// READ/SEND DISC STRUCTURE capability list /// READ/SEND DISC STRUCTURE capability list
/// </summary> /// </summary>
DISC_STRUCTURE_CapabilityList = 0xFF, DISC_STRUCTURE_CapabilityList = 0xFF,
// DVD Disc Structures // DVD Disc Structures
/// <summary> /// <summary>
/// DVD Lead-in Physical Information /// DVD Lead-in Physical Information
/// </summary> /// </summary>
DISC_STRUCTURE_PhysicalInformation = 0x00, DISC_STRUCTURE_PhysicalInformation = 0x00, /// <summary>
/// <summary>
/// DVD Lead-in Copyright Information /// DVD Lead-in Copyright Information
/// </summary> /// </summary>
DISC_STRUCTURE_CopyrightInformation = 0x01, DISC_STRUCTURE_CopyrightInformation = 0x01, /// <summary>
/// <summary>
/// CSS/CPPM Disc key /// CSS/CPPM Disc key
/// </summary> /// </summary>
DISC_STRUCTURE_DiscKey = 0x02, DISC_STRUCTURE_DiscKey = 0x02, /// <summary>
/// <summary>
/// DVD Burst Cutting Area /// DVD Burst Cutting Area
/// </summary> /// </summary>
DISC_STRUCTURE_BurstCuttingArea = 0x03, DISC_STRUCTURE_BurstCuttingArea = 0x03, /// <summary>
/// <summary>
/// DVD Lead-in Disc Manufacturing Information /// DVD Lead-in Disc Manufacturing Information
/// </summary> /// </summary>
DISC_STRUCTURE_DiscManufacturingInformation = 0x04, DISC_STRUCTURE_DiscManufacturingInformation = 0x04, /// <summary>
/// <summary>
/// DVD Copyright Information from specified sector /// DVD Copyright Information from specified sector
/// </summary> /// </summary>
DISC_STRUCTURE_SectorCopyrightInformation = 0x05, DISC_STRUCTURE_SectorCopyrightInformation = 0x05, /// <summary>
/// <summary>
/// CSS/CPPM Media Identifier /// CSS/CPPM Media Identifier
/// </summary> /// </summary>
DISC_STRUCTURE_MediaIdentifier = 0x06, DISC_STRUCTURE_MediaIdentifier = 0x06, /// <summary>
/// <summary>
/// CSS/CPPM Media Key Block /// CSS/CPPM Media Key Block
/// </summary> /// </summary>
DISC_STRUCTURE_MediaKeyBlock = 0x07, DISC_STRUCTURE_MediaKeyBlock = 0x07, /// <summary>
/// <summary>
/// DDS from DVD-RAM /// DDS from DVD-RAM
/// </summary> /// </summary>
DISC_STRUCTURE_DVDRAM_DDS = 0x08, DISC_STRUCTURE_DVDRAM_DDS = 0x08, /// <summary>
/// <summary>
/// DVD-RAM Medium Status /// DVD-RAM Medium Status
/// </summary> /// </summary>
DISC_STRUCTURE_DVDRAM_MediumStatus = 0x09, DISC_STRUCTURE_DVDRAM_MediumStatus = 0x09, /// <summary>
/// <summary>
/// DVD-RAM Spare Area Information /// DVD-RAM Spare Area Information
/// </summary> /// </summary>
DISC_STRUCTURE_DVDRAM_SpareAreaInformation = 0x0A, DISC_STRUCTURE_DVDRAM_SpareAreaInformation = 0x0A, /// <summary>
/// <summary>
/// DVD-RAM Recording Type Information /// DVD-RAM Recording Type Information
/// </summary> /// </summary>
DISC_STRUCTURE_DVDRAM_RecordingType = 0x0B, DISC_STRUCTURE_DVDRAM_RecordingType = 0x0B, /// <summary>
/// <summary>
/// DVD-R/-RW RMD in last Border-out /// DVD-R/-RW RMD in last Border-out
/// </summary> /// </summary>
DISC_STRUCTURE_LastBorderOutRMD = 0x0C, DISC_STRUCTURE_LastBorderOutRMD = 0x0C, /// <summary>
/// <summary>
/// Specified RMD from last recorded Border-out /// Specified RMD from last recorded Border-out
/// </summary> /// </summary>
DISC_STRUCTURE_SpecifiedRMD = 0x0D, DISC_STRUCTURE_SpecifiedRMD = 0x0D, /// <summary>
/// <summary>
/// DVD-R/-RW Lead-in pre-recorded information /// DVD-R/-RW Lead-in pre-recorded information
/// </summary> /// </summary>
DISC_STRUCTURE_PreRecordedInfo = 0x0E, DISC_STRUCTURE_PreRecordedInfo = 0x0E, /// <summary>
/// <summary>
/// DVD-R/-RW Media Identifier /// DVD-R/-RW Media Identifier
/// </summary> /// </summary>
DISC_STRUCTURE_DVDR_MediaIdentifier = 0x0F, DISC_STRUCTURE_DVDR_MediaIdentifier = 0x0F, /// <summary>
/// <summary>
/// DVD-R/-RW Physical Format Information /// DVD-R/-RW Physical Format Information
/// </summary> /// </summary>
DISC_STRUCTURE_DVDR_PhysicalInformation = 0x10, DISC_STRUCTURE_DVDR_PhysicalInformation = 0x10, /// <summary>
/// <summary>
/// ADIP /// ADIP
/// </summary> /// </summary>
DISC_STRUCTURE_ADIP = 0x11, DISC_STRUCTURE_ADIP = 0x11, /// <summary>
/// <summary>
/// HD DVD Lead-in Copyright Protection Information /// HD DVD Lead-in Copyright Protection Information
/// </summary> /// </summary>
DISC_STRUCTURE_HDDVD_CopyrightInformation = 0x12, DISC_STRUCTURE_HDDVD_CopyrightInformation = 0x12, /// <summary>
/// <summary>
/// AACS Lead-in Copyright Data Section /// AACS Lead-in Copyright Data Section
/// </summary> /// </summary>
DISC_STRUCTURE_DVD_AACS = 0x15, DISC_STRUCTURE_DVD_AACS = 0x15, /// <summary>
/// <summary>
/// HD DVD-R Medium Status /// HD DVD-R Medium Status
/// </summary> /// </summary>
DISC_STRUCTURE_HDDVDR_MediumStatus = 0x19, DISC_STRUCTURE_HDDVDR_MediumStatus = 0x19, /// <summary>
/// <summary>
/// HD DVD-R Last recorded RMD in the latest RMZ /// HD DVD-R Last recorded RMD in the latest RMZ
/// </summary> /// </summary>
DISC_STRUCTURE_HDDVDR_LastRMD = 0x1A, DISC_STRUCTURE_HDDVDR_LastRMD = 0x1A, /// <summary>
/// <summary>
/// DVD+/-R DL and DVD-Download DL layer capacity /// DVD+/-R DL and DVD-Download DL layer capacity
/// </summary> /// </summary>
DISC_STRUCTURE_DVDR_LayerCapacity = 0x20, DISC_STRUCTURE_DVDR_LayerCapacity = 0x20, /// <summary>
/// <summary>
/// DVD-R DL Middle Zone start address /// DVD-R DL Middle Zone start address
/// </summary> /// </summary>
DISC_STRUCTURE_MiddleZoneStart = 0x21, DISC_STRUCTURE_MiddleZoneStart = 0x21, /// <summary>
/// <summary>
/// DVD-R DL Jump Interval Size /// DVD-R DL Jump Interval Size
/// </summary> /// </summary>
DISC_STRUCTURE_JumpIntervalSize = 0x22, DISC_STRUCTURE_JumpIntervalSize = 0x22, /// <summary>
/// <summary>
/// DVD-R DL Start LBA of the manual layer jump /// DVD-R DL Start LBA of the manual layer jump
/// </summary> /// </summary>
DISC_STRUCTURE_ManualLayerJumpStartLBA = 0x23, DISC_STRUCTURE_ManualLayerJumpStartLBA = 0x23, /// <summary>
/// <summary>
/// DVD-R DL Remapping information of the specified Anchor Point /// DVD-R DL Remapping information of the specified Anchor Point
/// </summary> /// </summary>
DISC_STRUCTURE_RemapAnchorPoint = 0x24, DISC_STRUCTURE_RemapAnchorPoint = 0x24, /// <summary>
/// <summary>
/// Disc Control Block /// Disc Control Block
/// </summary> /// </summary>
DISC_STRUCTURE_DCB = 0x30, DISC_STRUCTURE_DCB = 0x30,
// BD Disc Structures // BD Disc Structures
/// <summary> /// <summary>
/// Blu-ray Disc Information /// Blu-ray Disc Information
/// </summary> /// </summary>
DISC_STRUCTURE_DiscInformation = 0x00, DISC_STRUCTURE_DiscInformation = 0x00, /// <summary>
/// <summary>
/// Blu-ray Burst Cutting Area /// Blu-ray Burst Cutting Area
/// </summary> /// </summary>
DISC_STRUCTURE_BD_BurstCuttingArea = 0x03, DISC_STRUCTURE_BD_BurstCuttingArea = 0x03, /// <summary>
/// <summary>
/// Blu-ray DDS /// Blu-ray DDS
/// </summary> /// </summary>
DISC_STRUCTURE_BD_DDS = 0x08, DISC_STRUCTURE_BD_DDS = 0x08, /// <summary>
/// <summary>
/// Blu-ray Cartridge Status /// Blu-ray Cartridge Status
/// </summary> /// </summary>
DISC_STRUCTURE_CartridgeStatus = 0x09, DISC_STRUCTURE_CartridgeStatus = 0x09, /// <summary>
/// <summary>
/// Blu-ray Spare Area Information /// Blu-ray Spare Area Information
/// </summary> /// </summary>
DISC_STRUCTURE_BD_SpareAreaInformation = 0x0A, DISC_STRUCTURE_BD_SpareAreaInformation = 0x0A, /// <summary>
/// <summary>
/// Unmodified DFL /// Unmodified DFL
/// </summary> /// </summary>
DISC_STRUCTURE_RawDFL = 0x12, DISC_STRUCTURE_RawDFL = 0x12, /// <summary>
/// <summary>
/// Physical Access Control /// Physical Access Control
/// </summary> /// </summary>
DISC_STRUCTURE_PAC = 0x30 DISC_STRUCTURE_PAC = 0x30
} MmcDiscStructureFormat; } MmcDiscStructureFormat;
typedef enum typedef enum
{ {
MMC_SECTOR_ALL = 0, MMC_SECTOR_ALL = 0,
MMC_SECTOR_CDDA = 1, MMC_SECTOR_CDDA = 1,
MMC_SECTOR_MODE1 = 2, MMC_SECTOR_MODE1 = 2,
MMC_SECTOR_MODE2 = 3, MMC_SECTOR_MODE2 = 3,
MMC_SECTOR_MODE2F1 = 4, MMC_SECTOR_MODE2F1 = 4,
MMC_SECTOR_MODE2F2 = 5 MMC_SECTOR_MODE2F2 = 5
} MmcSectorTypes; } MmcSectorTypes;
typedef enum typedef enum
{ {
MMC_HEADER_NONE = 0, MMC_HEADER_NONE = 0, MMC_HEADER_ONLY = 1, MMC_SUBHEADER_ONLY = 2, MMC_HEADER_ALL = 3
MMC_HEADER_ONLY = 1,
MMC_SUBHEADER_ONLY = 2,
MMC_HEADER_ALL = 3
} MmcHeaderCodes; } MmcHeaderCodes;
typedef enum typedef enum
{ {
MMC_ERROR_NONE = 0, MMC_ERROR_NONE = 0, MMC_ERROR_C2 = 1, MMC_ERROR_C2_AND_BLOCK = 2
MMC_ERROR_C2 = 1,
MMC_ERROR_C2_AND_BLOCK = 2
} MmcErrorField; } MmcErrorField;
typedef enum typedef enum
{ {
MMC_SUBCHANNEL_NONE = 0, MMC_SUBCHANNEL_NONE = 0, MMC_SUBCHANNEL_RAW = 1, MMC_SUBCHANNEL_Q16 = 2, MMC_SUBCHANNEL_RW = 4
MMC_SUBCHANNEL_RAW = 1,
MMC_SUBCHANNEL_Q16 = 2,
MMC_SUBCHANNEL_RW = 4
} MmcSubchannel; } MmcSubchannel;
typedef enum typedef enum
{ {
PIONEER_SUBCHANNEL_NONE = 0, PIONEER_SUBCHANNEL_NONE = 0, PIONEER_SUBCHANNEL_Q16 = 1, PIONEER_SUBCHANNEL_ALL = 2, PIONEER_SUBCHANNEL_ONLY = 3
PIONEER_SUBCHANNEL_Q16 = 1,
PIONEER_SUBCHANNEL_ALL = 2,
PIONEER_SUBCHANNEL_ONLY = 3
} PioneerSubchannel; } PioneerSubchannel;
typedef enum typedef enum
{ {
PLEXTOR_SUBCHANNEL_NONE = 0, PLEXTOR_SUBCHANNEL_NONE = 0,
PLEXTOR_SUBCHANNEL_Q16 = 1, PLEXTOR_SUBCHANNEL_Q16 = 1,
PLEXTOR_SUBCHANNEL_PACK = 2, PLEXTOR_SUBCHANNEL_PACK = 2,
PLEXTOR_SUBCHANNEL_ALL = 3, PLEXTOR_SUBCHANNEL_ALL = 3,
PLEXTOR_SUBCHANNEL_RAW_C2 = 8 PLEXTOR_SUBCHANNEL_RAW_C2 = 8
} PlextorSubchannel; } PlextorSubchannel;
@@ -354,221 +359,221 @@ typedef struct
/// Peripheral device type /// Peripheral device type
/// Byte 0, bits 4 to 0 /// Byte 0, bits 4 to 0
/// </summary> /// </summary>
uint8_t PeripheralDeviceType : 5; uint8_t PeripheralDeviceType : 5;
/// <summary> /// <summary>
/// Peripheral qualifier /// Peripheral qualifier
/// Byte 0, bits 7 to 5 /// Byte 0, bits 7 to 5
/// </summary> /// </summary>
uint8_t PeripheralQualifier : 3; uint8_t PeripheralQualifier : 3;
/// <summary> /// <summary>
/// SCSI-1 vendor-specific qualification codes /// SCSI-1 vendor-specific qualification codes
/// Byte 1, bits 6 to 0 /// Byte 1, bits 6 to 0
/// </summary> /// </summary>
uint8_t DeviceTypeModifier : 7; uint8_t DeviceTypeModifier : 7;
/// <summary> /// <summary>
/// Removable device /// Removable device
/// Byte 1, bit 7 /// Byte 1, bit 7
/// </summary> /// </summary>
uint8_t RMB : 1; uint8_t RMB : 1;
/// <summary> /// <summary>
/// ANSI SCSI Standard Version /// ANSI SCSI Standard Version
/// Byte 2, bits 2 to 0, mask = 0x07 /// Byte 2, bits 2 to 0, mask = 0x07
/// </summary> /// </summary>
uint8_t ANSIVersion : 3; uint8_t ANSIVersion : 3;
/// <summary> /// <summary>
/// ECMA SCSI Standard Version /// ECMA SCSI Standard Version
/// Byte 2, bits 5 to 3, mask = 0x38, >> 3 /// Byte 2, bits 5 to 3, mask = 0x38, >> 3
/// </summary> /// </summary>
uint8_t ECMAVersion : 3; uint8_t ECMAVersion : 3;
/// <summary> /// <summary>
/// ISO/IEC SCSI Standard Version /// ISO/IEC SCSI Standard Version
/// Byte 2, bits 7 to 6, mask = 0xC0, >> 6 /// Byte 2, bits 7 to 6, mask = 0xC0, >> 6
/// </summary> /// </summary>
uint8_t ISOVersion : 2; uint8_t ISOVersion : 2;
/// <summary> /// <summary>
/// Responde data format /// Responde data format
/// Byte 3, bit 3 to 0 /// Byte 3, bit 3 to 0
/// </summary> /// </summary>
uint8_t ResponseDataFormat : 4; uint8_t ResponseDataFormat : 4;
/// <summary> /// <summary>
/// Supports LUN hierarchical addressing /// Supports LUN hierarchical addressing
/// Byte 3, bit 4 /// Byte 3, bit 4
/// </summary> /// </summary>
uint8_t HiSup : 1; uint8_t HiSup : 1;
/// <summary> /// <summary>
/// Supports setting Normal ACA /// Supports setting Normal ACA
/// Byte 3, bit 5 /// Byte 3, bit 5
/// </summary> /// </summary>
uint8_t NormACA : 1; uint8_t NormACA : 1;
/// <summary> /// <summary>
/// Device supports TERMINATE TASK command /// Device supports TERMINATE TASK command
/// Byte 3, bit 6 /// Byte 3, bit 6
/// </summary> /// </summary>
uint8_t TrmTsk : 1; uint8_t TrmTsk : 1;
/// <summary> /// <summary>
/// Asynchronous Event Reporting Capability supported /// Asynchronous Event Reporting Capability supported
/// Byte 3, bit 7 /// Byte 3, bit 7
/// </summary> /// </summary>
uint8_t AERC : 1; uint8_t AERC : 1;
/// <summary> /// <summary>
/// Lenght of total INQUIRY response minus 4 /// Lenght of total INQUIRY response minus 4
/// Byte 4 /// Byte 4
/// </summary> /// </summary>
uint8_t AdditionalLength; uint8_t AdditionalLength;
/// <summary> /// <summary>
/// Supports protection information /// Supports protection information
/// Byte 5, bit 0 /// Byte 5, bit 0
/// </summary> /// </summary>
uint8_t Protect : 1; uint8_t Protect : 1;
/// <summary> /// <summary>
/// Reserved /// Reserved
/// Byte 5, bits 2 to 1 /// Byte 5, bits 2 to 1
/// </summary> /// </summary>
uint8_t Reserved2 : 2; uint8_t Reserved2 : 2;
/// <summary> /// <summary>
/// Supports third-party copy commands /// Supports third-party copy commands
/// Byte 5, bit 3 /// Byte 5, bit 3
/// </summary> /// </summary>
uint8_t ThreePC : 1; uint8_t ThreePC : 1;
/// <summary> /// <summary>
/// Supports asymetrical logical unit access /// Supports asymetrical logical unit access
/// Byte 5, bits 5 to 4 /// Byte 5, bits 5 to 4
/// </summary> /// </summary>
uint8_t TPGS : 2; uint8_t TPGS : 2;
/// <summary> /// <summary>
/// Device contains an Access Control Coordinator /// Device contains an Access Control Coordinator
/// Byte 5, bit 6 /// Byte 5, bit 6
/// </summary> /// </summary>
uint8_t ACC : 1; uint8_t ACC : 1;
/// <summary> /// <summary>
/// Device contains an embedded storage array controller /// Device contains an embedded storage array controller
/// Byte 5, bit 7 /// Byte 5, bit 7
/// </summary> /// </summary>
uint8_t SCCS : 1; uint8_t SCCS : 1;
/// <summary> /// <summary>
/// Supports 16-bit wide SCSI addresses /// Supports 16-bit wide SCSI addresses
/// Byte 6, bit 0 /// Byte 6, bit 0
/// </summary> /// </summary>
uint8_t Addr16 : 1; uint8_t Addr16 : 1;
/// <summary> /// <summary>
/// Supports 32-bit wide SCSI addresses /// Supports 32-bit wide SCSI addresses
/// Byte 6, bit 1 /// Byte 6, bit 1
/// </summary> /// </summary>
uint8_t Addr32 : 1; uint8_t Addr32 : 1;
/// <summary> /// <summary>
/// Device supports request and acknowledge handshakes /// Device supports request and acknowledge handshakes
/// Byte 6, bit 2 /// Byte 6, bit 2
/// </summary> /// </summary>
uint8_t ACKREQQ : 1; uint8_t ACKREQQ : 1;
/// <summary> /// <summary>
/// Device contains or is attached to a medium changer /// Device contains or is attached to a medium changer
/// Byte 6, bit 3 /// Byte 6, bit 3
/// </summary> /// </summary>
uint8_t MChngr : 1; uint8_t MChngr : 1;
/// <summary> /// <summary>
/// Multi-port device /// Multi-port device
/// Byte 6, bit 4 /// Byte 6, bit 4
/// </summary> /// </summary>
uint8_t MultiP : 1; uint8_t MultiP : 1;
/// <summary> /// <summary>
/// Vendor-specific /// Vendor-specific
/// Byte 6, bit 5 /// Byte 6, bit 5
/// </summary> /// </summary>
uint8_t VS1 : 1; uint8_t VS1 : 1;
/// <summary> /// <summary>
/// Device contains an embedded enclosure services component /// Device contains an embedded enclosure services component
/// Byte 6, bit 6 /// Byte 6, bit 6
/// </summary> /// </summary>
uint8_t EncServ : 1; uint8_t EncServ : 1;
/// <summary> /// <summary>
/// Supports basic queueing /// Supports basic queueing
/// Byte 6, bit 7 /// Byte 6, bit 7
/// </summary> /// </summary>
uint8_t BQue : 1; uint8_t BQue : 1;
/// <summary> /// <summary>
/// Indicates that the devices responds to RESET with soft reset /// Indicates that the devices responds to RESET with soft reset
/// Byte 7, bit 0 /// Byte 7, bit 0
/// </summary> /// </summary>
uint8_t SftRe : 1; uint8_t SftRe : 1;
/// <summary> /// <summary>
/// Supports TCQ queue /// Supports TCQ queue
/// Byte 7, bit 1 /// Byte 7, bit 1
/// </summary> /// </summary>
uint8_t CmdQue : 1; uint8_t CmdQue : 1;
/// <summary> /// <summary>
/// Supports CONTINUE TASK and TARGET TRANSFER DISABLE commands /// Supports CONTINUE TASK and TARGET TRANSFER DISABLE commands
/// Byte 7, bit 2 /// Byte 7, bit 2
/// </summary> /// </summary>
uint8_t TranDis : 1; uint8_t TranDis : 1;
/// <summary> /// <summary>
/// Supports linked commands /// Supports linked commands
/// Byte 7, bit 3 /// Byte 7, bit 3
/// </summary> /// </summary>
uint8_t Linked : 1; uint8_t Linked : 1;
/// <summary> /// <summary>
/// Supports synchronous data transfer /// Supports synchronous data transfer
/// Byte 7, bit 4 /// Byte 7, bit 4
/// </summary> /// </summary>
uint8_t Sync : 1; uint8_t Sync : 1;
/// <summary> /// <summary>
/// Supports 16-bit wide data transfers /// Supports 16-bit wide data transfers
/// Byte 7, bit 5 /// Byte 7, bit 5
/// </summary> /// </summary>
uint8_t WBus16 : 1; uint8_t WBus16 : 1;
/// <summary> /// <summary>
/// Supports 32-bit wide data transfers /// Supports 32-bit wide data transfers
/// Byte 7, bit 6 /// Byte 7, bit 6
/// </summary> /// </summary>
uint8_t WBus32 : 1; uint8_t WBus32 : 1;
/// <summary> /// <summary>
/// Device supports relative addressing /// Device supports relative addressing
/// Byte 7, bit 7 /// Byte 7, bit 7
/// </summary> /// </summary>
uint8_t RelAddr : 1; uint8_t RelAddr : 1;
/// <summary> /// <summary>
/// Vendor identification /// Vendor identification
/// Bytes 8 to 15 /// Bytes 8 to 15
/// </summary> /// </summary>
uint8_t VendorIdentification[8]; uint8_t VendorIdentification[8];
/// <summary> /// <summary>
/// Product identification /// Product identification
/// Bytes 16 to 31 /// Bytes 16 to 31
/// </summary> /// </summary>
uint8_t ProductIdentification[16]; uint8_t ProductIdentification[16];
/// <summary> /// <summary>
/// Product revision level /// Product revision level
/// Bytes 32 to 35 /// Bytes 32 to 35
/// </summary> /// </summary>
uint8_t ProductRevisionLevel[4]; uint8_t ProductRevisionLevel[4];
/// <summary> /// <summary>
/// Vendor-specific data /// Vendor-specific data
/// Bytes 36 to 55 /// Bytes 36 to 55
/// </summary> /// </summary>
uint8_t VendorSpecific[20]; uint8_t VendorSpecific[20];
/// <summary> /// <summary>
/// Supports information unit transfers /// Supports information unit transfers
/// Byte 56, bit 0 /// Byte 56, bit 0
/// </summary> /// </summary>
uint8_t IUS : 1; uint8_t IUS : 1;
/// <summary> /// <summary>
/// Device supports Quick Arbitration and Selection /// Device supports Quick Arbitration and Selection
/// Byte 56, bit 1 /// Byte 56, bit 1
/// </summary> /// </summary>
uint8_t QAS : 1; uint8_t QAS : 1;
/// <summary> /// <summary>
/// Supported SPI clocking /// Supported SPI clocking
/// Byte 56, bits 3 to 2 /// Byte 56, bits 3 to 2
/// </summary> /// </summary>
uint8_t Clocking : 2; uint8_t Clocking : 2;
/// <summary> /// <summary>
/// Byte 56, bits 7 to 4 /// Byte 56, bits 7 to 4
/// </summary> /// </summary>
uint8_t Reserved3 : 4; uint8_t Reserved3 : 4;
/// <summary> /// <summary>
/// Reserved /// Reserved
/// Byte 57 /// Byte 57
/// </summary> /// </summary>
uint8_t Reserved4; uint8_t Reserved4;
/// <summary> /// <summary>
/// Array of version descriptors /// Array of version descriptors
/// Bytes 58 to 73 /// Bytes 58 to 73
@@ -578,12 +583,12 @@ typedef struct
/// Reserved /// Reserved
/// Bytes 74 to 95 /// Bytes 74 to 95
/// </summary> /// </summary>
uint8_t Reserved5[22]; uint8_t Reserved5[22];
/// <summary> /// <summary>
/// Reserved /// Reserved
/// Bytes 96 to end /// Bytes 96 to end
/// </summary> /// </summary>
uint8_t VendorSpecific2; uint8_t VendorSpecific2;
} ScsiInquiry; } ScsiInquiry;
#pragma pack(pop) #pragma pack(pop)

71
DiscImageChef.Device.Report/scsi_mode.c
View File

@@ -5,13 +5,14 @@
#include <malloc.h> #include <malloc.h>
#include <string.h> #include <string.h>
#include <endian.h> #include <endian.h>
#include <stdint.h>
#include "scsi_mode.h" #include "scsi_mode.h"
ModeHeader *DecodeModeHeader10(unsigned char* modeResponse, uint8_t deviceType) ModeHeader *DecodeModeHeader10(unsigned char *modeResponse, uint8_t deviceType)
{ {
uint16_t blockDescLength = (uint16_t)((modeResponse[6] << 8) + modeResponse[7]); uint16_t blockDescLength = (uint16_t)((modeResponse[6] << 8) + modeResponse[7]);
int i; int i;
ModeHeader *header = malloc(sizeof(ModeHeader)); ModeHeader *header = malloc(sizeof(ModeHeader));
memset(header, 0, sizeof(ModeHeader)); memset(header, 0, sizeof(ModeHeader));
header->MediumType = modeResponse[2]; header->MediumType = modeResponse[2];
@@ -25,7 +26,7 @@ ModeHeader *DecodeModeHeader10(unsigned char* modeResponse, uint8_t deviceType)
for(i = 0; i < header->descriptorsLength; i++) for(i = 0; i < header->descriptorsLength; i++)
{ {
header->BlockDescriptors[i].Density = 0x00; header->BlockDescriptors[i].Density = 0x00;
header->BlockDescriptors[i].Blocks = be64toh((uint64_t)(*modeResponse + 0 + i * 16 + 8)); header->BlockDescriptors[i].Blocks = be64toh((uint64_t)(*modeResponse + 0 + i * 16 + 8));
header->BlockDescriptors[i].BlockLength += (uint32_t)(modeResponse[15 + i * 16 + 8] << 24); header->BlockDescriptors[i].BlockLength += (uint32_t)(modeResponse[15 + i * 16 + 8] << 24);
header->BlockDescriptors[i].BlockLength += (uint32_t)(modeResponse[14 + i * 16 + 8] << 16); header->BlockDescriptors[i].BlockLength += (uint32_t)(modeResponse[14 + i * 16 + 8] << 16);
header->BlockDescriptors[i].BlockLength += (uint32_t)(modeResponse[13 + i * 16 + 8] << 8); header->BlockDescriptors[i].BlockLength += (uint32_t)(modeResponse[13 + i * 16 + 8] << 8);
@@ -59,14 +60,14 @@ ModeHeader *DecodeModeHeader10(unsigned char* modeResponse, uint8_t deviceType)
if(deviceType == 0x00 || deviceType == 0x05) if(deviceType == 0x00 || deviceType == 0x05)
{ {
header->WriteProtected = ((modeResponse[3] & 0x80) == 0x80); header->WriteProtected = ((modeResponse[3] & 0x80) == 0x80);
header->DPOFUA = ((modeResponse[3] & 0x10) == 0x10); header->DPOFUA = ((modeResponse[3] & 0x10) == 0x10);
} }
if(deviceType == 0x01) if(deviceType == 0x01)
{ {
header->WriteProtected = ((modeResponse[3] & 0x80) == 0x80); header->WriteProtected = ((modeResponse[3] & 0x80) == 0x80);
header->Speed = (uint8_t)(modeResponse[3] & 0x0F); header->Speed = (uint8_t)(modeResponse[3] & 0x0F);
header->BufferedMode = (uint8_t)((modeResponse[3] & 0x70) >> 4); header->BufferedMode = (uint8_t)((modeResponse[3] & 0x70) >> 4);
} }
if(deviceType == 0x02) if(deviceType == 0x02)
@@ -75,8 +76,8 @@ ModeHeader *DecodeModeHeader10(unsigned char* modeResponse, uint8_t deviceType)
if(deviceType == 0x07) if(deviceType == 0x07)
{ {
header->WriteProtected = ((modeResponse[3] & 0x80) == 0x80); header->WriteProtected = ((modeResponse[3] & 0x80) == 0x80);
header->EBC = ((modeResponse[3] & 0x01) == 0x01); header->EBC = ((modeResponse[3] & 0x01) == 0x01);
header->DPOFUA = ((modeResponse[3] & 0x10) == 0x10); header->DPOFUA = ((modeResponse[3] & 0x10) == 0x10);
} }
header->decoded = 1; header->decoded = 1;
@@ -84,7 +85,7 @@ ModeHeader *DecodeModeHeader10(unsigned char* modeResponse, uint8_t deviceType)
return header; return header;
} }
DecodedMode *DecodeMode10(unsigned char* modeResponse, uint8_t deviceType) DecodedMode *DecodeMode10(unsigned char *modeResponse, uint8_t deviceType)
{ {
DecodedMode *decodedMode = malloc(sizeof(DecodedMode)); DecodedMode *decodedMode = malloc(sizeof(DecodedMode));
@@ -113,12 +114,12 @@ DecodedMode *DecodeMode10(unsigned char* modeResponse, uint8_t deviceType)
int isSubpage = (modeResponse[offset] & 0x40) == 0x40; int isSubpage = (modeResponse[offset] & 0x40) == 0x40;
uint8_t pageNo = (uint8_t)(modeResponse[offset] & 0x3F); uint8_t pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
int subpage; int subpage;
if(pageNo == 0) if(pageNo == 0)
{ {
decodedMode->pageSizes[0][0] = (size_t)(length - offset); decodedMode->pageSizes[0][0] = (size_t)(length - offset);
decodedMode->Pages[0][0] = malloc(decodedMode->pageSizes[0][0]); decodedMode->Pages[0][0] = malloc(decodedMode->pageSizes[0][0]);
memset(decodedMode->Pages[0][0], 0, decodedMode->pageSizes[0][0]); memset(decodedMode->Pages[0][0], 0, decodedMode->pageSizes[0][0]);
memcpy(decodedMode->Pages[0][0], modeResponse + offset, decodedMode->pageSizes[0][0]); memcpy(decodedMode->Pages[0][0], modeResponse + offset, decodedMode->pageSizes[0][0]);
offset += decodedMode->pageSizes[0][0]; offset += decodedMode->pageSizes[0][0];
@@ -130,12 +131,14 @@ DecodedMode *DecodeMode10(unsigned char* modeResponse, uint8_t deviceType)
if(offset + 3 >= length) if(offset + 3 >= length)
break; break;
pageNo = (uint8_t)(modeResponse[offset] & 0x3F); pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
subpage = modeResponse[offset + 1]; subpage = modeResponse[offset + 1];
decodedMode->pageSizes[pageNo][subpage] = (size_t)((modeResponse[offset + 2] << 8) + modeResponse[offset + 3] + 4); decodedMode->pageSizes[pageNo][subpage] = (size_t)((modeResponse[offset + 2] << 8) +
decodedMode->Pages[pageNo][subpage] = malloc(decodedMode->pageSizes[pageNo][subpage]); modeResponse[offset + 3] + 4);
decodedMode->Pages[pageNo][subpage] = malloc(decodedMode->pageSizes[pageNo][subpage]);
memset(decodedMode->Pages[pageNo][subpage], 0, decodedMode->pageSizes[pageNo][subpage]); memset(decodedMode->Pages[pageNo][subpage], 0, decodedMode->pageSizes[pageNo][subpage]);
memcpy(decodedMode->Pages[pageNo][subpage], modeResponse + offset, decodedMode->pageSizes[pageNo][subpage]); memcpy(decodedMode->Pages[pageNo][subpage], modeResponse + offset,
decodedMode->pageSizes[pageNo][subpage]);
offset += decodedMode->pageSizes[pageNo][subpage]; offset += decodedMode->pageSizes[pageNo][subpage];
} }
else else
@@ -145,7 +148,7 @@ DecodedMode *DecodeMode10(unsigned char* modeResponse, uint8_t deviceType)
pageNo = (uint8_t)(modeResponse[offset] & 0x3F); pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
decodedMode->pageSizes[pageNo][0] = (size_t)(modeResponse[offset + 1] + 2); decodedMode->pageSizes[pageNo][0] = (size_t)(modeResponse[offset + 1] + 2);
decodedMode->Pages[pageNo][0] = malloc(decodedMode->pageSizes[pageNo][0]); decodedMode->Pages[pageNo][0] = malloc(decodedMode->pageSizes[pageNo][0]);
memset(decodedMode->Pages[pageNo][0], 0, decodedMode->pageSizes[pageNo][0]); memset(decodedMode->Pages[pageNo][0], 0, decodedMode->pageSizes[pageNo][0]);
memcpy(decodedMode->Pages[pageNo][0], modeResponse + offset, decodedMode->pageSizes[pageNo][0]); memcpy(decodedMode->Pages[pageNo][0], modeResponse + offset, decodedMode->pageSizes[pageNo][0]);
offset += decodedMode->pageSizes[pageNo][0]; offset += decodedMode->pageSizes[pageNo][0];
@@ -157,9 +160,9 @@ DecodedMode *DecodeMode10(unsigned char* modeResponse, uint8_t deviceType)
} }
ModeHeader *DecodeModeHeader6(unsigned char* modeResponse, uint8_t deviceType) ModeHeader *DecodeModeHeader6(unsigned char *modeResponse, uint8_t deviceType)
{ {
int i; int i;
ModeHeader *header = malloc(sizeof(ModeHeader)); ModeHeader *header = malloc(sizeof(ModeHeader));
memset(header, 0, sizeof(ModeHeader)); memset(header, 0, sizeof(ModeHeader));
@@ -181,14 +184,14 @@ ModeHeader *DecodeModeHeader6(unsigned char* modeResponse, uint8_t deviceType)
if(deviceType == 0x00 || deviceType == 0x05) if(deviceType == 0x00 || deviceType == 0x05)
{ {
header->WriteProtected = ((modeResponse[2] & 0x80) == 0x80); header->WriteProtected = ((modeResponse[2] & 0x80) == 0x80);
header->DPOFUA = ((modeResponse[2] & 0x10) == 0x10); header->DPOFUA = ((modeResponse[2] & 0x10) == 0x10);
} }
if(deviceType == 0x01) if(deviceType == 0x01)
{ {
header->WriteProtected = ((modeResponse[2] & 0x80) == 0x80); header->WriteProtected = ((modeResponse[2] & 0x80) == 0x80);
header->Speed = (uint8_t)(modeResponse[2] & 0x0F); header->Speed = (uint8_t)(modeResponse[2] & 0x0F);
header->BufferedMode = (uint8_t)((modeResponse[2] & 0x70) >> 4); header->BufferedMode = (uint8_t)((modeResponse[2] & 0x70) >> 4);
} }
if(deviceType == 0x02) if(deviceType == 0x02)
@@ -197,8 +200,8 @@ ModeHeader *DecodeModeHeader6(unsigned char* modeResponse, uint8_t deviceType)
if(deviceType == 0x07) if(deviceType == 0x07)
{ {
header->WriteProtected = ((modeResponse[2] & 0x80) == 0x80); header->WriteProtected = ((modeResponse[2] & 0x80) == 0x80);
header->EBC = ((modeResponse[2] & 0x01) == 0x01); header->EBC = ((modeResponse[2] & 0x01) == 0x01);
header->DPOFUA = ((modeResponse[2] & 0x10) == 0x10); header->DPOFUA = ((modeResponse[2] & 0x10) == 0x10);
} }
header->decoded = 1; header->decoded = 1;
@@ -206,7 +209,7 @@ ModeHeader *DecodeModeHeader6(unsigned char* modeResponse, uint8_t deviceType)
return header; return header;
} }
DecodedMode *DecodeMode6(unsigned char* modeResponse, uint8_t deviceType) DecodedMode *DecodeMode6(unsigned char *modeResponse, uint8_t deviceType)
{ {
DecodedMode *decodedMode = malloc(sizeof(DecodedMode)); DecodedMode *decodedMode = malloc(sizeof(DecodedMode));
@@ -227,12 +230,12 @@ DecodedMode *DecodeMode6(unsigned char* modeResponse, uint8_t deviceType)
int isSubpage = (modeResponse[offset] & 0x40) == 0x40; int isSubpage = (modeResponse[offset] & 0x40) == 0x40;
uint8_t pageNo = (uint8_t)(modeResponse[offset] & 0x3F); uint8_t pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
int subpage; int subpage;
if(pageNo == 0) if(pageNo == 0)
{ {
decodedMode->pageSizes[0][0] = (size_t)(length - offset); decodedMode->pageSizes[0][0] = (size_t)(length - offset);
decodedMode->Pages[0][0] = malloc(decodedMode->pageSizes[0][0]); decodedMode->Pages[0][0] = malloc(decodedMode->pageSizes[0][0]);
memset(decodedMode->Pages[0][0], 0, decodedMode->pageSizes[0][0]); memset(decodedMode->Pages[0][0], 0, decodedMode->pageSizes[0][0]);
memcpy(decodedMode->Pages[0][0], modeResponse + offset, decodedMode->pageSizes[0][0]); memcpy(decodedMode->Pages[0][0], modeResponse + offset, decodedMode->pageSizes[0][0]);
offset += decodedMode->pageSizes[0][0]; offset += decodedMode->pageSizes[0][0];
@@ -244,12 +247,14 @@ DecodedMode *DecodeMode6(unsigned char* modeResponse, uint8_t deviceType)
if(offset + 3 >= length) if(offset + 3 >= length)
break; break;
pageNo = (uint8_t)(modeResponse[offset] & 0x3F); pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
subpage = modeResponse[offset + 1]; subpage = modeResponse[offset + 1];
decodedMode->pageSizes[pageNo][subpage] = (size_t)((modeResponse[offset + 2] << 8) + modeResponse[offset + 3] + 4); decodedMode->pageSizes[pageNo][subpage] = (size_t)((modeResponse[offset + 2] << 8) +
decodedMode->Pages[pageNo][subpage] = malloc(decodedMode->pageSizes[pageNo][subpage]); modeResponse[offset + 3] + 4);
decodedMode->Pages[pageNo][subpage] = malloc(decodedMode->pageSizes[pageNo][subpage]);
memset(decodedMode->Pages[pageNo][subpage], 0, decodedMode->pageSizes[pageNo][subpage]); memset(decodedMode->Pages[pageNo][subpage], 0, decodedMode->pageSizes[pageNo][subpage]);
memcpy(decodedMode->Pages[pageNo][subpage], modeResponse + offset, decodedMode->pageSizes[pageNo][subpage]); memcpy(decodedMode->Pages[pageNo][subpage], modeResponse + offset,
decodedMode->pageSizes[pageNo][subpage]);
offset += decodedMode->pageSizes[pageNo][subpage]; offset += decodedMode->pageSizes[pageNo][subpage];
} }
else else
@@ -259,7 +264,7 @@ DecodedMode *DecodeMode6(unsigned char* modeResponse, uint8_t deviceType)
pageNo = (uint8_t)(modeResponse[offset] & 0x3F); pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
decodedMode->pageSizes[pageNo][0] = (size_t)(modeResponse[offset + 1] + 2); decodedMode->pageSizes[pageNo][0] = (size_t)(modeResponse[offset + 1] + 2);
decodedMode->Pages[pageNo][0] = malloc(decodedMode->pageSizes[pageNo][0]); decodedMode->Pages[pageNo][0] = malloc(decodedMode->pageSizes[pageNo][0]);
memset(decodedMode->Pages[pageNo][0], 0, decodedMode->pageSizes[pageNo][0]); memset(decodedMode->Pages[pageNo][0], 0, decodedMode->pageSizes[pageNo][0]);
memcpy(decodedMode->Pages[pageNo][0], modeResponse + offset, decodedMode->pageSizes[pageNo][0]); memcpy(decodedMode->Pages[pageNo][0], modeResponse + offset, decodedMode->pageSizes[pageNo][0]);
offset += decodedMode->pageSizes[pageNo][0]; offset += decodedMode->pageSizes[pageNo][0];

38
DiscImageChef.Device.Report/scsi_mode.h
View File

@@ -5,38 +5,40 @@
#ifndef DISCIMAGECHEF_DEVICE_REPORT_SCSI_MODE_H #ifndef DISCIMAGECHEF_DEVICE_REPORT_SCSI_MODE_H
#define DISCIMAGECHEF_DEVICE_REPORT_SCSI_MODE_H #define DISCIMAGECHEF_DEVICE_REPORT_SCSI_MODE_H
#include <stdint.h>
typedef struct typedef struct
{ {
uint8_t Density; uint8_t Density;
uint64_t Blocks; uint64_t Blocks;
uint32_t BlockLength; uint32_t BlockLength;
} BlockDescriptor; } BlockDescriptor;
typedef struct typedef struct
{ {
uint8_t MediumType; uint8_t MediumType;
int WriteProtected; int WriteProtected;
BlockDescriptor BlockDescriptors[4096]; BlockDescriptor BlockDescriptors[4096];
int descriptorsLength; int descriptorsLength;
uint8_t Speed; uint8_t Speed;
uint8_t BufferedMode; uint8_t BufferedMode;
int EBC; int EBC;
int DPOFUA; int DPOFUA;
int decoded; int decoded;
} ModeHeader; } ModeHeader;
typedef struct typedef struct
{ {
ModeHeader Header; ModeHeader Header;
unsigned char *Pages[256][256]; unsigned char *Pages[256][256];
size_t pageSizes[256][256]; size_t pageSizes[256][256];
int decoded; int decoded;
} DecodedMode; } DecodedMode;
ModeHeader *DecodeModeHeader6(unsigned char* modeResponse, uint8_t deviceType); ModeHeader *DecodeModeHeader6(unsigned char *modeResponse, uint8_t deviceType);
ModeHeader *DecodeModeHeader10(unsigned char* modeResponse, uint8_t deviceType);
DecodedMode *DecodeMode6(unsigned char* modeResponse, uint8_t deviceType); ModeHeader *DecodeModeHeader10(unsigned char *modeResponse, uint8_t deviceType);
DecodedMode *DecodeMode10(unsigned char* modeResponse, uint8_t deviceType);
DecodedMode *DecodeMode6(unsigned char *modeResponse, uint8_t deviceType);
DecodedMode *DecodeMode10(unsigned char *modeResponse, uint8_t deviceType);
#endif //DISCIMAGECHEF_DEVICE_REPORT_SCSI_MODE_H #endif //DISCIMAGECHEF_DEVICE_REPORT_SCSI_MODE_H

191
DiscImageChef.Device.Report/scsi_report.c
View File

@@ -14,26 +14,26 @@
void ScsiReport(int fd, xmlTextWriterPtr xmlWriter) void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
{ {
unsigned char *sense = NULL; unsigned char *sense = NULL;
unsigned char *buffer = NULL; unsigned char *buffer = NULL;
int error; int error;
int page_len; int page_len;
int removable = FALSE; int removable = FALSE;
char user_response = ' '; char user_response = ' ';
unsigned char* tmpString; unsigned char *tmpString;
const int testSize512[] = {514, const int testSize512[] = {514,
// Long sector sizes for SuperDisk // Long sector sizes for SuperDisk
536, 558, 536, 558,
// Long sector sizes for 512-byte magneto-opticals // Long sector sizes for 512-byte magneto-opticals
600, 610, 630}; 600, 610, 630};
const int testSize1024[] = { const int testSize1024[] = {
// Long sector sizes for floppies // Long sector sizes for floppies
1026, 1026,
// Long sector sizes for 1024-byte magneto-opticals // Long sector sizes for 1024-byte magneto-opticals
1200}; 1200};
const int testSize2048[] = {2380}; const int testSize2048[] = {2380};
const int testSize4096[] = {4760}; const int testSize4096[] = {4760};
const int testSize8192[] = {9424}; const int testSize8192[] = {9424};
printf("Querying SCSI INQUIRY...\n"); printf("Querying SCSI INQUIRY...\n");
@@ -59,13 +59,14 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Is the media removable from the reading/writing elements (flash memories ARE NOT removable)? (Y/N): "); printf("Is the media removable from the reading/writing elements (flash memories ARE NOT removable)? (Y/N): ");
scanf("%c", &user_response); scanf("%c", &user_response);
printf("\n"); printf("\n");
} while(user_response != 'Y' && user_response != 'y' && user_response != 'N' && user_response != 'n'); }while(user_response != 'Y' && user_response != 'y' && user_response != 'N' && user_response != 'n');
removable = (user_response == 'Y' || user_response == 'y'); removable = (user_response == 'Y' || user_response == 'y');
} }
xmlTextWriterStartElement(xmlWriter, BAD_CAST DIC_SCSI_INQUIRY_ELEMENT); // <Inquiry> xmlTextWriterStartElement(xmlWriter, BAD_CAST DIC_SCSI_INQUIRY_ELEMENT); // <Inquiry>
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "AccessControlCoordinator", "%s", inquiry->ACC ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "AccessControlCoordinator", "%s",
inquiry->ACC ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ACKRequests", "%s", inquiry->ACKREQQ ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ACKRequests", "%s", inquiry->ACKREQQ ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Address16", "%s", inquiry->Addr16 ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Address16", "%s", inquiry->Addr16 ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Address32", "%s", inquiry->Addr32 ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Address32", "%s", inquiry->Addr32 ? "true" : "false");
@@ -83,8 +84,10 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumChanger", "%s", inquiry->MChngr ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumChanger", "%s", inquiry->MChngr ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultiPortDevice", "%s", inquiry->MultiP ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultiPortDevice", "%s", inquiry->MultiP ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NormalACA", "%s", inquiry->NormACA ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NormalACA", "%s", inquiry->NormACA ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PeripheralDeviceType", "%s", DecodePeripheralDeviceType(inquiry->PeripheralDeviceType)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PeripheralDeviceType", "%s",
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PeripheralQualifier", "%s", DecodePeripheralQualifier(inquiry->PeripheralQualifier)); DecodePeripheralDeviceType(inquiry->PeripheralDeviceType));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PeripheralQualifier", "%s",
DecodePeripheralQualifier(inquiry->PeripheralQualifier));
tmpString = malloc(17); tmpString = malloc(17);
memset(tmpString, 0, 17); memset(tmpString, 0, 17);
memcpy(tmpString, inquiry->ProductIdentification, 16); memcpy(tmpString, inquiry->ProductIdentification, 16);
@@ -97,15 +100,18 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
free(tmpString); free(tmpString);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Protection", "%s", inquiry->Protect ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Protection", "%s", inquiry->Protect ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "QAS", "%s", inquiry->QAS ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "QAS", "%s", inquiry->QAS ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RelativeAddressing", "%s", inquiry->RelAddr ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RelativeAddressing", "%s",
inquiry->RelAddr ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Removable", "%s", inquiry->RMB ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Removable", "%s", inquiry->RMB ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ResponseDataFormat", "%d", inquiry->ResponseDataFormat); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ResponseDataFormat", "%d", inquiry->ResponseDataFormat);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SoftReset", "%s", inquiry->SftRe ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SoftReset", "%s", inquiry->SftRe ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SPIClocking", "%s", DecodeSPIClocking(inquiry->Clocking)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SPIClocking", "%s", DecodeSPIClocking(inquiry->Clocking));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StorageArrayController", "%s", inquiry->SCCS ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StorageArrayController", "%s",
inquiry->SCCS ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SyncTransfer", "%s", inquiry->Sync ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SyncTransfer", "%s", inquiry->Sync ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TaggedCommandQueue", "%s", inquiry->CmdQue ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TaggedCommandQueue", "%s", inquiry->CmdQue ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TerminateTaskSupported", "%s", inquiry->TrmTsk ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TerminateTaskSupported", "%s",
inquiry->TrmTsk ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ThirdPartyCopy", "%s", inquiry->ThreePC ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ThirdPartyCopy", "%s", inquiry->ThreePC ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TranferDisable", "%s", inquiry->TranDis ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TranferDisable", "%s", inquiry->TranDis ? "true" : "false");
tmpString = malloc(9); tmpString = malloc(9);
@@ -140,11 +146,11 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
scanf("%c"); scanf("%c");
} }
int supportsMode6 = FALSE; int supportsMode6 = FALSE;
int supportsMode10 = FALSE; int supportsMode10 = FALSE;
int supportsModeSubpages = FALSE; int supportsModeSubpages = FALSE;
unsigned char* mode6Response = NULL; unsigned char *mode6Response = NULL;
unsigned char* mode10Response = NULL; unsigned char *mode10Response = NULL;
printf("Querying all mode pages and subpages using SCSI MODE SENSE (10)...\n"); printf("Querying all mode pages and subpages using SCSI MODE SENSE (10)...\n");
error = ModeSense10(fd, &mode10Response, &sense, FALSE, TRUE, MODE_PAGE_DEFAULT, 0x3F, 0xFF); error = ModeSense10(fd, &mode10Response, &sense, FALSE, TRUE, MODE_PAGE_DEFAULT, 0x3F, 0xFF);
@@ -152,13 +158,13 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
if(error) if(error)
{ {
printf("Querying all mode pages using SCSI MODE SENSE (10)...\n"); printf("Querying all mode pages using SCSI MODE SENSE (10)...\n");
error = ModeSense10(fd, &mode10Response, &sense, FALSE, TRUE, MODE_PAGE_DEFAULT, 0x3F, 0x00); error = ModeSense10(fd, &mode10Response, &sense, FALSE, TRUE, MODE_PAGE_DEFAULT, 0x3F, 0x00);
if(!error) if(!error)
supportsMode10 = TRUE; supportsMode10 = TRUE;
} }
else else
{ {
supportsMode10 = TRUE; supportsMode10 = TRUE;
supportsModeSubpages = TRUE; supportsModeSubpages = TRUE;
} }
@@ -171,7 +177,7 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
if(error) if(error)
{ {
printf("Querying SCSI MODE SENSE (6)...\n"); printf("Querying SCSI MODE SENSE (6)...\n");
error = ModeSense6(fd, &mode6Response, &sense, FALSE, MODE_PAGE_DEFAULT, 0x00, 0x00); error = ModeSense6(fd, &mode6Response, &sense, FALSE, MODE_PAGE_DEFAULT, 0x00, 0x00);
if(!error) if(!error)
supportsMode6 = TRUE; supportsMode6 = TRUE;
} }
@@ -180,13 +186,14 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
} }
else else
{ {
supportsMode6 = TRUE; supportsMode6 = TRUE;
supportsModeSubpages = TRUE; supportsModeSubpages = TRUE;
} }
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense6", "%s", supportsMode6 ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense6", "%s", supportsMode6 ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense10", "%s", supportsMode10 ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense10", "%s", supportsMode10 ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSubpages", "%s", supportsModeSubpages ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSubpages", "%s",
supportsModeSubpages ? "true" : "false");
if(supportsMode6) if(supportsMode6)
{ {
@@ -198,12 +205,13 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
if(supportsMode10) if(supportsMode10)
{ {
xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense10Data"); xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense10Data");
xmlTextWriterWriteBase64(xmlWriter, mode10Response, 0, (*(mode10Response + 0) << 8) + *(mode10Response + 1) + 2); xmlTextWriterWriteBase64(xmlWriter, mode10Response, 0,
(*(mode10Response + 0) << 8) + *(mode10Response + 1) + 2);
xmlTextWriterEndElement(xmlWriter); xmlTextWriterEndElement(xmlWriter);
} }
DecodedMode *decMode = NULL; DecodedMode *decMode = NULL;
unsigned char* cdromMode = NULL; unsigned char *cdromMode = NULL;
if(supportsMode10) if(supportsMode10)
decMode = DecodeMode10(mode10Response, inquiry->PeripheralDeviceType); decMode = DecodeMode10(mode10Response, inquiry->PeripheralDeviceType);
@@ -215,12 +223,16 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
int page, subpage; int page, subpage;
xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense"); // <ModeSense> xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense"); // <ModeSense>
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BlankCheckEnabled", "%s", decMode->Header.EBC ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BlankCheckEnabled", "%s",
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DPOandFUA", "%s", decMode->Header.DPOFUA ? "true" : "false"); decMode->Header.EBC ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WriteProtected", "%s", decMode->Header.WriteProtected ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DPOandFUA", "%s",
decMode->Header.DPOFUA ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WriteProtected", "%s",
decMode->Header.WriteProtected ? "true" : "false");
if(decMode->Header.BufferedMode > 0) if(decMode->Header.BufferedMode > 0)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BlankCheckEnabled", "%d", decMode->Header.BufferedMode); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BlankCheckEnabled", "%d",
decMode->Header.BufferedMode);
if(decMode->Header.Speed > 0) if(decMode->Header.Speed > 0)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Speed", "%d", decMode->Header.Speed); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Speed", "%d", decMode->Header.Speed);
@@ -233,7 +245,8 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
xmlTextWriterStartElement(xmlWriter, BAD_CAST "modePageType"); xmlTextWriterStartElement(xmlWriter, BAD_CAST "modePageType");
xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST "page", "%d", page); xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST "page", "%d", page);
xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST "subpage", "%d", subpage); xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST "subpage", "%d", subpage);
xmlTextWriterWriteBase64(xmlWriter, decMode->Pages[page][subpage], 0, decMode->pageSizes[page][subpage]); xmlTextWriterWriteBase64(xmlWriter, decMode->Pages[page][subpage], 0,
decMode->pageSizes[page][subpage]);
xmlTextWriterEndElement(xmlWriter); xmlTextWriterEndElement(xmlWriter);
if(page == 0x2A && subpage == 0x00) if(page == 0x2A && subpage == 0x00)
@@ -268,7 +281,7 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Do you have media that you can insert in the drive? (Y/N): "); printf("Do you have media that you can insert in the drive? (Y/N): ");
scanf("%c", &user_response); scanf("%c", &user_response);
printf("\n"); printf("\n");
} while(user_response != 'Y' && user_response != 'y' && user_response != 'N' && user_response != 'n'); }while(user_response != 'Y' && user_response != 'y' && user_response != 'N' && user_response != 'n');
if(user_response == 'Y' || user_response == 'y') if(user_response == 'Y' || user_response == 'y')
{ {
@@ -285,7 +298,7 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
error = TestUnitReady(fd, &sense); error = TestUnitReady(fd, &sense);
int mediaRecognized = TRUE; int mediaRecognized = TRUE;
int leftRetries = 20; int leftRetries = 20;
if(error) if(error)
{ {
@@ -319,14 +332,15 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
xmlTextWriterStartElement(xmlWriter, BAD_CAST "testedMediaType"); // <testedMediaType> xmlTextWriterStartElement(xmlWriter, BAD_CAST "testedMediaType"); // <testedMediaType>
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediaIsRecognized", "%s", mediaRecognized ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediaIsRecognized", "%s",
mediaRecognized ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Manufacturer", "%s", mediaManufacturer); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Manufacturer", "%s", mediaManufacturer);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumTypeName", "%s",mediaName); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumTypeName", "%s", mediaName);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Model", "%s", mediaModel); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Model", "%s", mediaModel);
if(mediaRecognized) if(mediaRecognized)
{ {
uint64_t blocks = 0; uint64_t blocks = 0;
uint32_t blockSize = 0; uint32_t blockSize = 0;
printf("Querying SCSI READ CAPACITY...\n"); printf("Querying SCSI READ CAPACITY...\n");
@@ -334,8 +348,10 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
if(!error) if(!error)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadCapacity", "%s", "true"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadCapacity", "%s", "true");
blocks = (uint64_t)(buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + (buffer[3]) + 1; blocks = (uint64_t)(buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + (buffer[3]) +
blockSize = (uint32_t)((buffer[4] << 24) + (buffer[5] << 16) + (buffer[6] << 8) + (buffer[7])); 1;
blockSize = (uint32_t)((buffer[4] << 24) + (buffer[5] << 16) + (buffer[6] << 8) +
(buffer[7]));
} }
printf("Querying SCSI READ CAPACITY (16)...\n"); printf("Querying SCSI READ CAPACITY (16)...\n");
@@ -347,7 +363,8 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
blocks <<= 32; blocks <<= 32;
blocks += (buffer[4] << 24) + (buffer[5] << 16) + (buffer[6] << 8) + (buffer[7]); blocks += (buffer[4] << 24) + (buffer[5] << 16) + (buffer[6] << 8) + (buffer[7]);
blocks++; blocks++;
blockSize = (uint32_t)((buffer[8] << 24) + (buffer[9] << 16) + (buffer[10] << 8) + (buffer[11])); blockSize = (uint32_t)((buffer[8] << 24) + (buffer[9] << 16) + (buffer[10] << 8) +
(buffer[11]));
} }
if(blocks != 0) if(blocks != 0)
@@ -361,18 +378,21 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Querying SCSI MODE SENSE (10)...\n"); printf("Querying SCSI MODE SENSE (10)...\n");
error = ModeSense10(fd, &mode10Response, &sense, FALSE, TRUE, MODE_PAGE_DEFAULT, 0x3F, 0x00); error = ModeSense10(fd, &mode10Response, &sense, FALSE, TRUE, MODE_PAGE_DEFAULT, 0x3F, 0x00);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense10", "%s", !error ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense10", "%s",
!error ? "true" : "false");
if(!error) if(!error)
{ {
xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense10Data"); xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense10Data");
xmlTextWriterWriteBase64(xmlWriter, mode10Response, 0, (*(mode10Response + 0) << 8) + *(mode10Response + 1) + 2); xmlTextWriterWriteBase64(xmlWriter, mode10Response, 0,
(*(mode10Response + 0) << 8) + *(mode10Response + 1) + 2);
xmlTextWriterEndElement(xmlWriter); xmlTextWriterEndElement(xmlWriter);
decMode = DecodeMode10(mode10Response, inquiry->PeripheralDeviceType); decMode = DecodeMode10(mode10Response, inquiry->PeripheralDeviceType);
} }
printf("Querying SCSI MODE SENSE (6)...\n"); printf("Querying SCSI MODE SENSE (6)...\n");
error = ModeSense6(fd, &mode6Response, &sense, FALSE, MODE_PAGE_DEFAULT, 0x00, 0x00); error = ModeSense6(fd, &mode6Response, &sense, FALSE, MODE_PAGE_DEFAULT, 0x00, 0x00);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense6", "%s", !error ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense6", "%s",
!error ? "true" : "false");
if(!error) if(!error)
{ {
xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense6Data"); xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense6Data");
@@ -384,22 +404,32 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
if(decMode->decoded) if(decMode->decoded)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumType", "%d", decMode->Header.MediumType); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumType", "%d",
decMode->Header.MediumType);
if(decMode->Header.descriptorsLength > 0) if(decMode->Header.descriptorsLength > 0)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Density", "%d", decMode->Header.BlockDescriptors[0].Density); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Density", "%d",
decMode->Header.BlockDescriptors[0].Density);
} }
printf("Trying SCSI READ (6)...\n"); printf("Trying SCSI READ (6)...\n");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead", "%s", !Read6(fd, &buffer, &sense, 0, blockSize, 1) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead", "%s",
!Read6(fd, &buffer, &sense, 0, blockSize, 1) ? "true"
: "false");
printf("Trying SCSI READ (10)...\n"); printf("Trying SCSI READ (10)...\n");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead10", "%s", !Read10(fd, &buffer, &sense, 0, FALSE, TRUE, FALSE, FALSE, 0, blockSize, 0, 1) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead10", "%s",
!Read10(fd, &buffer, &sense, 0, FALSE, TRUE, FALSE, FALSE, 0,
blockSize, 0, 1) ? "true" : "false");
printf("Trying SCSI READ (12)...\n"); printf("Trying SCSI READ (12)...\n");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead12", "%s", !Read12(fd, &buffer, &sense, 0, FALSE, TRUE, FALSE, FALSE, 0, blockSize, 0, 1, FALSE) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead12", "%s",
!Read12(fd, &buffer, &sense, 0, FALSE, TRUE, FALSE, FALSE, 0,
blockSize, 0, 1, FALSE) ? "true" : "false");
printf("Trying SCSI READ (16)...\n"); printf("Trying SCSI READ (16)...\n");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead16", "%s", !Read16(fd, &buffer, &sense, 0, FALSE, TRUE, FALSE, 0, blockSize, 0, 1, FALSE) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead16", "%s",
!Read16(fd, &buffer, &sense, 0, FALSE, TRUE, FALSE, 0,
blockSize, 0, 1, FALSE) ? "true" : "false");
uint32_t longBlockSize = blockSize; uint32_t longBlockSize = blockSize;
@@ -407,21 +437,24 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Trying SCSI READ LONG (10)...\n"); printf("Trying SCSI READ LONG (10)...\n");
ReadLong10(fd, &buffer, &sense, FALSE, FALSE, 0, 0xFFFF); ReadLong10(fd, &buffer, &sense, FALSE, FALSE, 0, 0xFFFF);
if((sense[0] == 0x70 || sense[0] == 0x71) && (sense[2] & 0x0F) == 0x05 && sense[12] == 0x24 && sense[13] == 0x00) if((sense[0] == 0x70 || sense[0] == 0x71) && (sense[2] & 0x0F) == 0x05 && sense[12] == 0x24 &&
sense[13] == 0x00)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLong", "%s", "true"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLong", "%s", "true");
supportsReadLong10 = TRUE; supportsReadLong10 = TRUE;
if(sense[0] & 0x80 && sense[2] & 0x20) if(sense[0] & 0x80 && sense[2] & 0x20)
{ {
uint32_t information = (sense[3] << 24) + (sense[4] << 16) + (sense[5] << 8) + sense[6]; uint32_t information = (sense[3] << 24) + (sense[4] << 16) + (sense[5] << 8) + sense[6];
longBlockSize = 0xFFFF - (information & 0xFFFF); longBlockSize = 0xFFFF - (information & 0xFFFF);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LongBlockSize", "%d", longBlockSize); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LongBlockSize", "%d",
longBlockSize);
} }
} }
printf("Trying SCSI READ LONG (16)...\n"); printf("Trying SCSI READ LONG (16)...\n");
ReadLong16(fd, &buffer, &sense, FALSE, 0, 0xFFFF); ReadLong16(fd, &buffer, &sense, FALSE, 0, 0xFFFF);
if((sense[0] == 0x70 || sense[0] == 0x71) && (sense[2] & 0x0F) == 0x05 && sense[12] == 0x24 && sense[13] == 0x00) if((sense[0] == 0x70 || sense[0] == 0x71) && (sense[2] & 0x0F) == 0x05 && sense[12] == 0x24 &&
sense[13] == 0x00)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLong16", "%s", "true"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLong16", "%s", "true");
int i; int i;
@@ -498,7 +531,8 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Drive supports SCSI READ LONG but I cannot find the correct size. Do you want me to try? (This can take hours) (Y/N): "); printf("Drive supports SCSI READ LONG but I cannot find the correct size. Do you want me to try? (This can take hours) (Y/N): ");
scanf("%c", &user_response); scanf("%c", &user_response);
printf("\n"); printf("\n");
} while(user_response != 'Y' && user_response != 'y' && user_response != 'N' && user_response != 'n'); }while(user_response != 'Y' && user_response != 'y' && user_response != 'N' &&
user_response != 'n');
if(user_response == 'Y' || user_response == 'y') if(user_response == 'Y' || user_response == 'y')
{ {
@@ -535,7 +569,7 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
} }
else else
{ {
uint64_t blocks = 0; uint64_t blocks = 0;
uint32_t blockSize = 0; uint32_t blockSize = 0;
xmlTextWriterStartElement(xmlWriter, BAD_CAST "ReadCapabilities"); // <ReadCapabilities> xmlTextWriterStartElement(xmlWriter, BAD_CAST "ReadCapabilities"); // <ReadCapabilities>
@@ -545,7 +579,7 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
if(!error) if(!error)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadCapacity", "%s", "true"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadCapacity", "%s", "true");
blocks = (uint64_t)(buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + (buffer[3]) + 1; blocks = (uint64_t)(buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + (buffer[3]) + 1;
blockSize = (uint32_t)((buffer[4] << 24) + (buffer[5] << 16) + (buffer[6] << 8) + (buffer[7])); blockSize = (uint32_t)((buffer[4] << 24) + (buffer[5] << 16) + (buffer[6] << 8) + (buffer[7]));
} }
@@ -571,7 +605,8 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense10", "%s", "true"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense10", "%s", "true");
xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense10Data"); xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense10Data");
xmlTextWriterWriteBase64(xmlWriter, mode10Response, 0, (*(mode10Response + 0) << 8) + *(mode10Response + 1) + 2); xmlTextWriterWriteBase64(xmlWriter, mode10Response, 0,
(*(mode10Response + 0) << 8) + *(mode10Response + 1) + 2);
xmlTextWriterEndElement(xmlWriter); xmlTextWriterEndElement(xmlWriter);
} }
@@ -587,20 +622,28 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumType", "%d", decMode->Header.MediumType); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumType", "%d", decMode->Header.MediumType);
if(decMode->Header.descriptorsLength > 0) if(decMode->Header.descriptorsLength > 0)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Density", "%d", decMode->Header.BlockDescriptors[0].Density); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Density", "%d",
decMode->Header.BlockDescriptors[0].Density);
} }
printf("Trying SCSI READ (6)...\n"); printf("Trying SCSI READ (6)...\n");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead", "%s", !Read6(fd, &buffer, &sense, 0, blockSize, 1) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead", "%s",
!Read6(fd, &buffer, &sense, 0, blockSize, 1) ? "true" : "false");
printf("Trying SCSI READ (10)...\n"); printf("Trying SCSI READ (10)...\n");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead10", "%s", !Read10(fd, &buffer, &sense, 0, FALSE, TRUE, FALSE, FALSE, 0, blockSize, 0, 1) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead10", "%s",
!Read10(fd, &buffer, &sense, 0, FALSE, TRUE, FALSE, FALSE, 0, blockSize, 0,
1) ? "true" : "false");
printf("Trying SCSI READ (12)...\n"); printf("Trying SCSI READ (12)...\n");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead12", "%s", !Read12(fd, &buffer, &sense, 0, FALSE, TRUE, FALSE, FALSE, 0, blockSize, 0, 1, FALSE) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead12", "%s",
!Read12(fd, &buffer, &sense, 0, FALSE, TRUE, FALSE, FALSE, 0, blockSize, 0,
1, FALSE) ? "true" : "false");
printf("Trying SCSI READ (16)...\n"); printf("Trying SCSI READ (16)...\n");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead16", "%s", !Read16(fd, &buffer, &sense, 0, FALSE, TRUE, FALSE, 0, blockSize, 0, 1, FALSE) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead16", "%s",
!Read16(fd, &buffer, &sense, 0, FALSE, TRUE, FALSE, 0, blockSize, 0, 1,
FALSE) ? "true" : "false");
uint32_t longBlockSize = blockSize; uint32_t longBlockSize = blockSize;
@@ -608,21 +651,23 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Trying SCSI READ LONG (10)...\n"); printf("Trying SCSI READ LONG (10)...\n");
ReadLong10(fd, &buffer, &sense, FALSE, FALSE, 0, 0xFFFF); ReadLong10(fd, &buffer, &sense, FALSE, FALSE, 0, 0xFFFF);
if((sense[0] == 0x70 || sense[0] == 0x71) && (sense[2] & 0x0F) == 0x05 && sense[12] == 0x24 && sense[13] == 0x00) if((sense[0] == 0x70 || sense[0] == 0x71) && (sense[2] & 0x0F) == 0x05 && sense[12] == 0x24 &&
sense[13] == 0x00)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLong", "%s", "true"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLong", "%s", "true");
supportsReadLong10 = TRUE; supportsReadLong10 = TRUE;
if(sense[0] & 0x80 && sense[2] & 0x20) if(sense[0] & 0x80 && sense[2] & 0x20)
{ {
uint32_t information = (sense[3] << 24) + (sense[4] << 16) + (sense[5] << 8) + sense[6]; uint32_t information = (sense[3] << 24) + (sense[4] << 16) + (sense[5] << 8) + sense[6];
longBlockSize = 0xFFFF - (information & 0xFFFF); longBlockSize = 0xFFFF - (information & 0xFFFF);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LongBlockSize", "%d", longBlockSize); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LongBlockSize", "%d", longBlockSize);
} }
} }
printf("Trying SCSI READ LONG (16)...\n"); printf("Trying SCSI READ LONG (16)...\n");
ReadLong16(fd, &buffer, &sense, FALSE, 0, 0xFFFF); ReadLong16(fd, &buffer, &sense, FALSE, 0, 0xFFFF);
if((sense[0] == 0x70 || sense[0] == 0x71) && (sense[2] & 0x0F) == 0x05 && sense[12] == 0x24 && sense[13] == 0x00) if((sense[0] == 0x70 || sense[0] == 0x71) && (sense[2] & 0x0F) == 0x05 && sense[12] == 0x24 &&
sense[13] == 0x00)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLong16", "%s", "true"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadLong16", "%s", "true");
int i; int i;
@@ -699,7 +744,7 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Drive supports SCSI READ LONG but I cannot find the correct size. Do you want me to try? (This can take hours) (Y/N): "); printf("Drive supports SCSI READ LONG but I cannot find the correct size. Do you want me to try? (This can take hours) (Y/N): ");
scanf("%c", &user_response); scanf("%c", &user_response);
printf("\n"); printf("\n");
} while(user_response != 'Y' && user_response != 'y' && user_response != 'N' && user_response != 'n'); }while(user_response != 'Y' && user_response != 'y' && user_response != 'N' && user_response != 'n');
if(user_response == 'Y' || user_response == 'y') if(user_response == 'Y' || user_response == 'y')
{ {

1
DiscImageChef.Device.Report/scsi_report.h
View File

@@ -8,4 +8,5 @@
#define DIC_SCSI_INQUIRY_ELEMENT "Inquiry" #define DIC_SCSI_INQUIRY_ELEMENT "Inquiry"
void ScsiReport(int fd, xmlTextWriterPtr xmlWriter); void ScsiReport(int fd, xmlTextWriterPtr xmlWriter);
#endif //DISCIMAGECHEF_DEVICE_REPORT_SCSI_REPORT_H #endif //DISCIMAGECHEF_DEVICE_REPORT_SCSI_REPORT_H

136
DiscImageChef.Device.Report/ssc_report.c
View File

@@ -11,14 +11,15 @@
#include "scsi_mode.h" #include "scsi_mode.h"
DensitySupport *DecodeDensity(unsigned char *response); DensitySupport *DecodeDensity(unsigned char *response);
MediaTypeSupport *DecodeMediumTypes(unsigned char *response); MediaTypeSupport *DecodeMediumTypes(unsigned char *response);
void SscReport(int fd, xmlTextWriterPtr xmlWriter) void SscReport(int fd, xmlTextWriterPtr xmlWriter)
{ {
unsigned char *sense = NULL; unsigned char *sense = NULL;
unsigned char *buffer = NULL; unsigned char *buffer = NULL;
int i, error, len; int i, error, len;
char user_response = ' '; char user_response = ' ';
xmlTextWriterStartElement(xmlWriter, BAD_CAST "SequentialDevice"); // <SequentialDevice> xmlTextWriterStartElement(xmlWriter, BAD_CAST "SequentialDevice"); // <SequentialDevice>
@@ -26,7 +27,7 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
error = ReadBlockLimits(fd, &buffer, &sense); error = ReadBlockLimits(fd, &buffer, &sense);
if(!error) if(!error)
{ {
uint8_t granularity = (uint8_t)(buffer[0] & 0x1F); uint8_t granularity = (uint8_t)(buffer[0] & 0x1F);
uint32_t maxBlockLen = (uint32_t)((buffer[1] << 16) + (buffer[2] << 8) + buffer[3]); uint32_t maxBlockLen = (uint32_t)((buffer[1] << 16) + (buffer[2] << 8) + buffer[3]);
uint16_t minBlockLen = (uint16_t)((buffer[4] << 8) + buffer[5]); uint16_t minBlockLen = (uint16_t)((buffer[4] << 8) + buffer[5]);
@@ -49,18 +50,29 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
for(i = 0; i < dsh->count; i++) for(i = 0; i < dsh->count; i++)
{ {
xmlTextWriterStartElement(xmlWriter, BAD_CAST "SupportedDensity"); // <SupportedDensity> xmlTextWriterStartElement(xmlWriter, BAD_CAST "SupportedDensity"); // <SupportedDensity>
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BitsPerMm", "%d", (dsh->descriptors[i]->bitsPerMm[0] << 16) + (dsh->descriptors[i]->bitsPerMm[1] << 8) + dsh->descriptors[i]->bitsPerMm[2]); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BitsPerMm", "%d",
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Capacity", "%d", be32toh(dsh->descriptors[i]->capacity)); (dsh->descriptors[i]->bitsPerMm[0] << 16) +
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DefaultDensity", "%s", dsh->descriptors[i]->deflt ? "true" : "false"); (dsh->descriptors[i]->bitsPerMm[1] << 8) +
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Description", "%20s", dsh->descriptors[i]->description); dsh->descriptors[i]->bitsPerMm[2]);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Duplicate", "%s", dsh->descriptors[i]->dup ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Capacity", "%d",
be32toh(dsh->descriptors[i]->capacity));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DefaultDensity", "%s",
dsh->descriptors[i]->deflt ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Description", "%20s",
dsh->descriptors[i]->description);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Duplicate", "%s",
dsh->descriptors[i]->dup ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Name", "%8s", dsh->descriptors[i]->densityName); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Name", "%8s", dsh->descriptors[i]->densityName);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Organization", "%8s", dsh->descriptors[i]->organization); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Organization", "%8s",
dsh->descriptors[i]->organization);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PrimaryCode", "%d", dsh->descriptors[i]->primaryCode); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PrimaryCode", "%d", dsh->descriptors[i]->primaryCode);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SecondaryCode", "%d", dsh->descriptors[i]->secondaryCode); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SecondaryCode", "%d",
dsh->descriptors[i]->secondaryCode);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Tracks", "%d", be16toh(dsh->descriptors[i]->tracks)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Tracks", "%d", be16toh(dsh->descriptors[i]->tracks));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Width", "%d", be16toh(dsh->descriptors[i]->mediaWidth)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Width", "%d",
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Writable", "%s", dsh->descriptors[i]->wrtok ? "true" : "false"); be16toh(dsh->descriptors[i]->mediaWidth));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Writable", "%s",
dsh->descriptors[i]->wrtok ? "true" : "false");
xmlTextWriterEndElement(xmlWriter); // </SupportedDensity> xmlTextWriterEndElement(xmlWriter); // </SupportedDensity>
} }
@@ -78,12 +90,15 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
for(i = 0; i < mtsh->count; i++) for(i = 0; i < mtsh->count; i++)
{ {
xmlTextWriterStartElement(xmlWriter, BAD_CAST "SupportedMedia"); // <SupportedMedia> xmlTextWriterStartElement(xmlWriter, BAD_CAST "SupportedMedia"); // <SupportedMedia>
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Description", "%20s", mtsh->descriptors[i]->description); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Description", "%20s",
mtsh->descriptors[i]->description);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Length", "%d", be16toh(mtsh->descriptors[i]->length)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Length", "%d", be16toh(mtsh->descriptors[i]->length));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumType", "%d", mtsh->descriptors[i]->mediumType); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumType", "%d", mtsh->descriptors[i]->mediumType);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Name", "%8s", mtsh->descriptors[i]->densityName); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Name", "%8s", mtsh->descriptors[i]->densityName);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Organization", "%8s", mtsh->descriptors[i]->organization); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Organization", "%8s",
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Width", "%d", be16toh(mtsh->descriptors[i]->mediaWidth)); mtsh->descriptors[i]->organization);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Width", "%d",
be16toh(mtsh->descriptors[i]->mediaWidth));
xmlTextWriterStartElement(xmlWriter, BAD_CAST "SupportedDensity"); // <SupportedDensity> xmlTextWriterStartElement(xmlWriter, BAD_CAST "SupportedDensity"); // <SupportedDensity>
// TODO: Density codes // TODO: Density codes
xmlTextWriterEndElement(xmlWriter); // </SupportedMedia> xmlTextWriterEndElement(xmlWriter); // </SupportedMedia>
@@ -93,7 +108,7 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
} }
user_response = ' '; user_response = ' ';
int anyMedia = FALSE; int anyMedia = FALSE;
DecodedMode *decMode; DecodedMode *decMode;
while(user_response != 'N' && user_response != 'n') while(user_response != 'N' && user_response != 'n')
@@ -103,7 +118,7 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Do you have media that you can insert in the drive? (Y/N): "); printf("Do you have media that you can insert in the drive? (Y/N): ");
scanf("%c", &user_response); scanf("%c", &user_response);
printf("\n"); printf("\n");
} while(user_response != 'Y' && user_response != 'y' && user_response != 'N' && user_response != 'n'); }while(user_response != 'Y' && user_response != 'y' && user_response != 'N' && user_response != 'n');
if(user_response == 'Y' || user_response == 'y') if(user_response == 'Y' || user_response == 'y')
{ {
@@ -120,7 +135,7 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
error = TestUnitReady(fd, &sense); error = TestUnitReady(fd, &sense);
int mediaRecognized = TRUE; int mediaRecognized = TRUE;
int leftRetries = 20; int leftRetries = 20;
if(error) if(error)
{ {
@@ -154,16 +169,18 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
xmlTextWriterStartElement(xmlWriter, BAD_CAST "SequentialMedia"); // <SequentialMedia> xmlTextWriterStartElement(xmlWriter, BAD_CAST "SequentialMedia"); // <SequentialMedia>
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediaIsRecognized", "%s", mediaRecognized ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediaIsRecognized", "%s",
mediaRecognized ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Manufacturer", "%s", mediaManufacturer); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Manufacturer", "%s", mediaManufacturer);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumTypeName", "%s",mediaName); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumTypeName", "%s", mediaName);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Model", "%s", mediaModel); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Model", "%s", mediaModel);
if(mediaRecognized) if(mediaRecognized)
{ {
printf("Querying SCSI MODE SENSE (10)...\n"); printf("Querying SCSI MODE SENSE (10)...\n");
error = ModeSense10(fd, &buffer, &sense, FALSE, TRUE, MODE_PAGE_DEFAULT, 0x3F, 0x00); error = ModeSense10(fd, &buffer, &sense, FALSE, TRUE, MODE_PAGE_DEFAULT, 0x3F, 0x00);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense10", "%s", !error ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense10", "%s",
!error ? "true" : "false");
if(!error) if(!error)
{ {
xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense10Data"); xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense10Data");
@@ -174,7 +191,8 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Querying SCSI MODE SENSE (6)...\n"); printf("Querying SCSI MODE SENSE (6)...\n");
error = ModeSense6(fd, &buffer, &sense, FALSE, MODE_PAGE_DEFAULT, 0x00, 0x00); error = ModeSense6(fd, &buffer, &sense, FALSE, MODE_PAGE_DEFAULT, 0x00, 0x00);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense6", "%s", !error ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense6", "%s",
!error ? "true" : "false");
if(!error) if(!error)
{ {
xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense6Data"); xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense6Data");
@@ -188,7 +206,8 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
{ {
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumType", "%d", decMode->Header.MediumType); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumType", "%d", decMode->Header.MediumType);
if(decMode->Header.descriptorsLength > 0) if(decMode->Header.descriptorsLength > 0)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Density", "%d", decMode->Header.BlockDescriptors[0].Density); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Density", "%d",
decMode->Header.BlockDescriptors[0].Density);
} }
printf("Querying SCSI REPORT DENSITY SUPPORT for current media...\n"); printf("Querying SCSI REPORT DENSITY SUPPORT for current media...\n");
@@ -202,18 +221,32 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
for(i = 0; i < dsh->count; i++) for(i = 0; i < dsh->count; i++)
{ {
xmlTextWriterStartElement(xmlWriter, BAD_CAST "SupportedDensity"); // <SupportedDensity> xmlTextWriterStartElement(xmlWriter, BAD_CAST "SupportedDensity"); // <SupportedDensity>
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BitsPerMm", "%d", (dsh->descriptors[i]->bitsPerMm[0] << 16) + (dsh->descriptors[i]->bitsPerMm[1] << 8) + dsh->descriptors[i]->bitsPerMm[2]); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BitsPerMm", "%d",
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Capacity", "%d", be32toh(dsh->descriptors[i]->capacity)); (dsh->descriptors[i]->bitsPerMm[0] << 16) +
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DefaultDensity", "%s", dsh->descriptors[i]->deflt ? "true" : "false"); (dsh->descriptors[i]->bitsPerMm[1] << 8) +
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Description", "%20s", dsh->descriptors[i]->description); dsh->descriptors[i]->bitsPerMm[2]);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Duplicate", "%s", dsh->descriptors[i]->dup ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Capacity", "%d",
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Name", "%8s", dsh->descriptors[i]->densityName); be32toh(dsh->descriptors[i]->capacity));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Organization", "%8s", dsh->descriptors[i]->organization); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DefaultDensity", "%s",
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PrimaryCode", "%d", dsh->descriptors[i]->primaryCode); dsh->descriptors[i]->deflt ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SecondaryCode", "%d", dsh->descriptors[i]->secondaryCode); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Description", "%20s",
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Tracks", "%d", be16toh(dsh->descriptors[i]->tracks)); dsh->descriptors[i]->description);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Width", "%d", be16toh(dsh->descriptors[i]->mediaWidth)); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Duplicate", "%s",
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Writable", "%s", dsh->descriptors[i]->wrtok ? "true" : "false"); dsh->descriptors[i]->dup ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Name", "%8s",
dsh->descriptors[i]->densityName);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Organization", "%8s",
dsh->descriptors[i]->organization);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PrimaryCode", "%d",
dsh->descriptors[i]->primaryCode);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SecondaryCode", "%d",
dsh->descriptors[i]->secondaryCode);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Tracks", "%d",
be16toh(dsh->descriptors[i]->tracks));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Width", "%d",
be16toh(dsh->descriptors[i]->mediaWidth));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Writable", "%s",
dsh->descriptors[i]->wrtok ? "true" : "false");
xmlTextWriterEndElement(xmlWriter); // </SupportedDensity> xmlTextWriterEndElement(xmlWriter); // </SupportedDensity>
} }
@@ -232,12 +265,18 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
for(i = 0; i < mtsh->count; i++) for(i = 0; i < mtsh->count; i++)
{ {
xmlTextWriterStartElement(xmlWriter, BAD_CAST "SupportedMedia"); // <SupportedMedia> xmlTextWriterStartElement(xmlWriter, BAD_CAST "SupportedMedia"); // <SupportedMedia>
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Description", "%20s", mtsh->descriptors[i]->description); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Description", "%20s",
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Length", "%d", be16toh(mtsh->descriptors[i]->length)); mtsh->descriptors[i]->description);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumType", "%d", mtsh->descriptors[i]->mediumType); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Length", "%d",
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Name", "%8s", mtsh->descriptors[i]->densityName); be16toh(mtsh->descriptors[i]->length));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Organization", "%8s", mtsh->descriptors[i]->organization); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumType", "%d",
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Width", "%d", be16toh(mtsh->descriptors[i]->mediaWidth)); mtsh->descriptors[i]->mediumType);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Name", "%8s",
mtsh->descriptors[i]->densityName);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Organization", "%8s",
mtsh->descriptors[i]->organization);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Width", "%d",
be16toh(mtsh->descriptors[i]->mediaWidth));
xmlTextWriterStartElement(xmlWriter, BAD_CAST "SupportedDensity"); // <SupportedDensity> xmlTextWriterStartElement(xmlWriter, BAD_CAST "SupportedDensity"); // <SupportedDensity>
// TODO: Density codes // TODO: Density codes
xmlTextWriterEndElement(xmlWriter); // </SupportedMedia> xmlTextWriterEndElement(xmlWriter); // </SupportedMedia>
@@ -247,7 +286,8 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
} }
printf("Trying SCSI READ MEDIA SERIAL NUMBER...\n"); printf("Trying SCSI READ MEDIA SERIAL NUMBER...\n");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead", "%s", !ReadMediaSerialNumber(fd, &buffer, &sense) ? "true" : "false"); xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsRead", "%s",
!ReadMediaSerialNumber(fd, &buffer, &sense) ? "true" : "false");
} }
xmlTextWriterEndElement(xmlWriter); // </SequentialMedia> xmlTextWriterEndElement(xmlWriter); // </SequentialMedia>
@@ -268,12 +308,12 @@ DensitySupport *DecodeDensity(unsigned char *response)
DensitySupport *decoded = malloc(sizeof(DensitySupport)); DensitySupport *decoded = malloc(sizeof(DensitySupport));
memset(decoded, 0, sizeof(DensitySupport)); memset(decoded, 0, sizeof(DensitySupport));
uint16_t responseLen = (uint16_t)((response[0] << 8) + response[1] + 2); uint16_t responseLen = (uint16_t)((response[0] << 8) + response[1] + 2);
int offset = 4; int offset = 4;
while(offset + 3 < responseLen) while(offset + 3 < responseLen)
{ {
int lenValid = response[offset + 2] & 0x20; int lenValid = response[offset + 2] & 0x20;
uint16_t descLen = (uint16_t)((response[offset + 3] << 8) + response[offset + 4] + 5); uint16_t descLen = (uint16_t)((response[offset + 3] << 8) + response[offset + 4] + 5);
decoded->descriptors[decoded->count] = malloc(sizeof(DensityDescriptor)); decoded->descriptors[decoded->count] = malloc(sizeof(DensityDescriptor));
memset(decoded->descriptors[decoded->count], 0, sizeof(DensityDescriptor)); memset(decoded->descriptors[decoded->count], 0, sizeof(DensityDescriptor));
@@ -293,7 +333,7 @@ MediaTypeSupport *DecodeMediumTypes(unsigned char *response)
MediaTypeSupport *decoded = malloc(sizeof(MediaTypeSupport)); MediaTypeSupport *decoded = malloc(sizeof(MediaTypeSupport));
memset(decoded, 0, sizeof(MediaTypeSupport)); memset(decoded, 0, sizeof(MediaTypeSupport));
uint16_t responseLen = (uint16_t)((response[0] << 8) + response[1] + 2); uint16_t responseLen = (uint16_t)((response[0] << 8) + response[1] + 2);
int offset = 4; int offset = 4;
while(offset + 3 < responseLen) while(offset + 3 < responseLen)
{ {

45
DiscImageChef.Device.Report/ssc_report.h
View File

@@ -4,23 +4,24 @@
#ifndef DISCIMAGECHEF_DEVICE_REPORT_SSC_REPORT_H #ifndef DISCIMAGECHEF_DEVICE_REPORT_SSC_REPORT_H
#define DISCIMAGECHEF_DEVICE_REPORT_SSC_REPORT_H #define DISCIMAGECHEF_DEVICE_REPORT_SSC_REPORT_H
void SscReport(int fd, xmlTextWriterPtr xmlWriter); void SscReport(int fd, xmlTextWriterPtr xmlWriter);
#pragma pack(push, 1) #pragma pack(push, 1)
typedef struct typedef struct
{ {
uint8_t primaryCode; uint8_t primaryCode;
uint8_t secondaryCode; uint8_t secondaryCode;
uint8_t dlv : 1; uint8_t dlv : 1;
uint8_t reserved : 4; uint8_t reserved : 4;
uint8_t deflt : 1; uint8_t deflt : 1;
uint8_t dup : 1; uint8_t dup : 1;
uint8_t wrtok : 1; uint8_t wrtok : 1;
uint16_t length; uint16_t length;
uint8_t bitsPerMm[3]; uint8_t bitsPerMm[3];
uint16_t mediaWidth; uint16_t mediaWidth;
uint16_t tracks; uint16_t tracks;
uint32_t capacity; uint32_t capacity;
unsigned char organization[8]; unsigned char organization[8];
unsigned char densityName[8]; unsigned char densityName[8];
unsigned char description[20]; unsigned char description[20];
@@ -30,14 +31,14 @@ typedef struct
#pragma pack(push, 1) #pragma pack(push, 1)
typedef struct typedef struct
{ {
uint8_t mediumType; uint8_t mediumType;
uint8_t reserved; uint8_t reserved;
uint16_t length; uint16_t length;
uint8_t codes_len; uint8_t codes_len;
uint8_t codes[9]; uint8_t codes[9];
uint16_t mediaWidth; uint16_t mediaWidth;
uint16_t mediumLength; uint16_t mediumLength;
uint16_t reserved2; uint16_t reserved2;
unsigned char organization[8]; unsigned char organization[8];
unsigned char densityName[8]; unsigned char densityName[8];
unsigned char description[20]; unsigned char description[20];
@@ -46,13 +47,13 @@ typedef struct
typedef struct typedef struct
{ {
uint16_t count; uint16_t count;
DensityDescriptor *descriptors[1260]; DensityDescriptor *descriptors[1260];
} DensitySupport; } DensitySupport;
typedef struct typedef struct
{ {
uint16_t count; uint16_t count;
MediumDescriptor *descriptors[1170]; MediumDescriptor *descriptors[1170];
} MediaTypeSupport; } MediaTypeSupport;
#endif //DISCIMAGECHEF_DEVICE_REPORT_SSC_REPORT_H #endif //DISCIMAGECHEF_DEVICE_REPORT_SSC_REPORT_H