666 lines
20 KiB
C++
666 lines
20 KiB
C++
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <cstddef>
|
|
|
|
#include "command_packet_format_byte_order.hpp"
|
|
|
|
namespace gdrom_command_packet_format {
|
|
struct test_unit {
|
|
uint8_t command_code;
|
|
uint8_t _res0;
|
|
uint8_t _res1;
|
|
uint8_t _res2;
|
|
uint8_t _res3;
|
|
uint8_t _res4;
|
|
uint8_t _res5;
|
|
uint8_t _res6;
|
|
uint8_t _res7;
|
|
uint8_t _res8;
|
|
uint8_t _res9;
|
|
uint8_t _res10;
|
|
|
|
test_unit()
|
|
: command_code(0x0)
|
|
, _res0(0)
|
|
, _res1(0)
|
|
, _res2(0)
|
|
, _res3(0)
|
|
, _res4(0)
|
|
, _res5(0)
|
|
, _res6(0)
|
|
, _res7(0)
|
|
, _res8(0)
|
|
, _res9(0)
|
|
, _res10(0)
|
|
{ }
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (test_unit)) == 12);
|
|
static_assert((offsetof (struct test_unit, command_code)) == 0x00);
|
|
static_assert((offsetof (struct test_unit, _res0)) == 0x01);
|
|
static_assert((offsetof (struct test_unit, _res1)) == 0x02);
|
|
static_assert((offsetof (struct test_unit, _res2)) == 0x03);
|
|
static_assert((offsetof (struct test_unit, _res3)) == 0x04);
|
|
static_assert((offsetof (struct test_unit, _res4)) == 0x05);
|
|
static_assert((offsetof (struct test_unit, _res5)) == 0x06);
|
|
static_assert((offsetof (struct test_unit, _res6)) == 0x07);
|
|
static_assert((offsetof (struct test_unit, _res7)) == 0x08);
|
|
static_assert((offsetof (struct test_unit, _res8)) == 0x09);
|
|
static_assert((offsetof (struct test_unit, _res9)) == 0x0a);
|
|
static_assert((offsetof (struct test_unit, _res10)) == 0x0b);
|
|
|
|
struct req_stat {
|
|
uint8_t command_code;
|
|
uint8_t _res0;
|
|
uint8_t starting_address;
|
|
uint8_t _res1;
|
|
uint8_t allocation_length;
|
|
uint8_t _res2;
|
|
uint8_t _res3;
|
|
uint8_t _res4;
|
|
uint8_t _res5;
|
|
uint8_t _res6;
|
|
uint8_t _res7;
|
|
uint8_t _res8;
|
|
|
|
req_stat(const uint8_t starting_address,
|
|
const uint8_t allocation_length
|
|
)
|
|
: command_code(0x10)
|
|
, _res0(0)
|
|
, starting_address(starting_address)
|
|
, _res1(0)
|
|
, allocation_length(allocation_length)
|
|
, _res2(0)
|
|
, _res3(0)
|
|
, _res4(0)
|
|
, _res5(0)
|
|
, _res6(0)
|
|
, _res7(0)
|
|
, _res8(0)
|
|
{ }
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (req_stat)) == 12);
|
|
static_assert((offsetof (struct req_stat, command_code)) == 0x00);
|
|
static_assert((offsetof (struct req_stat, _res0)) == 0x01);
|
|
static_assert((offsetof (struct req_stat, starting_address)) == 0x02);
|
|
static_assert((offsetof (struct req_stat, _res1)) == 0x03);
|
|
static_assert((offsetof (struct req_stat, allocation_length)) == 0x04);
|
|
static_assert((offsetof (struct req_stat, _res2)) == 0x05);
|
|
static_assert((offsetof (struct req_stat, _res3)) == 0x06);
|
|
static_assert((offsetof (struct req_stat, _res4)) == 0x07);
|
|
static_assert((offsetof (struct req_stat, _res5)) == 0x08);
|
|
static_assert((offsetof (struct req_stat, _res6)) == 0x09);
|
|
static_assert((offsetof (struct req_stat, _res7)) == 0x0a);
|
|
static_assert((offsetof (struct req_stat, _res8)) == 0x0b);
|
|
|
|
struct req_mode {
|
|
uint8_t command_code;
|
|
uint8_t _res0;
|
|
uint8_t starting_address;
|
|
uint8_t _res1;
|
|
uint8_t allocation_length;
|
|
uint8_t _res2;
|
|
uint8_t _res3;
|
|
uint8_t _res4;
|
|
uint8_t _res5;
|
|
uint8_t _res6;
|
|
uint8_t _res7;
|
|
uint8_t _res8;
|
|
|
|
req_mode(const uint8_t starting_address,
|
|
const uint8_t allocation_length
|
|
)
|
|
: command_code(0x11)
|
|
, _res0(0)
|
|
, starting_address(starting_address)
|
|
, _res1(0)
|
|
, allocation_length(allocation_length)
|
|
, _res2(0)
|
|
, _res3(0)
|
|
, _res4(0)
|
|
, _res5(0)
|
|
, _res6(0)
|
|
, _res7(0)
|
|
, _res8(0)
|
|
{ }
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (req_mode)) == 12);
|
|
static_assert((offsetof (struct req_mode, command_code)) == 0x00);
|
|
static_assert((offsetof (struct req_mode, _res0)) == 0x01);
|
|
static_assert((offsetof (struct req_mode, starting_address)) == 0x02);
|
|
static_assert((offsetof (struct req_mode, _res1)) == 0x03);
|
|
static_assert((offsetof (struct req_mode, allocation_length)) == 0x04);
|
|
static_assert((offsetof (struct req_mode, _res2)) == 0x05);
|
|
static_assert((offsetof (struct req_mode, _res3)) == 0x06);
|
|
static_assert((offsetof (struct req_mode, _res4)) == 0x07);
|
|
static_assert((offsetof (struct req_mode, _res5)) == 0x08);
|
|
static_assert((offsetof (struct req_mode, _res6)) == 0x09);
|
|
static_assert((offsetof (struct req_mode, _res7)) == 0x0a);
|
|
static_assert((offsetof (struct req_mode, _res8)) == 0x0b);
|
|
|
|
struct set_mode {
|
|
uint8_t command_code;
|
|
uint8_t _res0;
|
|
uint8_t starting_address;
|
|
uint8_t _res1;
|
|
uint8_t allocation_length;
|
|
uint8_t _res2;
|
|
uint8_t _res3;
|
|
uint8_t _res4;
|
|
uint8_t _res5;
|
|
uint8_t _res6;
|
|
uint8_t _res7;
|
|
uint8_t _res8;
|
|
|
|
set_mode(const uint8_t starting_address,
|
|
const uint8_t allocation_length
|
|
)
|
|
: command_code(0x12)
|
|
, _res0(0)
|
|
, starting_address(starting_address)
|
|
, _res1(0)
|
|
, allocation_length(allocation_length)
|
|
, _res2(0)
|
|
, _res3(0)
|
|
, _res4(0)
|
|
, _res5(0)
|
|
, _res6(0)
|
|
, _res7(0)
|
|
, _res8(0)
|
|
{ }
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (set_mode)) == 12);
|
|
static_assert((offsetof (struct set_mode, command_code)) == 0x00);
|
|
static_assert((offsetof (struct set_mode, _res0)) == 0x01);
|
|
static_assert((offsetof (struct set_mode, starting_address)) == 0x02);
|
|
static_assert((offsetof (struct set_mode, _res1)) == 0x03);
|
|
static_assert((offsetof (struct set_mode, allocation_length)) == 0x04);
|
|
static_assert((offsetof (struct set_mode, _res2)) == 0x05);
|
|
static_assert((offsetof (struct set_mode, _res3)) == 0x06);
|
|
static_assert((offsetof (struct set_mode, _res4)) == 0x07);
|
|
static_assert((offsetof (struct set_mode, _res5)) == 0x08);
|
|
static_assert((offsetof (struct set_mode, _res6)) == 0x09);
|
|
static_assert((offsetof (struct set_mode, _res7)) == 0x0a);
|
|
static_assert((offsetof (struct set_mode, _res8)) == 0x0b);
|
|
|
|
struct req_error {
|
|
uint8_t command_code;
|
|
uint8_t _res0;
|
|
uint8_t _res1;
|
|
uint8_t _res2;
|
|
uint8_t allocation_length;
|
|
uint8_t _res3;
|
|
uint8_t _res4;
|
|
uint8_t _res5;
|
|
uint8_t _res6;
|
|
uint8_t _res7;
|
|
uint8_t _res8;
|
|
uint8_t _res9;
|
|
|
|
req_error(const uint8_t allocation_length
|
|
)
|
|
: command_code(0x13)
|
|
, _res0(0)
|
|
, _res1(0)
|
|
, _res2(0)
|
|
, allocation_length(allocation_length)
|
|
, _res3(0)
|
|
, _res4(0)
|
|
, _res5(0)
|
|
, _res6(0)
|
|
, _res7(0)
|
|
, _res8(0)
|
|
, _res9(0)
|
|
{ }
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (req_error)) == 12);
|
|
static_assert((offsetof (struct req_error, command_code)) == 0x00);
|
|
static_assert((offsetof (struct req_error, _res0)) == 0x01);
|
|
static_assert((offsetof (struct req_error, _res1)) == 0x02);
|
|
static_assert((offsetof (struct req_error, _res2)) == 0x03);
|
|
static_assert((offsetof (struct req_error, allocation_length)) == 0x04);
|
|
static_assert((offsetof (struct req_error, _res3)) == 0x05);
|
|
static_assert((offsetof (struct req_error, _res4)) == 0x06);
|
|
static_assert((offsetof (struct req_error, _res5)) == 0x07);
|
|
static_assert((offsetof (struct req_error, _res6)) == 0x08);
|
|
static_assert((offsetof (struct req_error, _res7)) == 0x09);
|
|
static_assert((offsetof (struct req_error, _res8)) == 0x0a);
|
|
static_assert((offsetof (struct req_error, _res9)) == 0x0b);
|
|
|
|
struct get_toc {
|
|
uint8_t command_code;
|
|
uint8_t select;
|
|
uint8_t _res0;
|
|
uint8_t allocation_length[2];
|
|
uint8_t _res1;
|
|
uint8_t _res2;
|
|
uint8_t _res3;
|
|
uint8_t _res4;
|
|
uint8_t _res5;
|
|
uint8_t _res6;
|
|
uint8_t _res7;
|
|
|
|
get_toc(const uint8_t select,
|
|
const uint32_t allocation_length
|
|
)
|
|
: command_code(0x14)
|
|
, select(select)
|
|
, _res0(0)
|
|
, _res1(0)
|
|
, _res2(0)
|
|
, _res3(0)
|
|
, _res4(0)
|
|
, _res5(0)
|
|
, _res6(0)
|
|
, _res7(0)
|
|
{
|
|
byte_order<2>(&this->allocation_length[0], allocation_length);
|
|
}
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (get_toc)) == 12);
|
|
static_assert((offsetof (struct get_toc, command_code)) == 0x00);
|
|
static_assert((offsetof (struct get_toc, select)) == 0x01);
|
|
static_assert((offsetof (struct get_toc, _res0)) == 0x02);
|
|
static_assert((offsetof (struct get_toc, allocation_length)) == 0x03);
|
|
static_assert((offsetof (struct get_toc, _res1)) == 0x05);
|
|
static_assert((offsetof (struct get_toc, _res2)) == 0x06);
|
|
static_assert((offsetof (struct get_toc, _res3)) == 0x07);
|
|
static_assert((offsetof (struct get_toc, _res4)) == 0x08);
|
|
static_assert((offsetof (struct get_toc, _res5)) == 0x09);
|
|
static_assert((offsetof (struct get_toc, _res6)) == 0x0a);
|
|
static_assert((offsetof (struct get_toc, _res7)) == 0x0b);
|
|
|
|
struct req_ses {
|
|
uint8_t command_code;
|
|
uint8_t _res0;
|
|
uint8_t session_number;
|
|
uint8_t _res1;
|
|
uint8_t allocation_length;
|
|
uint8_t _res2;
|
|
uint8_t _res3;
|
|
uint8_t _res4;
|
|
uint8_t _res5;
|
|
uint8_t _res6;
|
|
uint8_t _res7;
|
|
uint8_t _res8;
|
|
|
|
req_ses(const uint8_t session_number,
|
|
const uint8_t allocation_length
|
|
)
|
|
: command_code(0x15)
|
|
, _res0(0)
|
|
, session_number(session_number)
|
|
, _res1(0)
|
|
, allocation_length(allocation_length)
|
|
, _res2(0)
|
|
, _res3(0)
|
|
, _res4(0)
|
|
, _res5(0)
|
|
, _res6(0)
|
|
, _res7(0)
|
|
, _res8(0)
|
|
{ }
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (req_ses)) == 12);
|
|
static_assert((offsetof (struct req_ses, command_code)) == 0x00);
|
|
static_assert((offsetof (struct req_ses, _res0)) == 0x01);
|
|
static_assert((offsetof (struct req_ses, session_number)) == 0x02);
|
|
static_assert((offsetof (struct req_ses, _res1)) == 0x03);
|
|
static_assert((offsetof (struct req_ses, allocation_length)) == 0x04);
|
|
static_assert((offsetof (struct req_ses, _res2)) == 0x05);
|
|
static_assert((offsetof (struct req_ses, _res3)) == 0x06);
|
|
static_assert((offsetof (struct req_ses, _res4)) == 0x07);
|
|
static_assert((offsetof (struct req_ses, _res5)) == 0x08);
|
|
static_assert((offsetof (struct req_ses, _res6)) == 0x09);
|
|
static_assert((offsetof (struct req_ses, _res7)) == 0x0a);
|
|
static_assert((offsetof (struct req_ses, _res8)) == 0x0b);
|
|
|
|
struct cd_open {
|
|
uint8_t command_code;
|
|
uint8_t _res0;
|
|
uint8_t _res1;
|
|
uint8_t _res2;
|
|
uint8_t _res3;
|
|
uint8_t _res4;
|
|
uint8_t _res5;
|
|
uint8_t _res6;
|
|
uint8_t _res7;
|
|
uint8_t _res8;
|
|
uint8_t _res9;
|
|
uint8_t _res10;
|
|
|
|
cd_open()
|
|
: command_code(0x16)
|
|
, _res0(0)
|
|
, _res1(0)
|
|
, _res2(0)
|
|
, _res3(0)
|
|
, _res4(0)
|
|
, _res5(0)
|
|
, _res6(0)
|
|
, _res7(0)
|
|
, _res8(0)
|
|
, _res9(0)
|
|
, _res10(0)
|
|
{ }
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (cd_open)) == 12);
|
|
static_assert((offsetof (struct cd_open, command_code)) == 0x00);
|
|
static_assert((offsetof (struct cd_open, _res0)) == 0x01);
|
|
static_assert((offsetof (struct cd_open, _res1)) == 0x02);
|
|
static_assert((offsetof (struct cd_open, _res2)) == 0x03);
|
|
static_assert((offsetof (struct cd_open, _res3)) == 0x04);
|
|
static_assert((offsetof (struct cd_open, _res4)) == 0x05);
|
|
static_assert((offsetof (struct cd_open, _res5)) == 0x06);
|
|
static_assert((offsetof (struct cd_open, _res6)) == 0x07);
|
|
static_assert((offsetof (struct cd_open, _res7)) == 0x08);
|
|
static_assert((offsetof (struct cd_open, _res8)) == 0x09);
|
|
static_assert((offsetof (struct cd_open, _res9)) == 0x0a);
|
|
static_assert((offsetof (struct cd_open, _res10)) == 0x0b);
|
|
|
|
struct cd_play {
|
|
uint8_t command_code;
|
|
uint8_t parameter_type;
|
|
uint8_t starting_point[3];
|
|
uint8_t _res0;
|
|
uint8_t repeat_times;
|
|
uint8_t _res1;
|
|
uint8_t end_point[3];
|
|
uint8_t _res2;
|
|
|
|
cd_play(const uint8_t parameter_type,
|
|
const uint32_t starting_point,
|
|
const uint8_t repeat_times,
|
|
const uint32_t end_point
|
|
)
|
|
: command_code(0x20)
|
|
, parameter_type(parameter_type)
|
|
, _res0(0)
|
|
, repeat_times(repeat_times)
|
|
, _res1(0)
|
|
, _res2(0)
|
|
{
|
|
byte_order<3>(&this->starting_point[0], starting_point);
|
|
byte_order<3>(&this->end_point[0], end_point);
|
|
}
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (cd_play)) == 12);
|
|
static_assert((offsetof (struct cd_play, command_code)) == 0x00);
|
|
static_assert((offsetof (struct cd_play, parameter_type)) == 0x01);
|
|
static_assert((offsetof (struct cd_play, starting_point)) == 0x02);
|
|
static_assert((offsetof (struct cd_play, _res0)) == 0x05);
|
|
static_assert((offsetof (struct cd_play, repeat_times)) == 0x06);
|
|
static_assert((offsetof (struct cd_play, _res1)) == 0x07);
|
|
static_assert((offsetof (struct cd_play, end_point)) == 0x08);
|
|
static_assert((offsetof (struct cd_play, _res2)) == 0x0b);
|
|
|
|
struct cd_seek {
|
|
uint8_t command_code;
|
|
uint8_t parameter_type;
|
|
uint8_t seek_point[3];
|
|
uint8_t _res0;
|
|
uint8_t _res1;
|
|
uint8_t _res2;
|
|
uint8_t _res3;
|
|
uint8_t _res4;
|
|
uint8_t _res5;
|
|
uint8_t _res6;
|
|
|
|
cd_seek(const uint8_t parameter_type,
|
|
const uint32_t seek_point
|
|
)
|
|
: command_code(0x21)
|
|
, parameter_type(parameter_type)
|
|
, _res0(0)
|
|
, _res1(0)
|
|
, _res2(0)
|
|
, _res3(0)
|
|
, _res4(0)
|
|
, _res5(0)
|
|
, _res6(0)
|
|
{
|
|
byte_order<3>(&this->seek_point[0], seek_point);
|
|
}
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (cd_seek)) == 12);
|
|
static_assert((offsetof (struct cd_seek, command_code)) == 0x00);
|
|
static_assert((offsetof (struct cd_seek, parameter_type)) == 0x01);
|
|
static_assert((offsetof (struct cd_seek, seek_point)) == 0x02);
|
|
static_assert((offsetof (struct cd_seek, _res0)) == 0x05);
|
|
static_assert((offsetof (struct cd_seek, _res1)) == 0x06);
|
|
static_assert((offsetof (struct cd_seek, _res2)) == 0x07);
|
|
static_assert((offsetof (struct cd_seek, _res3)) == 0x08);
|
|
static_assert((offsetof (struct cd_seek, _res4)) == 0x09);
|
|
static_assert((offsetof (struct cd_seek, _res5)) == 0x0a);
|
|
static_assert((offsetof (struct cd_seek, _res6)) == 0x0b);
|
|
|
|
struct cd_scan {
|
|
uint8_t command_code;
|
|
uint8_t _res0;
|
|
uint8_t direction;
|
|
uint8_t speed;
|
|
uint8_t _res1;
|
|
uint8_t _res2;
|
|
uint8_t _res3;
|
|
uint8_t _res4;
|
|
uint8_t _res5;
|
|
uint8_t _res6;
|
|
uint8_t _res7;
|
|
uint8_t _res8;
|
|
|
|
cd_scan(const uint8_t direction,
|
|
const uint8_t speed
|
|
)
|
|
: command_code(0x22)
|
|
, _res0(0)
|
|
, direction(direction)
|
|
, speed(speed)
|
|
, _res1(0)
|
|
, _res2(0)
|
|
, _res3(0)
|
|
, _res4(0)
|
|
, _res5(0)
|
|
, _res6(0)
|
|
, _res7(0)
|
|
, _res8(0)
|
|
{ }
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (cd_scan)) == 12);
|
|
static_assert((offsetof (struct cd_scan, command_code)) == 0x00);
|
|
static_assert((offsetof (struct cd_scan, _res0)) == 0x01);
|
|
static_assert((offsetof (struct cd_scan, direction)) == 0x02);
|
|
static_assert((offsetof (struct cd_scan, speed)) == 0x03);
|
|
static_assert((offsetof (struct cd_scan, _res1)) == 0x04);
|
|
static_assert((offsetof (struct cd_scan, _res2)) == 0x05);
|
|
static_assert((offsetof (struct cd_scan, _res3)) == 0x06);
|
|
static_assert((offsetof (struct cd_scan, _res4)) == 0x07);
|
|
static_assert((offsetof (struct cd_scan, _res5)) == 0x08);
|
|
static_assert((offsetof (struct cd_scan, _res6)) == 0x09);
|
|
static_assert((offsetof (struct cd_scan, _res7)) == 0x0a);
|
|
static_assert((offsetof (struct cd_scan, _res8)) == 0x0b);
|
|
|
|
struct cd_read {
|
|
uint8_t command_code;
|
|
uint8_t data;
|
|
uint8_t starting_address[3];
|
|
uint8_t _res0;
|
|
uint8_t _res1;
|
|
uint8_t _res2;
|
|
uint8_t transfer_length[3];
|
|
uint8_t _res3;
|
|
|
|
cd_read(const uint8_t data,
|
|
const uint32_t starting_address,
|
|
const uint32_t transfer_length
|
|
)
|
|
: command_code(0x30)
|
|
, data(data)
|
|
, _res0(0)
|
|
, _res1(0)
|
|
, _res2(0)
|
|
, _res3(0)
|
|
{
|
|
byte_order<3>(&this->starting_address[0], starting_address);
|
|
byte_order<3>(&this->transfer_length[0], transfer_length);
|
|
}
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (cd_read)) == 12);
|
|
static_assert((offsetof (struct cd_read, command_code)) == 0x00);
|
|
static_assert((offsetof (struct cd_read, data)) == 0x01);
|
|
static_assert((offsetof (struct cd_read, starting_address)) == 0x02);
|
|
static_assert((offsetof (struct cd_read, _res0)) == 0x05);
|
|
static_assert((offsetof (struct cd_read, _res1)) == 0x06);
|
|
static_assert((offsetof (struct cd_read, _res2)) == 0x07);
|
|
static_assert((offsetof (struct cd_read, transfer_length)) == 0x08);
|
|
static_assert((offsetof (struct cd_read, _res3)) == 0x0b);
|
|
|
|
struct cd_read2 {
|
|
uint8_t command_code;
|
|
uint8_t data;
|
|
uint8_t starting_address[3];
|
|
uint8_t _res0;
|
|
uint8_t transfer_length[2];
|
|
uint8_t next_address[3];
|
|
uint8_t _res1;
|
|
|
|
cd_read2(const uint8_t data,
|
|
const uint32_t starting_address,
|
|
const uint32_t transfer_length,
|
|
const uint32_t next_address
|
|
)
|
|
: command_code(0x31)
|
|
, data(data)
|
|
, _res0(0)
|
|
, _res1(0)
|
|
{
|
|
byte_order<3>(&this->starting_address[0], starting_address);
|
|
byte_order<2>(&this->transfer_length[0], transfer_length);
|
|
byte_order<3>(&this->next_address[0], next_address);
|
|
}
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (cd_read2)) == 12);
|
|
static_assert((offsetof (struct cd_read2, command_code)) == 0x00);
|
|
static_assert((offsetof (struct cd_read2, data)) == 0x01);
|
|
static_assert((offsetof (struct cd_read2, starting_address)) == 0x02);
|
|
static_assert((offsetof (struct cd_read2, _res0)) == 0x05);
|
|
static_assert((offsetof (struct cd_read2, transfer_length)) == 0x06);
|
|
static_assert((offsetof (struct cd_read2, next_address)) == 0x08);
|
|
static_assert((offsetof (struct cd_read2, _res1)) == 0x0b);
|
|
|
|
struct cd_scd {
|
|
uint8_t command_code;
|
|
uint8_t data_format;
|
|
uint8_t _res0;
|
|
uint8_t allocation_length[2];
|
|
uint8_t _res1;
|
|
uint8_t _res2;
|
|
uint8_t _res3;
|
|
uint8_t _res4;
|
|
uint8_t _res5;
|
|
uint8_t _res6;
|
|
uint8_t _res7;
|
|
|
|
cd_scd(const uint8_t data_format,
|
|
const uint32_t allocation_length
|
|
)
|
|
: command_code(0x40)
|
|
, data_format(data_format)
|
|
, _res0(0)
|
|
, _res1(0)
|
|
, _res2(0)
|
|
, _res3(0)
|
|
, _res4(0)
|
|
, _res5(0)
|
|
, _res6(0)
|
|
, _res7(0)
|
|
{
|
|
byte_order<2>(&this->allocation_length[0], allocation_length);
|
|
}
|
|
|
|
const uint8_t * _data()
|
|
{
|
|
return reinterpret_cast<const uint8_t *>(this);
|
|
}
|
|
};
|
|
static_assert((sizeof (cd_scd)) == 12);
|
|
static_assert((offsetof (struct cd_scd, command_code)) == 0x00);
|
|
static_assert((offsetof (struct cd_scd, data_format)) == 0x01);
|
|
static_assert((offsetof (struct cd_scd, _res0)) == 0x02);
|
|
static_assert((offsetof (struct cd_scd, allocation_length)) == 0x03);
|
|
static_assert((offsetof (struct cd_scd, _res1)) == 0x05);
|
|
static_assert((offsetof (struct cd_scd, _res2)) == 0x06);
|
|
static_assert((offsetof (struct cd_scd, _res3)) == 0x07);
|
|
static_assert((offsetof (struct cd_scd, _res4)) == 0x08);
|
|
static_assert((offsetof (struct cd_scd, _res5)) == 0x09);
|
|
static_assert((offsetof (struct cd_scd, _res6)) == 0x0a);
|
|
static_assert((offsetof (struct cd_scd, _res7)) == 0x0b);
|
|
|
|
}
|
|
|