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

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

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

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

@@ -10,14 +10,14 @@
void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
{
unsigned char *ata_ident = NULL;
unsigned char *buffer = NULL;
AtaErrorRegistersCHS *ata_error_chs;
unsigned char *ata_ident = NULL;
unsigned char *buffer = NULL;
AtaErrorRegistersCHS *ata_error_chs;
AtaErrorRegistersLBA28 *ata_error_lba;
AtaErrorRegistersLBA48 *ata_error_lba48;
int error;
int removable = FALSE;
char user_response = ' ';
int error;
int removable = FALSE;
char user_response = ' ';
printf("Querying ATA IDENTIFY...\n");
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): ");
scanf("%c", &user_response);
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');
}
@@ -64,15 +64,18 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
if((uint64_t)*identify->AdditionalPID != 0 && (uint64_t)*identify->AdditionalPID != 0x2020202020202020)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "AdditionalPid", AtaToCString(identify->AdditionalPID, 8));
if(identify->APIOSupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "APIOSupported", DecodeTransferMode(le16toh(identify->APIOSupported)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "APIOSupported",
DecodeTransferMode(le16toh(identify->APIOSupported)));
if(identify->BufferType)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BufferType", "%u", le16toh(identify->BufferType));
if(identify->BufferSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BufferSize", "%u", le16toh(identify->BufferSize));
if(identify->Capabilities)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities", DecodeCapabilities(le16toh(identify->Capabilities)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities",
DecodeCapabilities(le16toh(identify->Capabilities)));
if(identify->Capabilities2)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities2", DecodeCapabilities2(le16toh(identify->Capabilities2)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities2",
DecodeCapabilities2(le16toh(identify->Capabilities2)));
if(identify->Capabilities3)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities3", DecodeCapabilities3(identify->Capabilities3));
if(identify->CFAPowerMode)
@@ -94,127 +97,173 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
if(identify->DataSetMgmt)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DataSetMgmt", DecodeDataSetMgmt(le16toh(identify->DataSetMgmt)));
if(identify->DataSetMgmtSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DataSetMgmtSize", "%u", le16toh(identify->DataSetMgmtSize));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DataSetMgmtSize", "%u",
le16toh(identify->DataSetMgmtSize));
if(identify->DeviceFormFactor)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DeviceFormFactor", DecodeDeviceFormFactor(le16toh(identify->DeviceFormFactor)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DeviceFormFactor",
DecodeDeviceFormFactor(le16toh(identify->DeviceFormFactor)));
if(identify->DMAActive)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMAActive", DecodeTransferMode(le16toh(identify->DMAActive)));
if(identify->DMASupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMASupported", DecodeTransferMode(le16toh(identify->DMASupported)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMASupported",
DecodeTransferMode(le16toh(identify->DMASupported)));
if(identify->DMATransferTimingMode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DMATransferTimingMode", "%u", identify->DMATransferTimingMode);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DMATransferTimingMode", "%u",
identify->DMATransferTimingMode);
if(identify->EnhancedSecurityEraseTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "EnhancedSecurityEraseTime", "%u", le16toh(identify->EnhancedSecurityEraseTime));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "EnhancedSecurityEraseTime", "%u",
le16toh(identify->EnhancedSecurityEraseTime));
if(identify->EnabledCommandSet)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet", DecodeCommandSet(le16toh(identify->EnabledCommandSet)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet",
DecodeCommandSet(le16toh(identify->EnabledCommandSet)));
if(identify->EnabledCommandSet2)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet2", DecodeCommandSet2(le16toh(identify->EnabledCommandSet2)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet2",
DecodeCommandSet2(le16toh(identify->EnabledCommandSet2)));
if(identify->EnabledCommandSet3)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet3", DecodeCommandSet3(le16toh(identify->EnabledCommandSet3)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet3",
DecodeCommandSet3(le16toh(identify->EnabledCommandSet3)));
if(identify->EnabledCommandSet4)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet4", DecodeCommandSet4(le16toh(identify->EnabledCommandSet4)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet4",
DecodeCommandSet4(le16toh(identify->EnabledCommandSet4)));
if(identify->EnabledSATAFeatures)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledSATAFeatures", DecodeSATAFeatures(le16toh(identify->EnabledSATAFeatures)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledSATAFeatures",
DecodeSATAFeatures(le16toh(identify->EnabledSATAFeatures)));
if(identify->ExtendedUserSectors)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ExtendedUserSectors", "%llu", le64toh(identify->ExtendedUserSectors));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ExtendedUserSectors", "%llu",
le64toh(identify->ExtendedUserSectors));
if(identify->FreeFallSensitivity)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "FreeFallSensitivity", "%u", identify->FreeFallSensitivity);
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "FirmwareRevision", AtaToCString(identify->FirmwareRevision, 8));
if(identify->GeneralConfiguration)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "GeneralConfiguration", DecodeGeneralConfiguration(le16toh(identify->GeneralConfiguration)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "GeneralConfiguration",
DecodeGeneralConfiguration(le16toh(identify->GeneralConfiguration)));
if(identify->HardwareResetResult)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "HardwareResetResult", "%u", le16toh(identify->HardwareResetResult));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "HardwareResetResult", "%u",
le16toh(identify->HardwareResetResult));
if(identify->InterseekDelay)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "InterseekDelay", "%u", le16toh(identify->InterseekDelay));
if(identify->MajorVersion)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MajorVersion", DecodeMajorVersion(le16toh(identify->MajorVersion)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MajorVersion",
DecodeMajorVersion(le16toh(identify->MajorVersion)));
if(identify->MasterPasswordRevisionCode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MasterPasswordRevisionCode", "%u", le16toh(identify->MasterPasswordRevisionCode));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MasterPasswordRevisionCode", "%u",
le16toh(identify->MasterPasswordRevisionCode));
if(identify->MaxDownloadMicroMode3)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxDownloadMicroMode3", "%u", le16toh(identify->MaxDownloadMicroMode3));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxDownloadMicroMode3", "%u",
le16toh(identify->MaxDownloadMicroMode3));
if(identify->MaxQueueDepth)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxQueueDepth", "%u", le16toh(identify->MaxQueueDepth));
if(identify->MDMAActive)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMAActive", DecodeTransferMode(le16toh(identify->MDMAActive)));
if(identify->MDMASupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMASupported", DecodeTransferMode(le16toh(identify->MDMASupported)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMASupported",
DecodeTransferMode(le16toh(identify->MDMASupported)));
if(identify->MinDownloadMicroMode3)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinDownloadMicroMode3", "%u", le16toh(identify->MinDownloadMicroMode3));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinDownloadMicroMode3", "%u",
le16toh(identify->MinDownloadMicroMode3));
if(identify->MinMDMACycleTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinMDMACycleTime", "%u", le16toh(identify->MinMDMACycleTime));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinMDMACycleTime", "%u",
le16toh(identify->MinMDMACycleTime));
if(identify->MinorVersion)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinorVersion", "%u", le16toh(identify->MinorVersion));
if(identify->MinPIOCycleTimeNoFlow)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinPIOCycleTimeNoFlow", "%u", le16toh(identify->MinPIOCycleTimeNoFlow));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinPIOCycleTimeNoFlow", "%u",
le16toh(identify->MinPIOCycleTimeNoFlow));
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));
if(identify->MultipleMaxSectors)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleMaxSectors", "%u", identify->MultipleMaxSectors);
if(identify->MultipleSectorNumber)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleSectorNumber", "%u", identify->MultipleSectorNumber);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleSectorNumber", "%u",
identify->MultipleSectorNumber);
if(identify->NVCacheCaps)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheCaps", "%u", le16toh(identify->NVCacheCaps));
if(identify->NVCacheSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheSize", "%u", le32toh(identify->NVCacheSize));
if(identify->NVCacheWriteSpeed)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheWriteSpeed", "%u", le16toh(identify->NVCacheWriteSpeed));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheWriteSpeed", "%u",
le16toh(identify->NVCacheWriteSpeed));
if(identify->NVEstimatedSpinUp)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVEstimatedSpinUp", "%u", identify->NVEstimatedSpinUp);
if(identify->PacketBusRelease)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PacketBusRelease", "%u", le16toh(identify->PacketBusRelease));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PacketBusRelease", "%u",
le16toh(identify->PacketBusRelease));
if(identify->PIOTransferTimingMode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PIOTransferTimingMode", "%u", identify->PIOTransferTimingMode);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PIOTransferTimingMode", "%u",
identify->PIOTransferTimingMode);
if(identify->RecommendedAAM)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecommendedAAM", "%u", identify->RecommendedAAM);
if(identify->RecMDMACycleTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecMDMACycleTime", "%u", le16toh(identify->RecMDMACycleTime));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecMDMACycleTime", "%u",
le16toh(identify->RecMDMACycleTime));
if(identify->RemovableStatusSet)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RemovableStatusSet", "%u", le16toh(identify->RemovableStatusSet));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RemovableStatusSet", "%u",
le16toh(identify->RemovableStatusSet));
if(identify->SATACapabilities)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities", DecodeSATACapabilities(le16toh(identify->SATACapabilities)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities",
DecodeSATACapabilities(le16toh(identify->SATACapabilities)));
if(identify->SATACapabilities2)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities2", DecodeSATACapabilities2(le16toh(identify->SATACapabilities2)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities2",
DecodeSATACapabilities2(le16toh(identify->SATACapabilities2)));
if(identify->SATAFeatures)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATAFeatures", DecodeSATAFeatures(le16toh(identify->SATAFeatures)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATAFeatures",
DecodeSATAFeatures(le16toh(identify->SATAFeatures)));
if(identify->SCTCommandTransport)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SCTCommandTransport", DecodeSCTCommandTransport(le16toh(identify->SCTCommandTransport)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SCTCommandTransport",
DecodeSCTCommandTransport(le16toh(identify->SCTCommandTransport)));
if(identify->SectorsPerCard)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SectorsPerCard", "%u", le32toh(identify->SectorsPerCard));
if(identify->SecurityEraseTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SecurityEraseTime", "%u", le16toh(identify->SecurityEraseTime));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SecurityEraseTime", "%u",
le16toh(identify->SecurityEraseTime));
if(identify->SecurityStatus)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SecurityStatus", DecodeSecurityStatus(le16toh(identify->SecurityStatus)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SecurityStatus",
DecodeSecurityStatus(le16toh(identify->SecurityStatus)));
if(identify->ServiceBusyClear)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ServiceBusyClear", "%u", le16toh(identify->ServiceBusyClear));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ServiceBusyClear", "%u",
le16toh(identify->ServiceBusyClear));
if(identify->SpecificConfiguration)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SpecificConfiguration", DecodeSpecificConfiguration(le16toh(identify->SpecificConfiguration)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SpecificConfiguration",
DecodeSpecificConfiguration(le16toh(identify->SpecificConfiguration)));
if(identify->StreamAccessLatency)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamAccessLatency", "%u", le16toh(identify->StreamAccessLatency));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamAccessLatency", "%u",
le16toh(identify->StreamAccessLatency));
if(identify->StreamMinReqSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamMinReqSize", "%u", le16toh(identify->StreamMinReqSize));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamMinReqSize", "%u",
le16toh(identify->StreamMinReqSize));
if(identify->StreamPerformanceGranularity)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamPerformanceGranularity", "%u", le32toh(identify->StreamPerformanceGranularity));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamPerformanceGranularity", "%u",
le32toh(identify->StreamPerformanceGranularity));
if(identify->StreamTransferTimeDMA)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimeDMA", "%u", le16toh(identify->StreamTransferTimeDMA));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimeDMA", "%u",
le16toh(identify->StreamTransferTimeDMA));
if(identify->StreamTransferTimePIO)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimePIO", "%u", le16toh(identify->StreamTransferTimePIO));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimePIO", "%u",
le16toh(identify->StreamTransferTimePIO));
if(identify->TransportMajorVersion)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMajorVersion", "%u", le16toh(identify->TransportMajorVersion));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMajorVersion", "%u",
le16toh(identify->TransportMajorVersion));
if(identify->TransportMinorVersion)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMinorVersion", "%u", le16toh(identify->TransportMinorVersion));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMinorVersion", "%u",
le16toh(identify->TransportMinorVersion));
if(identify->TrustedComputing)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "TrustedComputing", DecodeTrustedComputing(le16toh(identify->TrustedComputing)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "TrustedComputing",
DecodeTrustedComputing(le16toh(identify->TrustedComputing)));
if(identify->UDMAActive)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMAActive", DecodeTransferMode(le16toh(identify->UDMAActive)));
if(identify->UDMASupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMASupported", DecodeTransferMode(le16toh(identify->UDMASupported)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMASupported",
DecodeTransferMode(le16toh(identify->UDMASupported)));
if(identify->WRVMode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVMode", "%u", identify->WRVMode);
if(identify->WRVSectorCountMode3)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVSectorCountMode3", "%u", le32toh(identify->WRVSectorCountMode3));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVSectorCountMode3", "%u",
le32toh(identify->WRVSectorCountMode3));
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");
xmlTextWriterWriteBase64(xmlWriter, ata_ident, 0, 512);
@@ -273,42 +322,53 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
memcpy(identify, ata_ident, 512);
if(identify->UnformattedBPT)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPT", "%u", le16toh(identify->UnformattedBPT));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPT", "%u",
le16toh(identify->UnformattedBPT));
if(identify->UnformattedBPS)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPS", "%u", le16toh(identify->UnformattedBPS));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPS", "%u",
le16toh(identify->UnformattedBPS));
uint64_t blocks;
if(identify->Cylinders > 0 && identify->Heads > 0 && identify->SectorsPerTrack != 0)
{
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 "Sectors", "%u", le16toh(identify->SectorsPerTrack));
blocks = le16toh(identify->Cylinders) * le16toh(identify->Heads) * le16toh(identify->SectorsPerTrack);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Sectors", "%u",
le16toh(identify->SectorsPerTrack));
blocks = le16toh(identify->Cylinders) * le16toh(identify->Heads) *
le16toh(identify->SectorsPerTrack);
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>
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 "Sectors", "%u", le16toh(identify->CurrentSectorsPerTrack));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Sectors", "%u",
le16toh(identify->CurrentSectorsPerTrack));
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>
}
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);
}
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);
}
@@ -319,15 +379,16 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
else
{
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;
if((le16toh(identify->PhysLogSectorSize) & 0x8000) == 0x0000 &&
(le16toh(identify->PhysLogSectorSize) & 0x4000) == 0x4000)
(le16toh(identify->PhysLogSectorSize) & 0x4000) == 0x4000)
{
if(le16toh(identify->PhysLogSectorSize) & 0x1000)
{
@@ -346,7 +407,7 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
}
else
{
logicalsectorsize = 512;
logicalsectorsize = 512;
physicalsectorsize = 512;
}
@@ -355,94 +416,133 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
{
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PhysicalBlockSize", "%u", physicalsectorsize);
if((le16toh(identify->LogicalAlignment) & 0x8000) == 0x0000 &&
(le16toh(identify->LogicalAlignment) & 0x4000) == 0x4000)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LogicalAlignment", "%u", le16toh(identify->LogicalAlignment) & 0x3FFF);
(le16toh(identify->LogicalAlignment) & 0x4000) == 0x4000)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LogicalAlignment", "%u",
le16toh(identify->LogicalAlignment) & 0x3FFF);
}
uint16_t longblocksize = 0;
if(identify->EccBytes != 0x0000 && identify->EccBytes != 0xFFFF)
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);
if(longblocksize > 0)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LongBlockSize", "%u", longblocksize);
if((le16toh(identify->CommandSet3) & 0x8000) == 0x0000 &&
(le16toh(identify->CommandSet3) & 0x4000) == 0x4000 &&
(le16toh(identify->EnabledCommandSet3) & 0x0004) == 0x0004)
(le16toh(identify->CommandSet3) & 0x4000) == 0x4000 &&
(le16toh(identify->EnabledCommandSet3) & 0x0004) == 0x0004)
{
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
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Manufacturer", "%s", mediaManufacturer);
printf("Trying READ SECTOR(S) in CHS mode...\n");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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>
@@ -465,9 +565,11 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
memcpy(identify, ata_ident, 512);
if(identify->UnformattedBPT)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPT", "%u", le16toh(identify->UnformattedBPT));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPT", "%u",
le16toh(identify->UnformattedBPT));
if(identify->UnformattedBPS)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPS", "%u", le16toh(identify->UnformattedBPS));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "UnformattedBPS", "%u",
le16toh(identify->UnformattedBPS));
uint64_t blocks;
@@ -486,9 +588,11 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
xmlTextWriterStartElement(xmlWriter, BAD_CAST "CurrentCHS"); // <CurrentCHS>
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Cylinders", "%u", le16toh(identify->CurrentCylinders));
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)
blocks = le16toh(identify->CurrentCylinders) * le16toh(identify->CurrentHeads) * le16toh(identify->CurrentSectorsPerTrack);
blocks = le16toh(identify->CurrentCylinders) * le16toh(identify->CurrentHeads) *
le16toh(identify->CurrentSectorsPerTrack);
xmlTextWriterEndElement(xmlWriter); // </CurrentCHS>
}
@@ -500,7 +604,8 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
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);
}
@@ -511,11 +616,12 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
else
{
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;
if((le16toh(identify->PhysLogSectorSize) & 0x8000) == 0x0000 &&
@@ -538,7 +644,7 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
}
else
{
logicalsectorsize = 512;
logicalsectorsize = 512;
physicalsectorsize = 512;
}
@@ -548,7 +654,8 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PhysicalBlockSize", "%u", physicalsectorsize);
if((le16toh(identify->LogicalAlignment) & 0x8000) == 0x0000 &&
(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;
@@ -561,78 +668,114 @@ void AtaReport(int fd, xmlTextWriterPtr xmlWriter)
if(longblocksize > 0)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LongBlockSize", "%u", longblocksize);
if((le16toh(identify->CommandSet3) & 0x8000) == 0x0000 &&
(le16toh(identify->CommandSet3) & 0x4000) == 0x4000 &&
if((le16toh(identify->CommandSet3) & 0x8000) == 0x0000 && (le16toh(identify->CommandSet3) & 0x4000) == 0x4000 &&
(le16toh(identify->EnabledCommandSet3) & 0x0004) == 0x0004)
{
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");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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");
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>
}

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

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

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

@@ -4,6 +4,7 @@
#include <malloc.h>
#include <string.h>
#include <stdint.h>
#include "ata.h"
#include "atapi.h"
@@ -16,7 +17,8 @@ int IdentifyPacket(int fd, unsigned char **buffer, AtaErrorRegistersCHS **errorR
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;
}

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

@@ -4,5 +4,7 @@
#ifndef DISCIMAGECHEF_DEVICE_REPORT_ATAPI_H
#define DISCIMAGECHEF_DEVICE_REPORT_ATAPI_H
int IdentifyPacket(int fd, unsigned char **buffer, AtaErrorRegistersCHS **errorRegisters);
#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)
{
unsigned char *atapi_ident = NULL;
unsigned char *atapi_ident = NULL;
AtaErrorRegistersCHS *ata_error_chs;
int error;
int error;
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)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "AdditionalPid", AtaToCString(identify->AdditionalPID, 8));
if(identify->APIOSupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "APIOSupported", DecodeTransferMode(le16toh(identify->APIOSupported)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "APIOSupported",
DecodeTransferMode(le16toh(identify->APIOSupported)));
if(identify->ATAPIByteCount)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ATAPIByteCount", "%u", le16toh(identify->ATAPIByteCount));
if(identify->BufferType)
@@ -41,9 +42,11 @@ void AtapiReport(int fd, xmlTextWriterPtr xmlWriter)
if(identify->BufferSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BufferSize", "%u", le16toh(identify->BufferSize));
if(identify->Capabilities)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities", DecodeCapabilities(le16toh(identify->Capabilities)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities",
DecodeCapabilities(le16toh(identify->Capabilities)));
if(identify->Capabilities2)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities2", DecodeCapabilities2(le16toh(identify->Capabilities2)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities2",
DecodeCapabilities2(le16toh(identify->Capabilities2)));
if(identify->Capabilities3)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "Capabilities3", DecodeCapabilities3(identify->Capabilities3));
if(identify->CFAPowerMode)
@@ -65,127 +68,173 @@ void AtapiReport(int fd, xmlTextWriterPtr xmlWriter)
if(identify->DataSetMgmt)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DataSetMgmt", DecodeDataSetMgmt(le16toh(identify->DataSetMgmt)));
if(identify->DataSetMgmtSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DataSetMgmtSize", "%u", le16toh(identify->DataSetMgmtSize));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DataSetMgmtSize", "%u",
le16toh(identify->DataSetMgmtSize));
if(identify->DeviceFormFactor)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DeviceFormFactor", DecodeDeviceFormFactor(le16toh(identify->DeviceFormFactor)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DeviceFormFactor",
DecodeDeviceFormFactor(le16toh(identify->DeviceFormFactor)));
if(identify->DMAActive)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMAActive", DecodeTransferMode(le16toh(identify->DMAActive)));
if(identify->DMASupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMASupported", DecodeTransferMode(le16toh(identify->DMASupported)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "DMASupported",
DecodeTransferMode(le16toh(identify->DMASupported)));
if(identify->DMATransferTimingMode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DMATransferTimingMode", "%u", identify->DMATransferTimingMode);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DMATransferTimingMode", "%u",
identify->DMATransferTimingMode);
if(identify->EnhancedSecurityEraseTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "EnhancedSecurityEraseTime", "%u", le16toh(identify->EnhancedSecurityEraseTime));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "EnhancedSecurityEraseTime", "%u",
le16toh(identify->EnhancedSecurityEraseTime));
if(identify->EnabledCommandSet)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet", DecodeCommandSet(le16toh(identify->EnabledCommandSet)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet",
DecodeCommandSet(le16toh(identify->EnabledCommandSet)));
if(identify->EnabledCommandSet2)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet2", DecodeCommandSet2(le16toh(identify->EnabledCommandSet2)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet2",
DecodeCommandSet2(le16toh(identify->EnabledCommandSet2)));
if(identify->EnabledCommandSet3)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet3", DecodeCommandSet3(le16toh(identify->EnabledCommandSet3)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet3",
DecodeCommandSet3(le16toh(identify->EnabledCommandSet3)));
if(identify->EnabledCommandSet4)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet4", DecodeCommandSet4(le16toh(identify->EnabledCommandSet4)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledCommandSet4",
DecodeCommandSet4(le16toh(identify->EnabledCommandSet4)));
if(identify->EnabledSATAFeatures)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledSATAFeatures", DecodeSATAFeatures(le16toh(identify->EnabledSATAFeatures)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "EnabledSATAFeatures",
DecodeSATAFeatures(le16toh(identify->EnabledSATAFeatures)));
if(identify->ExtendedUserSectors)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ExtendedUserSectors", "%llu", le64toh(identify->ExtendedUserSectors));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ExtendedUserSectors", "%llu",
le64toh(identify->ExtendedUserSectors));
if(identify->FreeFallSensitivity)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "FreeFallSensitivity", "%u", identify->FreeFallSensitivity);
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "FirmwareRevision", AtaToCString(identify->FirmwareRevision, 8));
if(identify->GeneralConfiguration)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "GeneralConfiguration", DecodeGeneralConfiguration(le16toh(identify->GeneralConfiguration)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "GeneralConfiguration",
DecodeGeneralConfiguration(le16toh(identify->GeneralConfiguration)));
if(identify->HardwareResetResult)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "HardwareResetResult", "%u", le16toh(identify->HardwareResetResult));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "HardwareResetResult", "%u",
le16toh(identify->HardwareResetResult));
if(identify->InterseekDelay)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "InterseekDelay", "%u", le16toh(identify->InterseekDelay));
if(identify->MajorVersion)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MajorVersion", DecodeMajorVersion(le16toh(identify->MajorVersion)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MajorVersion",
DecodeMajorVersion(le16toh(identify->MajorVersion)));
if(identify->MasterPasswordRevisionCode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MasterPasswordRevisionCode", "%u", le16toh(identify->MasterPasswordRevisionCode));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MasterPasswordRevisionCode", "%u",
le16toh(identify->MasterPasswordRevisionCode));
if(identify->MaxDownloadMicroMode3)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxDownloadMicroMode3", "%u", le16toh(identify->MaxDownloadMicroMode3));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxDownloadMicroMode3", "%u",
le16toh(identify->MaxDownloadMicroMode3));
if(identify->MaxQueueDepth)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MaxQueueDepth", "%u", le16toh(identify->MaxQueueDepth));
if(identify->MDMAActive)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMAActive", DecodeTransferMode(le16toh(identify->MDMAActive)));
if(identify->MDMASupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMASupported", DecodeTransferMode(le16toh(identify->MDMASupported)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "MDMASupported",
DecodeTransferMode(le16toh(identify->MDMASupported)));
if(identify->MinDownloadMicroMode3)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinDownloadMicroMode3", "%u", le16toh(identify->MinDownloadMicroMode3));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinDownloadMicroMode3", "%u",
le16toh(identify->MinDownloadMicroMode3));
if(identify->MinMDMACycleTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinMDMACycleTime", "%u", le16toh(identify->MinMDMACycleTime));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinMDMACycleTime", "%u",
le16toh(identify->MinMDMACycleTime));
if(identify->MinorVersion)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinorVersion", "%u", le16toh(identify->MinorVersion));
if(identify->MinPIOCycleTimeNoFlow)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinPIOCycleTimeNoFlow", "%u", le16toh(identify->MinPIOCycleTimeNoFlow));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MinPIOCycleTimeNoFlow", "%u",
le16toh(identify->MinPIOCycleTimeNoFlow));
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));
if(identify->MultipleMaxSectors)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleMaxSectors", "%u", identify->MultipleMaxSectors);
if(identify->MultipleSectorNumber)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleSectorNumber", "%u", identify->MultipleSectorNumber);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MultipleSectorNumber", "%u",
identify->MultipleSectorNumber);
if(identify->NVCacheCaps)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheCaps", "%u", le16toh(identify->NVCacheCaps));
if(identify->NVCacheSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheSize", "%u", le32toh(identify->NVCacheSize));
if(identify->NVCacheWriteSpeed)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheWriteSpeed", "%u", le16toh(identify->NVCacheWriteSpeed));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVCacheWriteSpeed", "%u",
le16toh(identify->NVCacheWriteSpeed));
if(identify->NVEstimatedSpinUp)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "NVEstimatedSpinUp", "%u", identify->NVEstimatedSpinUp);
if(identify->PacketBusRelease)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PacketBusRelease", "%u", le16toh(identify->PacketBusRelease));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PacketBusRelease", "%u",
le16toh(identify->PacketBusRelease));
if(identify->PIOTransferTimingMode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PIOTransferTimingMode", "%u", identify->PIOTransferTimingMode);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PIOTransferTimingMode", "%u",
identify->PIOTransferTimingMode);
if(identify->RecommendedAAM)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecommendedAAM", "%u", identify->RecommendedAAM);
if(identify->RecMDMACycleTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecMDMACycleTime", "%u", le16toh(identify->RecMDMACycleTime));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RecMDMACycleTime", "%u",
le16toh(identify->RecMDMACycleTime));
if(identify->RemovableStatusSet)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RemovableStatusSet", "%u", le16toh(identify->RemovableStatusSet));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "RemovableStatusSet", "%u",
le16toh(identify->RemovableStatusSet));
if(identify->SATACapabilities)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities", DecodeSATACapabilities(le16toh(identify->SATACapabilities)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities",
DecodeSATACapabilities(le16toh(identify->SATACapabilities)));
if(identify->SATACapabilities2)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities2", DecodeSATACapabilities2(le16toh(identify->SATACapabilities2)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATACapabilities2",
DecodeSATACapabilities2(le16toh(identify->SATACapabilities2)));
if(identify->SATAFeatures)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATAFeatures", DecodeSATAFeatures(le16toh(identify->SATAFeatures)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SATAFeatures",
DecodeSATAFeatures(le16toh(identify->SATAFeatures)));
if(identify->SCTCommandTransport)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SCTCommandTransport", DecodeSCTCommandTransport(le16toh(identify->SCTCommandTransport)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SCTCommandTransport",
DecodeSCTCommandTransport(le16toh(identify->SCTCommandTransport)));
if(identify->SectorsPerCard)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SectorsPerCard", "%u", le32toh(identify->SectorsPerCard));
if(identify->SecurityEraseTime)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SecurityEraseTime", "%u", le16toh(identify->SecurityEraseTime));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SecurityEraseTime", "%u",
le16toh(identify->SecurityEraseTime));
if(identify->SecurityStatus)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SecurityStatus", DecodeSecurityStatus(le16toh(identify->SecurityStatus)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SecurityStatus",
DecodeSecurityStatus(le16toh(identify->SecurityStatus)));
if(identify->ServiceBusyClear)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ServiceBusyClear", "%u", le16toh(identify->ServiceBusyClear));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "ServiceBusyClear", "%u",
le16toh(identify->ServiceBusyClear));
if(identify->SpecificConfiguration)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SpecificConfiguration", DecodeSpecificConfiguration(le16toh(identify->SpecificConfiguration)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "SpecificConfiguration",
DecodeSpecificConfiguration(le16toh(identify->SpecificConfiguration)));
if(identify->StreamAccessLatency)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamAccessLatency", "%u", le16toh(identify->StreamAccessLatency));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamAccessLatency", "%u",
le16toh(identify->StreamAccessLatency));
if(identify->StreamMinReqSize)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamMinReqSize", "%u", le16toh(identify->StreamMinReqSize));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamMinReqSize", "%u",
le16toh(identify->StreamMinReqSize));
if(identify->StreamPerformanceGranularity)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamPerformanceGranularity", "%u", le32toh(identify->StreamPerformanceGranularity));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamPerformanceGranularity", "%u",
le32toh(identify->StreamPerformanceGranularity));
if(identify->StreamTransferTimeDMA)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimeDMA", "%u", le16toh(identify->StreamTransferTimeDMA));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimeDMA", "%u",
le16toh(identify->StreamTransferTimeDMA));
if(identify->StreamTransferTimePIO)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimePIO", "%u", le16toh(identify->StreamTransferTimePIO));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "StreamTransferTimePIO", "%u",
le16toh(identify->StreamTransferTimePIO));
if(identify->TransportMajorVersion)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMajorVersion", "%u", le16toh(identify->TransportMajorVersion));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMajorVersion", "%u",
le16toh(identify->TransportMajorVersion));
if(identify->TransportMinorVersion)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMinorVersion", "%u", le16toh(identify->TransportMinorVersion));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "TransportMinorVersion", "%u",
le16toh(identify->TransportMinorVersion));
if(identify->TrustedComputing)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "TrustedComputing", DecodeTrustedComputing(le16toh(identify->TrustedComputing)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "TrustedComputing",
DecodeTrustedComputing(le16toh(identify->TrustedComputing)));
if(identify->UDMAActive)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMAActive", DecodeTransferMode(le16toh(identify->UDMAActive)));
if(identify->UDMASupported)
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMASupported", DecodeTransferMode(le16toh(identify->UDMASupported)));
xmlTextWriterWriteElement(xmlWriter, BAD_CAST "UDMASupported",
DecodeTransferMode(le16toh(identify->UDMASupported)));
if(identify->WRVMode)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVMode", "%u", identify->WRVMode);
if(identify->WRVSectorCountMode3)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVSectorCountMode3", "%u", le32toh(identify->WRVSectorCountMode3));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WRVSectorCountMode3", "%u",
le32toh(identify->WRVSectorCountMode3));
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>
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
#define DISCIMAGECHEF_DEVICE_REPORT_ATAPI_REPORT_H
#include <libxml/xmlwriter.h>
#define DIC_ATAPI_REPORT_ELEMENT "ATAPI"
void AtapiReport(int fd, xmlTextWriterPtr xmlWriter);
#endif //DISCIMAGECHEF_DEVICE_REPORT_ATAPI_REPORT_H

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

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

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

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

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

@@ -4,24 +4,45 @@
#ifndef DISCIMAGECHEF_DEVICE_REPORT_IDENTIFY_DECODE_H
#define DISCIMAGECHEF_DEVICE_REPORT_IDENTIFY_DECODE_H
char *DecodeGeneralConfiguration(uint16_t configuration);
char *DecodeTransferMode(uint16_t transferMode);
char *DecodeCapabilities(uint16_t capabilities);
char *DecodeCapabilities2(uint16_t capabilities);
char *DecodeCapabilities3(uint8_t capabilities);
char *DecodeCommandSet(uint16_t commandset);
char *DecodeCommandSet2(uint16_t commandset);
char *DecodeCommandSet3(uint16_t commandset);
char *DecodeCommandSet4(uint16_t commandset);
char *DecodeCommandSet5(uint16_t commandset);
char *DecodeDataSetMgmt(uint16_t datasetmgmt);
char *DecodeDeviceFormFactor(uint16_t formfactor);
char *DecodeSATAFeatures(uint16_t features);
char *DecodeMajorVersion(uint16_t capabilities);
char *DecodeSATACapabilities(uint16_t capabilities);
char *DecodeSATACapabilities2(uint16_t transport);
char *DecodeSCTCommandTransport(uint16_t transport);
char *DecodeSecurityStatus(uint16_t status);
char *DecodeSpecificConfiguration(uint16_t configuration);
char *DecodeTrustedComputing(uint16_t trutedcomputing);
#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
#define DISCIMAGECHEF_DEVICE_REPORT_INQUIRY_DECODE_H
#include <stdint.h>
char *DecodeTPGSValues(uint8_t capabilities);
char *DecodePeripheralDeviceType(uint8_t capabilities);
char *DecodePeripheralQualifier(uint8_t capabilities);
char *DecodeSPIClocking(uint8_t capabilities);
#endif //DISCIMAGECHEF_DEVICE_REPORT_INQUIRY_DECODE_H

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

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

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

@@ -17,5 +17,6 @@ typedef enum
DEVICE_TYPE_SD
} 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

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
#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
{
int present;
size_t len;
unsigned char* data;
int present;
size_t len;
unsigned char *data;
} FeatureDescriptors;
typedef struct
{
uint32_t DataLength;
uint16_t CurrentProfile;
uint32_t DataLength;
uint16_t CurrentProfile;
FeatureDescriptors Descriptors[65536];
} SeparatedFeatures;
#endif //DISCIMAGECHEF_DEVICE_REPORT_MMC_REPORT_H

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

@@ -8,13 +8,13 @@
#include <sys/ioctl.h>
#include <errno.h>
#include <string.h>
#include <stdint.h>
#include "scsi.h"
#define FALSE 0
#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)
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;
memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
io_hdr.interface_id = 'S';
io_hdr.cmd_len = cdb_len;
io_hdr.mx_sb_len = 32;
io_hdr.interface_id = 'S';
io_hdr.cmd_len = cdb_len;
io_hdr.mx_sb_len = 32;
io_hdr.dxfer_direction = direction;
io_hdr.dxfer_len = buffer_len;
io_hdr.dxferp = buffer;
io_hdr.cmdp = cdb;
io_hdr.sbp = *senseBuffer;
io_hdr.timeout = 10000;
io_hdr.dxfer_len = buffer_len;
io_hdr.dxferp = buffer;
io_hdr.cmdp = cdb;
io_hdr.sbp = *senseBuffer;
io_hdr.timeout = 10000;
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)
{
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);
if(prevent)
@@ -111,18 +111,19 @@ int EjectTray(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)
{
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;
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);
if(immediate)
@@ -159,7 +160,7 @@ int SpcAllowMediumRemoval(int fd, unsigned char **senseBuffer)
int SpcPreventAllowMediumRemoval(int fd, unsigned char **senseBuffer, uint8_t preventMode)
{
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);
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)
{
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)
{
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)
{
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);
if(immediate)
cdb[1] = 0x01;
@@ -199,10 +200,12 @@ int LoadUnload(int fd, unsigned char **senseBuffer, int immediate, int load, int
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 int buffer_len = 255;
unsigned char cmd_len = 6;
unsigned int buffer_len = 255;
*buffer = malloc(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[2] |= pageControl;
cdb[2] |= (pageCode & 0x3F);
cdb[3] = subPageCode;
cdb[4] = (uint8_t)(buffer_len & 0xFF);
cdb[3] = subPageCode;
cdb[4] = (uint8_t)(buffer_len & 0xFF);
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;
}
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 int buffer_len = 4096;
unsigned char cmd_len = 10;
unsigned int buffer_len = 4096;
*buffer = malloc(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[2] |= pageControl;
cdb[2] |= (pageCode & 0x3F);
cdb[3] = subPageCode;
cdb[7] = (uint8_t)((buffer_len & 0xFF00) >> 8);
cdb[8] = (uint8_t)(buffer_len & 0xFF);
cdb[9] = 0;
cdb[3] = subPageCode;
cdb[7] = (uint8_t)((buffer_len & 0xFF00) >> 8);
cdb[8] = (uint8_t)(buffer_len & 0xFF);
cdb[9] = 0;
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)
{
unsigned char cmd_len = 10;
unsigned int buffer_len = 8;
unsigned char cmd_len = 10;
unsigned int buffer_len = 8;
*buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len);
@@ -279,7 +283,7 @@ int ReadCapacity(int fd, unsigned char **buffer, unsigned char **senseBuffer, in
if(PMI)
{
cdb[8] = 0x01;
cdb[8] = 0x01;
if(RelAddr)
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)
{
unsigned char cmd_len = 16;
unsigned int buffer_len = 32;
unsigned char cmd_len = 16;
unsigned int buffer_len = 32;
*buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len);
@@ -306,14 +310,14 @@ int ReadCapacity16(int fd, unsigned char **buffer, unsigned char **senseBuffer,
if(PMI)
{
cdb[14] = 0x01;
cdb[2] = (uint8_t)((address & 0xFF00000000000000ULL) >> 56);
cdb[3] = (uint8_t)((address & 0xFF000000000000ULL) >> 48);
cdb[4] = (uint8_t)((address & 0xFF0000000000ULL) >> 40);
cdb[5] = (uint8_t)((address & 0xFF00000000ULL) >> 32);
cdb[6] = (uint8_t)((address & 0xFF000000ULL) >> 24);
cdb[7] = (uint8_t)((address & 0xFF0000ULL) >> 16);
cdb[8] = (uint8_t)((address & 0xFF00ULL) >> 8);
cdb[9] = (uint8_t)(address & 0xFFULL);
cdb[2] = (uint8_t)((address & 0xFF00000000000000ULL) >> 56);
cdb[3] = (uint8_t)((address & 0xFF000000000000ULL) >> 48);
cdb[4] = (uint8_t)((address & 0xFF0000000000ULL) >> 40);
cdb[5] = (uint8_t)((address & 0xFF00000000ULL) >> 32);
cdb[6] = (uint8_t)((address & 0xFF000000ULL) >> 24);
cdb[7] = (uint8_t)((address & 0xFF0000ULL) >> 16);
cdb[8] = (uint8_t)((address & 0xFF00ULL) >> 8);
cdb[9] = (uint8_t)(address & 0xFFULL);
}
cdb[10] = (uint8_t)((buffer_len & 0xFF000000) >> 24);
@@ -326,10 +330,11 @@ int ReadCapacity16(int fd, unsigned char **buffer, unsigned char **senseBuffer,
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 int buflen = transferLength == 0 ? 256 * blockSize : transferLength * blockSize;
unsigned int buflen = transferLength == 0 ? 256 * blockSize : transferLength * blockSize;
*buffer = malloc(buflen);
memset(*buffer, 0, buflen);
@@ -345,10 +350,11 @@ int Read6(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint32_t
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 int buflen = transferLength * blockSize;
unsigned int buflen = transferLength * blockSize;
*buffer = malloc(buflen);
memset(*buffer, 0, buflen);
@@ -376,16 +382,17 @@ int Read10(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t
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 int buflen = transferLength * blockSize;
unsigned int buflen = transferLength * blockSize;
*buffer = malloc(buflen);
memset(*buffer, 0, buflen);
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)
cdb[1] += 0x10;
if(fua)
@@ -394,14 +401,14 @@ int Read12(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t
cdb[1] += 0x02;
if(relAddr)
cdb[1] += 0x01;
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF);
cdb[6] = (uint8_t)((transferLength & 0xFF000000) >> 24);
cdb[7] = (uint8_t)((transferLength & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((transferLength & 0xFF00) >> 8);
cdb[9] = (uint8_t)(transferLength & 0xFF);
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF);
cdb[6] = (uint8_t)((transferLength & 0xFF000000) >> 24);
cdb[7] = (uint8_t)((transferLength & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((transferLength & 0xFF00) >> 8);
cdb[9] = (uint8_t)(transferLength & 0xFF);
cdb[10] = (uint8_t)(groupNumber & 0x1F);
if(streaming)
cdb[10] += 0x80;
@@ -411,30 +418,31 @@ int Read12(int fd, unsigned char **buffer, unsigned char **senseBuffer, uint8_t
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 int buflen = transferLength * blockSize;
unsigned int buflen = transferLength * blockSize;
*buffer = malloc(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};
cdb[1] = (uint8_t)((rdprotect & 0x07) << 5);
cdb[1] = (uint8_t)((rdprotect & 0x07) << 5);
if(dpo)
cdb[1] += 0x10;
if(fua)
cdb[1] += 0x08;
if(fuaNv)
cdb[1] += 0x02;
cdb[2] = (uint8_t)((lba & 0xFF00000000000000ULL) >> 56);
cdb[3] = (uint8_t)((lba & 0xFF000000000000ULL) >> 48);
cdb[4] = (uint8_t)((lba & 0xFF0000000000ULL) >> 40);
cdb[5] = (uint8_t)((lba & 0xFF00000000ULL) >> 32);
cdb[6] = (uint8_t)((lba & 0xFF000000ULL) >> 24);
cdb[7] = (uint8_t)((lba & 0xFF0000ULL) >> 16);
cdb[8] = (uint8_t)((lba & 0xFF00ULL) >> 8);
cdb[9] = (uint8_t)(lba & 0xFFULL);
cdb[2] = (uint8_t)((lba & 0xFF00000000000000ULL) >> 56);
cdb[3] = (uint8_t)((lba & 0xFF000000000000ULL) >> 48);
cdb[4] = (uint8_t)((lba & 0xFF0000000000ULL) >> 40);
cdb[5] = (uint8_t)((lba & 0xFF00000000ULL) >> 32);
cdb[6] = (uint8_t)((lba & 0xFF000000ULL) >> 24);
cdb[7] = (uint8_t)((lba & 0xFF0000ULL) >> 16);
cdb[8] = (uint8_t)((lba & 0xFF00ULL) >> 8);
cdb[9] = (uint8_t)(lba & 0xFFULL);
cdb[10] = (uint8_t)((transferLength & 0xFF000000) >> 24);
cdb[11] = (uint8_t)((transferLength & 0xFF0000) >> 16);
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;
}
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;
*buffer = malloc(transferBytes);
@@ -460,19 +469,20 @@ int ReadLong10(int fd, unsigned char **buffer, unsigned char **senseBuffer, int
cdb[1] += 0x02;
if(relAddr)
cdb[1] += 0x01;
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF);
cdb[7] = (uint8_t)((transferBytes & 0xFF00) >> 8);
cdb[8] = (uint8_t)(transferBytes & 0xFF);
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF);
cdb[7] = (uint8_t)((transferBytes & 0xFF00) >> 8);
cdb[8] = (uint8_t)(transferBytes & 0xFF);
int error = SendScsiCommand(fd, &cdb, cmd_len, *buffer, transferBytes, senseBuffer, SG_DXFER_FROM_DEV);
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;
*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};
cdb[2] = (uint8_t)((lba & 0xFF00000000000000ULL) >> 56);
cdb[3] = (uint8_t)((lba & 0xFF000000000000ULL) >> 48);
cdb[4] = (uint8_t)((lba & 0xFF0000000000ULL) >> 40);
cdb[5] = (uint8_t)((lba & 0xFF00000000ULL) >> 32);
cdb[6] = (uint8_t)((lba & 0xFF000000ULL) >> 24);
cdb[7] = (uint8_t)((lba & 0xFF0000ULL) >> 16);
cdb[8] = (uint8_t)((lba & 0xFF00ULL) >> 8);
cdb[9] = (uint8_t)(lba & 0xFFULL);
cdb[2] = (uint8_t)((lba & 0xFF00000000000000ULL) >> 56);
cdb[3] = (uint8_t)((lba & 0xFF000000000000ULL) >> 48);
cdb[4] = (uint8_t)((lba & 0xFF0000000000ULL) >> 40);
cdb[5] = (uint8_t)((lba & 0xFF00000000ULL) >> 32);
cdb[6] = (uint8_t)((lba & 0xFF000000ULL) >> 24);
cdb[7] = (uint8_t)((lba & 0xFF0000ULL) >> 16);
cdb[8] = (uint8_t)((lba & 0xFF00ULL) >> 8);
cdb[9] = (uint8_t)(lba & 0xFFULL);
cdb[12] = (uint8_t)((transferBytes & 0xFF00) >> 8);
cdb[13] = (uint8_t)(transferBytes & 0xFF);
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)
{
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);
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)
{
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);
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)
{
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);
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;
}
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;
uint16_t buffer_len = 8;
unsigned char cmd_len = 10;
uint16_t buffer_len = 8;
*buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len);
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;
}
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;
uint16_t buffer_len = 1024;
char cdb[] = {MMC_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 0, 0};
unsigned char cmd_len = 10;
uint16_t buffer_len = 1024;
char cdb[] = {MMC_READ_TOC_PMA_ATIP, 0, 0, 0, 0, 0, 0, 0, 0, 0};
if((format & 0xF) == 5)
buffer_len = 32768;
@@ -587,10 +599,10 @@ int ReadTocPmaAtip(int fd, unsigned char **buffer, unsigned char **senseBuffer,
if(MSF)
cdb[1] = 0x02;
cdb[2] = (uint8_t)(format & 0x0F);
cdb[6] = trackSessionNumber;
cdb[7] = (uint8_t)((buffer_len & 0xFF00) >> 8);
cdb[8] = (uint8_t)(buffer_len & 0xFF);
cdb[2] = (uint8_t)(format & 0x0F);
cdb[6] = trackSessionNumber;
cdb[7] = (uint8_t)((buffer_len & 0xFF00) >> 8);
cdb[8] = (uint8_t)(buffer_len & 0xFF);
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;
}
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;
uint16_t buffer_len = 8;
unsigned char cmd_len = 12;
uint16_t buffer_len = 8;
*buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len);
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[2] = (uint8_t)((address & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((address & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((address & 0xFF00) >> 8);
cdb[5] = (uint8_t)(address & 0xFF);
cdb[6] = layerNumber;
cdb[7] = (uint8_t)format;
cdb[8] = (uint8_t)((buffer_len & 0xFF00) >> 8);
cdb[9] = (uint8_t)(buffer_len & 0xFF);
cdb[1] = (uint8_t)((uint8_t)mediaType & 0x0F);
cdb[2] = (uint8_t)((address & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((address & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((address & 0xFF00) >> 8);
cdb[5] = (uint8_t)(address & 0xFF);
cdb[6] = layerNumber;
cdb[7] = (uint8_t)format;
cdb[8] = (uint8_t)((buffer_len & 0xFF00) >> 8);
cdb[9] = (uint8_t)(buffer_len & 0xFF);
cdb[10] = (uint8_t)((AGID & 0x03) << 6);
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;
}
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 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)
{
unsigned char cmd_len = 12;
uint32_t buffer_len = transferLength * blockSize;
unsigned char cmd_len = 12;
uint32_t buffer_len = transferLength * blockSize;
*buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len);
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)
cdb[1] += 0x02;
if(relAddr)
cdb[1] += 0x01;
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF);
cdb[6] = (uint8_t)((transferLength & 0xFF0000) >> 16);
cdb[7] = (uint8_t)((transferLength & 0xFF00) >> 8);
cdb[8] = (uint8_t)(transferLength & 0xFF);
cdb[9] = (uint8_t)((uint8_t)C2Error << 1);
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF);
cdb[6] = (uint8_t)((transferLength & 0xFF0000) >> 16);
cdb[7] = (uint8_t)((transferLength & 0xFF00) >> 8);
cdb[8] = (uint8_t)(transferLength & 0xFF);
cdb[9] = (uint8_t)((uint8_t)C2Error << 1);
cdb[9] += (uint8_t)((uint8_t)headerCodes << 5);
if(sync)
cdb[9] += 0x80;
@@ -683,22 +697,23 @@ int DAP, int relAddr, int sync, uint8_t headerCodes, int userData, int edcEcc, u
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 DAP, 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)
{
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)
cdb[1] += 0x02;
cdb[3] = (uint8_t)((startMsf & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((startMsf & 0xFF00) >> 8);
cdb[5] = (uint8_t)(startMsf & 0xFF);
cdb[6] = (uint8_t)((endMsf & 0xFF0000) >> 16);
cdb[7] = (uint8_t)((endMsf & 0xFF00) >> 8);
cdb[8] = (uint8_t)(endMsf & 0xFF);
cdb[9] = (uint8_t)((uint8_t)C2Error << 1);
cdb[3] = (uint8_t)((startMsf & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((startMsf & 0xFF00) >> 8);
cdb[5] = (uint8_t)(startMsf & 0xFF);
cdb[6] = (uint8_t)((endMsf & 0xFF0000) >> 16);
cdb[7] = (uint8_t)((endMsf & 0xFF00) >> 8);
cdb[8] = (uint8_t)(endMsf & 0xFF);
cdb[9] = (uint8_t)((uint8_t)C2Error << 1);
cdb[9] += (uint8_t)((uint8_t)headerCodes << 5);
if(sync)
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[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 buffer_len = transferLength * blockSize;
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;
*buffer = malloc(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;
}
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;
uint32_t buffer_len = transferLength * blockSize;
unsigned char cmd_len = 12;
uint32_t buffer_len = transferLength * blockSize;
*buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len);
char cdb[] = {PIONEER_READ_CDDA, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF);
cdb[6] = (uint8_t)((transferLength & 0xFF000000) >> 24);
cdb[7] = (uint8_t)((transferLength & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((transferLength & 0xFF00) >> 8);
cdb[9] = (uint8_t)(transferLength & 0xFF);
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF);
cdb[6] = (uint8_t)((transferLength & 0xFF000000) >> 24);
cdb[7] = (uint8_t)((transferLength & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((transferLength & 0xFF00) >> 8);
cdb[9] = (uint8_t)(transferLength & 0xFF);
cdb[10] = (uint8_t)subchannel;
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;
}
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;
uint32_t buffer_len = transferLength * 2064;
unsigned char cmd_len = 10;
uint32_t buffer_len = transferLength * 2064;
*buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len);
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;
}
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;
uint32_t buffer_len = transferLength * blockSize;
unsigned char cmd_len = 12;
uint32_t buffer_len = transferLength * blockSize;
*buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len);
char cdb[] = {PIONEER_READ_CDDA, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF);
cdb[7] = (uint8_t)((transferLength & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((transferLength & 0xFF00) >> 8);
cdb[9] = (uint8_t)(transferLength & 0xFF);
cdb[2] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[3] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[5] = (uint8_t)(lba & 0xFF);
cdb[7] = (uint8_t)((transferLength & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((transferLength & 0xFF00) >> 8);
cdb[9] = (uint8_t)(transferLength & 0xFF);
cdb[10] = (uint8_t)subchannel;
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;
}
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;
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[4] = (uint8_t)((startMsf & 0xFF00) >> 8);
cdb[5] = (uint8_t)(startMsf & 0xFF);
cdb[7] = (uint8_t)((endMsf & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((endMsf & 0xFF00) >> 8);
cdb[9] = (uint8_t)(endMsf & 0xFF);
cdb[3] = (uint8_t)((startMsf & 0xFF0000) >> 16);
cdb[4] = (uint8_t)((startMsf & 0xFF00) >> 8);
cdb[5] = (uint8_t)(startMsf & 0xFF);
cdb[7] = (uint8_t)((endMsf & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((endMsf & 0xFF00) >> 8);
cdb[9] = (uint8_t)(endMsf & 0xFF);
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 buffer_len = transferLength * blockSize;
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;
*buffer = malloc(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)
{
unsigned char cmd_len = 12;
uint32_t buffer_len = transferLength * 2352;
unsigned char cmd_len = 12;
uint32_t buffer_len = transferLength * 2352;
*buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len);
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)
{
unsigned char cmd_len = 12;
uint32_t buffer_len = transferLength * 2064;
unsigned char cmd_len = 12;
uint32_t buffer_len = transferLength * 2064;
*buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len);
char cdb[] = {HLDTST_VENDOR, 0x48, 0x49, 0x54, 0x01, 0, 0, 0, 0, 0, 0, 0};
cdb[6] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[7] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[9] = (uint8_t)(lba & 0xFF);
cdb[6] = (uint8_t)((lba & 0xFF000000) >> 24);
cdb[7] = (uint8_t)((lba & 0xFF0000) >> 16);
cdb[8] = (uint8_t)((lba & 0xFF00) >> 8);
cdb[9] = (uint8_t)(lba & 0xFF);
cdb[10] = (uint8_t)((buffer_len & 0xFF00) >> 8);
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)
{
unsigned char cmd_len = 6;
unsigned int buffer_len = 6;
unsigned char cmd_len = 6;
unsigned int buffer_len = 6;
*buffer = malloc(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)
{
unsigned char cmd_len = 10;
unsigned int buffer_len = 256;
unsigned char cmd_len = 10;
unsigned int buffer_len = 256;
*buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len);
@@ -873,8 +892,8 @@ int ReportDensitySupport(int fd, unsigned char **buffer, unsigned char **senseBu
cdb[1] |= 0x01;
if(mediumType)
cdb[1] |= 0x02;
cdb[7] = (uint8_t)((buffer_len & 0xFF00) >> 8);
cdb[8] = (uint8_t)(buffer_len & 0xFF);
cdb[7] = (uint8_t)((buffer_len & 0xFF00) >> 8);
cdb[8] = (uint8_t)(buffer_len & 0xFF);
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)
{
unsigned char cmd_len = 12;
unsigned int buffer_len = 256;
unsigned char cmd_len = 12;
unsigned int buffer_len = 256;
*buffer = malloc(buffer_len);
memset(*buffer, 0, buffer_len);
@@ -913,7 +932,9 @@ int ReadMediaSerialNumber(int fd, unsigned char **buffer, unsigned char **senseB
if(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);
*buffer = malloc(buffer_len);

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

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

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

@@ -5,13 +5,14 @@
#include <malloc.h>
#include <string.h>
#include <endian.h>
#include <stdint.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]);
int i;
ModeHeader *header = malloc(sizeof(ModeHeader));
uint16_t blockDescLength = (uint16_t)((modeResponse[6] << 8) + modeResponse[7]);
int i;
ModeHeader *header = malloc(sizeof(ModeHeader));
memset(header, 0, sizeof(ModeHeader));
header->MediumType = modeResponse[2];
@@ -25,7 +26,7 @@ ModeHeader *DecodeModeHeader10(unsigned char* modeResponse, uint8_t deviceType)
for(i = 0; i < header->descriptorsLength; i++)
{
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[14 + i * 16 + 8] << 16);
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)
{
header->WriteProtected = ((modeResponse[3] & 0x80) == 0x80);
header->DPOFUA = ((modeResponse[3] & 0x10) == 0x10);
header->DPOFUA = ((modeResponse[3] & 0x10) == 0x10);
}
if(deviceType == 0x01)
{
header->WriteProtected = ((modeResponse[3] & 0x80) == 0x80);
header->Speed = (uint8_t)(modeResponse[3] & 0x0F);
header->BufferedMode = (uint8_t)((modeResponse[3] & 0x70) >> 4);
header->Speed = (uint8_t)(modeResponse[3] & 0x0F);
header->BufferedMode = (uint8_t)((modeResponse[3] & 0x70) >> 4);
}
if(deviceType == 0x02)
@@ -75,8 +76,8 @@ ModeHeader *DecodeModeHeader10(unsigned char* modeResponse, uint8_t deviceType)
if(deviceType == 0x07)
{
header->WriteProtected = ((modeResponse[3] & 0x80) == 0x80);
header->EBC = ((modeResponse[3] & 0x01) == 0x01);
header->DPOFUA = ((modeResponse[3] & 0x10) == 0x10);
header->EBC = ((modeResponse[3] & 0x01) == 0x01);
header->DPOFUA = ((modeResponse[3] & 0x10) == 0x10);
}
header->decoded = 1;
@@ -84,7 +85,7 @@ ModeHeader *DecodeModeHeader10(unsigned char* modeResponse, uint8_t deviceType)
return header;
}
DecodedMode *DecodeMode10(unsigned char* modeResponse, uint8_t deviceType)
DecodedMode *DecodeMode10(unsigned char *modeResponse, uint8_t deviceType)
{
DecodedMode *decodedMode = malloc(sizeof(DecodedMode));
@@ -113,12 +114,12 @@ DecodedMode *DecodeMode10(unsigned char* modeResponse, uint8_t deviceType)
int isSubpage = (modeResponse[offset] & 0x40) == 0x40;
uint8_t pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
int subpage;
int subpage;
if(pageNo == 0)
{
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]);
memcpy(decodedMode->Pages[0][0], modeResponse + 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)
break;
pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
subpage = modeResponse[offset + 1];
decodedMode->pageSizes[pageNo][subpage] = (size_t)((modeResponse[offset + 2] << 8) + modeResponse[offset + 3] + 4);
decodedMode->Pages[pageNo][subpage] = malloc(decodedMode->pageSizes[pageNo][subpage]);
decodedMode->pageSizes[pageNo][subpage] = (size_t)((modeResponse[offset + 2] << 8) +
modeResponse[offset + 3] + 4);
decodedMode->Pages[pageNo][subpage] = malloc(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];
}
else
@@ -145,7 +148,7 @@ DecodedMode *DecodeMode10(unsigned char* modeResponse, uint8_t deviceType)
pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
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]);
memcpy(decodedMode->Pages[pageNo][0], modeResponse + 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));
memset(header, 0, sizeof(ModeHeader));
@@ -181,14 +184,14 @@ ModeHeader *DecodeModeHeader6(unsigned char* modeResponse, uint8_t deviceType)
if(deviceType == 0x00 || deviceType == 0x05)
{
header->WriteProtected = ((modeResponse[2] & 0x80) == 0x80);
header->DPOFUA = ((modeResponse[2] & 0x10) == 0x10);
header->DPOFUA = ((modeResponse[2] & 0x10) == 0x10);
}
if(deviceType == 0x01)
{
header->WriteProtected = ((modeResponse[2] & 0x80) == 0x80);
header->Speed = (uint8_t)(modeResponse[2] & 0x0F);
header->BufferedMode = (uint8_t)((modeResponse[2] & 0x70) >> 4);
header->Speed = (uint8_t)(modeResponse[2] & 0x0F);
header->BufferedMode = (uint8_t)((modeResponse[2] & 0x70) >> 4);
}
if(deviceType == 0x02)
@@ -197,8 +200,8 @@ ModeHeader *DecodeModeHeader6(unsigned char* modeResponse, uint8_t deviceType)
if(deviceType == 0x07)
{
header->WriteProtected = ((modeResponse[2] & 0x80) == 0x80);
header->EBC = ((modeResponse[2] & 0x01) == 0x01);
header->DPOFUA = ((modeResponse[2] & 0x10) == 0x10);
header->EBC = ((modeResponse[2] & 0x01) == 0x01);
header->DPOFUA = ((modeResponse[2] & 0x10) == 0x10);
}
header->decoded = 1;
@@ -206,7 +209,7 @@ ModeHeader *DecodeModeHeader6(unsigned char* modeResponse, uint8_t deviceType)
return header;
}
DecodedMode *DecodeMode6(unsigned char* modeResponse, uint8_t deviceType)
DecodedMode *DecodeMode6(unsigned char *modeResponse, uint8_t deviceType)
{
DecodedMode *decodedMode = malloc(sizeof(DecodedMode));
@@ -227,12 +230,12 @@ DecodedMode *DecodeMode6(unsigned char* modeResponse, uint8_t deviceType)
int isSubpage = (modeResponse[offset] & 0x40) == 0x40;
uint8_t pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
int subpage;
int subpage;
if(pageNo == 0)
{
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]);
memcpy(decodedMode->Pages[0][0], modeResponse + 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)
break;
pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
subpage = modeResponse[offset + 1];
decodedMode->pageSizes[pageNo][subpage] = (size_t)((modeResponse[offset + 2] << 8) + modeResponse[offset + 3] + 4);
decodedMode->Pages[pageNo][subpage] = malloc(decodedMode->pageSizes[pageNo][subpage]);
decodedMode->pageSizes[pageNo][subpage] = (size_t)((modeResponse[offset + 2] << 8) +
modeResponse[offset + 3] + 4);
decodedMode->Pages[pageNo][subpage] = malloc(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];
}
else
@@ -259,7 +264,7 @@ DecodedMode *DecodeMode6(unsigned char* modeResponse, uint8_t deviceType)
pageNo = (uint8_t)(modeResponse[offset] & 0x3F);
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]);
memcpy(decodedMode->Pages[pageNo][0], modeResponse + 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
#define DISCIMAGECHEF_DEVICE_REPORT_SCSI_MODE_H
#include <stdint.h>
typedef struct
{
uint8_t Density;
uint8_t Density;
uint64_t Blocks;
uint32_t BlockLength;
} BlockDescriptor;
typedef struct
{
uint8_t MediumType;
int WriteProtected;
uint8_t MediumType;
int WriteProtected;
BlockDescriptor BlockDescriptors[4096];
int descriptorsLength;
uint8_t Speed;
uint8_t BufferedMode;
int EBC;
int DPOFUA;
int decoded;
int descriptorsLength;
uint8_t Speed;
uint8_t BufferedMode;
int EBC;
int DPOFUA;
int decoded;
} ModeHeader;
typedef struct
{
ModeHeader Header;
ModeHeader Header;
unsigned char *Pages[256][256];
size_t pageSizes[256][256];
int decoded;
size_t pageSizes[256][256];
int decoded;
} DecodedMode;
ModeHeader *DecodeModeHeader6(unsigned char* modeResponse, uint8_t deviceType);
ModeHeader *DecodeModeHeader10(unsigned char* modeResponse, uint8_t deviceType);
DecodedMode *DecodeMode6(unsigned char* modeResponse, uint8_t deviceType);
DecodedMode *DecodeMode10(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);
DecodedMode *DecodeMode10(unsigned char *modeResponse, uint8_t deviceType);
#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)
{
unsigned char *sense = NULL;
unsigned char *buffer = NULL;
int error;
int page_len;
int removable = FALSE;
char user_response = ' ';
unsigned char* tmpString;
const int testSize512[] = {514,
unsigned char *sense = NULL;
unsigned char *buffer = NULL;
int error;
int page_len;
int removable = FALSE;
char user_response = ' ';
unsigned char *tmpString;
const int testSize512[] = {514,
// Long sector sizes for SuperDisk
536, 558,
536, 558,
// Long sector sizes for 512-byte magneto-opticals
600, 610, 630};
const int testSize1024[] = {
600, 610, 630};
const int testSize1024[] = {
// Long sector sizes for floppies
1026,
// Long sector sizes for 1024-byte magneto-opticals
1200};
const int testSize2048[] = {2380};
const int testSize4096[] = {4760};
const int testSize8192[] = {9424};
const int testSize2048[] = {2380};
const int testSize4096[] = {4760};
const int testSize8192[] = {9424};
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): ");
scanf("%c", &user_response);
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');
}
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 "Address16", "%s", inquiry->Addr16 ? "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 "MultiPortDevice", "%s", inquiry->MultiP ? "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 "PeripheralQualifier", "%s", DecodePeripheralQualifier(inquiry->PeripheralQualifier));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PeripheralDeviceType", "%s",
DecodePeripheralDeviceType(inquiry->PeripheralDeviceType));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "PeripheralQualifier", "%s",
DecodePeripheralQualifier(inquiry->PeripheralQualifier));
tmpString = malloc(17);
memset(tmpString, 0, 17);
memcpy(tmpString, inquiry->ProductIdentification, 16);
@@ -97,15 +100,18 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
free(tmpString);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Protection", "%s", inquiry->Protect ? "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 "ResponseDataFormat", "%d", inquiry->ResponseDataFormat);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SoftReset", "%s", inquiry->SftRe ? "true" : "false");
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 "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 "TranferDisable", "%s", inquiry->TranDis ? "true" : "false");
tmpString = malloc(9);
@@ -140,11 +146,11 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
scanf("%c");
}
int supportsMode6 = FALSE;
int supportsMode10 = FALSE;
int supportsModeSubpages = FALSE;
unsigned char* mode6Response = NULL;
unsigned char* mode10Response = NULL;
int supportsMode6 = FALSE;
int supportsMode10 = FALSE;
int supportsModeSubpages = FALSE;
unsigned char *mode6Response = NULL;
unsigned char *mode10Response = NULL;
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);
@@ -152,13 +158,13 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
if(error)
{
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)
supportsMode10 = TRUE;
}
else
{
supportsMode10 = TRUE;
supportsMode10 = TRUE;
supportsModeSubpages = TRUE;
}
@@ -171,7 +177,7 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
if(error)
{
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)
supportsMode6 = TRUE;
}
@@ -180,13 +186,14 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
}
else
{
supportsMode6 = TRUE;
supportsMode6 = TRUE;
supportsModeSubpages = TRUE;
}
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense6", "%s", supportsMode6 ? "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)
{
@@ -198,12 +205,13 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
if(supportsMode10)
{
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);
}
DecodedMode *decMode = NULL;
unsigned char* cdromMode = NULL;
DecodedMode *decMode = NULL;
unsigned char *cdromMode = NULL;
if(supportsMode10)
decMode = DecodeMode10(mode10Response, inquiry->PeripheralDeviceType);
@@ -215,12 +223,16 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
int page, subpage;
xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense"); // <ModeSense>
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BlankCheckEnabled", "%s", decMode->Header.EBC ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "DPOandFUA", "%s", decMode->Header.DPOFUA ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "WriteProtected", "%s", decMode->Header.WriteProtected ? "true" : "false");
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BlankCheckEnabled", "%s",
decMode->Header.EBC ? "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)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BlankCheckEnabled", "%d", decMode->Header.BufferedMode);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "BlankCheckEnabled", "%d",
decMode->Header.BufferedMode);
if(decMode->Header.Speed > 0)
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Speed", "%d", decMode->Header.Speed);
@@ -233,7 +245,8 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
xmlTextWriterStartElement(xmlWriter, BAD_CAST "modePageType");
xmlTextWriterWriteFormatAttribute(xmlWriter, BAD_CAST "page", "%d", page);
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);
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): ");
scanf("%c", &user_response);
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')
{
@@ -285,7 +298,7 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
error = TestUnitReady(fd, &sense);
int mediaRecognized = TRUE;
int leftRetries = 20;
int leftRetries = 20;
if(error)
{
@@ -319,14 +332,15 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
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 "MediumTypeName", "%s",mediaName);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumTypeName", "%s", mediaName);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Model", "%s", mediaModel);
if(mediaRecognized)
{
uint64_t blocks = 0;
uint64_t blocks = 0;
uint32_t blockSize = 0;
printf("Querying SCSI READ CAPACITY...\n");
@@ -334,8 +348,10 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
if(!error)
{
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsReadCapacity", "%s", "true");
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]));
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]));
}
printf("Querying SCSI READ CAPACITY (16)...\n");
@@ -347,7 +363,8 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
blocks <<= 32;
blocks += (buffer[4] << 24) + (buffer[5] << 16) + (buffer[6] << 8) + (buffer[7]);
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)
@@ -361,18 +378,21 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Querying SCSI MODE SENSE (10)...\n");
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)
{
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);
decMode = DecodeMode10(mode10Response, inquiry->PeripheralDeviceType);
}
printf("Querying SCSI MODE SENSE (6)...\n");
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)
{
xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense6Data");
@@ -384,22 +404,32 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
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)
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");
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");
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");
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");
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;
@@ -407,21 +437,24 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Trying SCSI READ LONG (10)...\n");
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");
supportsReadLong10 = TRUE;
if(sense[0] & 0x80 && sense[2] & 0x20)
{
uint32_t information = (sense[3] << 24) + (sense[4] << 16) + (sense[5] << 8) + sense[6];
longBlockSize = 0xFFFF - (information & 0xFFFF);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LongBlockSize", "%d", longBlockSize);
longBlockSize = 0xFFFF - (information & 0xFFFF);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "LongBlockSize", "%d",
longBlockSize);
}
}
printf("Trying SCSI READ LONG (16)...\n");
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");
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): ");
scanf("%c", &user_response);
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')
{
@@ -535,7 +569,7 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
}
else
{
uint64_t blocks = 0;
uint64_t blocks = 0;
uint32_t blockSize = 0;
xmlTextWriterStartElement(xmlWriter, BAD_CAST "ReadCapabilities"); // <ReadCapabilities>
@@ -545,7 +579,7 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
if(!error)
{
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]));
}
@@ -571,7 +605,8 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
{
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "SupportsModeSense10", "%s", "true");
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);
}
@@ -587,20 +622,28 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
{
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumType", "%d", decMode->Header.MediumType);
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");
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");
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");
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");
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;
@@ -608,21 +651,23 @@ void ScsiReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Trying SCSI READ LONG (10)...\n");
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");
supportsReadLong10 = TRUE;
if(sense[0] & 0x80 && sense[2] & 0x20)
{
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);
}
}
printf("Trying SCSI READ LONG (16)...\n");
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");
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): ");
scanf("%c", &user_response);
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')
{

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

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

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

@@ -11,14 +11,15 @@
#include "scsi_mode.h"
DensitySupport *DecodeDensity(unsigned char *response);
MediaTypeSupport *DecodeMediumTypes(unsigned char *response);
void SscReport(int fd, xmlTextWriterPtr xmlWriter)
{
unsigned char *sense = NULL;
unsigned char *buffer = NULL;
int i, error, len;
char user_response = ' ';
unsigned char *sense = NULL;
unsigned char *buffer = NULL;
int i, error, len;
char user_response = ' ';
xmlTextWriterStartElement(xmlWriter, BAD_CAST "SequentialDevice"); // <SequentialDevice>
@@ -26,7 +27,7 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
error = ReadBlockLimits(fd, &buffer, &sense);
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]);
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++)
{
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 "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 "BitsPerMm", "%d",
(dsh->descriptors[i]->bitsPerMm[0] << 16) +
(dsh->descriptors[i]->bitsPerMm[1] << 8) +
dsh->descriptors[i]->bitsPerMm[2]);
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 "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 "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 "Width", "%d", be16toh(dsh->descriptors[i]->mediaWidth));
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Writable", "%s", dsh->descriptors[i]->wrtok ? "true" : "false");
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>
}
@@ -78,12 +90,15 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
for(i = 0; i < mtsh->count; i++)
{
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 "MediumType", "%d", 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));
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>
// TODO: Density codes
xmlTextWriterEndElement(xmlWriter); // </SupportedMedia>
@@ -93,7 +108,7 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
}
user_response = ' ';
int anyMedia = FALSE;
int anyMedia = FALSE;
DecodedMode *decMode;
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): ");
scanf("%c", &user_response);
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')
{
@@ -120,7 +135,7 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
error = TestUnitReady(fd, &sense);
int mediaRecognized = TRUE;
int leftRetries = 20;
int leftRetries = 20;
if(error)
{
@@ -154,16 +169,18 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
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 "MediumTypeName", "%s",mediaName);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumTypeName", "%s", mediaName);
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "Model", "%s", mediaModel);
if(mediaRecognized)
{
printf("Querying SCSI MODE SENSE (10)...\n");
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)
{
xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense10Data");
@@ -174,7 +191,8 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
printf("Querying SCSI MODE SENSE (6)...\n");
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)
{
xmlTextWriterStartElement(xmlWriter, BAD_CAST "ModeSense6Data");
@@ -188,7 +206,8 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
{
xmlTextWriterWriteFormatElement(xmlWriter, BAD_CAST "MediumType", "%d", decMode->Header.MediumType);
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");
@@ -202,18 +221,32 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
for(i = 0; i < dsh->count; i++)
{
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 "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 "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");
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 "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 "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>
}
@@ -232,12 +265,18 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
for(i = 0; i < mtsh->count; i++)
{
xmlTextWriterStartElement(xmlWriter, BAD_CAST "SupportedMedia"); // <SupportedMedia>
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 "MediumType", "%d", 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));
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 "MediumType", "%d",
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>
// TODO: Density codes
xmlTextWriterEndElement(xmlWriter); // </SupportedMedia>
@@ -247,7 +286,8 @@ void SscReport(int fd, xmlTextWriterPtr xmlWriter)
}
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>
@@ -268,12 +308,12 @@ DensitySupport *DecodeDensity(unsigned char *response)
DensitySupport *decoded = malloc(sizeof(DensitySupport));
memset(decoded, 0, sizeof(DensitySupport));
uint16_t responseLen = (uint16_t)((response[0] << 8) + response[1] + 2);
int offset = 4;
int offset = 4;
while(offset + 3 < responseLen)
{
int lenValid = response[offset + 2] & 0x20;
uint16_t descLen = (uint16_t)((response[offset + 3] << 8) + response[offset + 4] + 5);
int lenValid = response[offset + 2] & 0x20;
uint16_t descLen = (uint16_t)((response[offset + 3] << 8) + response[offset + 4] + 5);
decoded->descriptors[decoded->count] = malloc(sizeof(DensityDescriptor));
memset(decoded->descriptors[decoded->count], 0, sizeof(DensityDescriptor));
@@ -293,7 +333,7 @@ MediaTypeSupport *DecodeMediumTypes(unsigned char *response)
MediaTypeSupport *decoded = malloc(sizeof(MediaTypeSupport));
memset(decoded, 0, sizeof(MediaTypeSupport));
uint16_t responseLen = (uint16_t)((response[0] << 8) + response[1] + 2);
int offset = 4;
int offset = 4;
while(offset + 3 < responseLen)
{

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

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