mirror of https://github.com/inolen/redream.git
prefix gdrom enums with GD_
This commit is contained in:
Anthony Pesch
parent
507ef27a61
commit
759234d607
|
|
@ -215,9 +215,9 @@ static int bios_boot(struct bios *bios) {
|
|||
const uint32_t BOOT1_ADDR = 0x8c008000;
|
||||
const uint32_t BOOT2_ADDR = 0x8c010000;
|
||||
const uint32_t SYSINFO_ADDR = 0x8c000068;
|
||||
const enum gd_secfmt secfmt = SECTOR_ANY;
|
||||
const enum gd_secmask secmask = MASK_DATA;
|
||||
const int secsz = 2048;
|
||||
const int sector_fmt = GD_SECTOR_ANY;
|
||||
const int sector_mask = GD_MASK_DATA;
|
||||
const int sector_size = 2048;
|
||||
uint8_t tmp[0x10000];
|
||||
|
||||
LOG_INFO("bios_boot using hle bootstrap");
|
||||
|
|
@ -226,7 +226,8 @@ static int bios_boot(struct bios *bios) {
|
|||
{
|
||||
int fad = 45150;
|
||||
int n = 16;
|
||||
int r = gdrom_read_sectors(gd, fad, secfmt, secmask, n, tmp, sizeof(tmp));
|
||||
int r = gdrom_read_sectors(gd, fad, sector_fmt, sector_mask, n, tmp,
|
||||
sizeof(tmp));
|
||||
if (!r) {
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -240,7 +241,8 @@ static int bios_boot(struct bios *bios) {
|
|||
/* read primary volume descriptor */
|
||||
int fad = 45150 + ISO_PVD_SECTOR;
|
||||
int n = 1;
|
||||
int r = gdrom_read_sectors(gd, fad, secfmt, secmask, n, tmp, sizeof(tmp));
|
||||
int r = gdrom_read_sectors(gd, fad, sector_fmt, sector_mask, n, tmp,
|
||||
sizeof(tmp));
|
||||
if (!r) {
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -252,10 +254,11 @@ static int bios_boot(struct bios *bios) {
|
|||
|
||||
/* check root directory for the bootfile */
|
||||
struct iso_dir *root = &pvd->root_directory_record;
|
||||
int len = align_up(root->size.le, secsz);
|
||||
int len = align_up(root->size.le, sector_size);
|
||||
fad = GDROM_PREGAP + root->extent.le;
|
||||
n = len / secsz;
|
||||
r = gdrom_read_sectors(gd, fad, secfmt, secmask, n, tmp, sizeof(tmp));
|
||||
n = len / sector_size;
|
||||
r = gdrom_read_sectors(gd, fad, sector_fmt, sector_mask, n, tmp,
|
||||
sizeof(tmp));
|
||||
if (!r) {
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -284,8 +287,9 @@ static int bios_boot(struct bios *bios) {
|
|||
/* copy the bootfile into ram */
|
||||
struct iso_dir *dir = (struct iso_dir *)ptr;
|
||||
fad = GDROM_PREGAP + dir->extent.le;
|
||||
n = align_up(dir->size.le, secsz) / secsz;
|
||||
r = gdrom_copy_sectors(gd, fad, secfmt, secmask, n, space, BOOT2_ADDR);
|
||||
n = align_up(dir->size.le, sector_size) / sector_size;
|
||||
r = gdrom_copy_sectors(gd, fad, sector_fmt, sector_mask, n, space,
|
||||
BOOT2_ADDR);
|
||||
if (!r) {
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -138,8 +138,8 @@ static void bios_gdrom_mainloop(struct bios *bios) {
|
|||
uint32_t n = bios->params[1];
|
||||
uint32_t dst = bios->params[2];
|
||||
uint32_t unknown = bios->params[3];
|
||||
enum gd_secfmt fmt = SECTOR_ANY;
|
||||
enum gd_secmask mask = MASK_DATA;
|
||||
int fmt = GD_SECTOR_ANY;
|
||||
int mask = GD_MASK_DATA;
|
||||
|
||||
LOG_SYSCALL("GDC_DMAREAD fad=0x%x n=0x%x dst=0x%x unknown=0x%x", fad, n,
|
||||
dst, unknown);
|
||||
|
|
@ -166,7 +166,7 @@ static void bios_gdrom_mainloop(struct bios *bios) {
|
|||
|
||||
LOG_SYSCALL("GDC_GETTOC2 0=0x%x 1=0x%x", area, dst);
|
||||
|
||||
uint8_t toc[SPI_TOC_SIZE];
|
||||
uint8_t toc[GD_SPI_TOC_SIZE];
|
||||
gdrom_get_toc(gd, area, toc, sizeof(toc));
|
||||
|
||||
/* byte swap to little endian */
|
||||
|
|
@ -263,7 +263,7 @@ static void bios_gdrom_mainloop(struct bios *bios) {
|
|||
|
||||
LOG_SYSCALL("GDC_GET_SCD 0x%x 0x%x 0x%x", format, size, dst);
|
||||
|
||||
uint8_t scd[SPI_SCD_SIZE];
|
||||
uint8_t scd[GD_SPI_SCD_SIZE];
|
||||
gdrom_get_subcode(gd, format, scd, sizeof(scd));
|
||||
|
||||
CHECK_EQ(scd[3], size);
|
||||
|
|
@ -281,7 +281,7 @@ static void bios_gdrom_mainloop(struct bios *bios) {
|
|||
case GDC_REQ_STAT: {
|
||||
LOG_SYSCALL("GDC_REQ_STAT");
|
||||
|
||||
uint8_t status[SPI_STAT_SIZE];
|
||||
uint8_t status[GD_SPI_STAT_SIZE];
|
||||
gdrom_get_status(gd, status, sizeof(status));
|
||||
|
||||
uint32_t drive_status = status[0];
|
||||
|
|
@ -472,7 +472,7 @@ void bios_gdrom_vector(struct bios *bios) {
|
|||
|
||||
LOG_SYSCALL("GDROM_CHECK_DRIVE 0x%x", result);
|
||||
|
||||
uint8_t status[SPI_STAT_SIZE];
|
||||
uint8_t status[GD_SPI_STAT_SIZE];
|
||||
gdrom_get_status(gd, status, sizeof(status));
|
||||
|
||||
uint32_t cond[2];
|
||||
|
|
|
|||
|
|
@ -15,8 +15,8 @@ static const char *cdi_version_names[] = {
|
|||
|
||||
static const int cdi_sector_sizes[] = {2048, 2336, 2352};
|
||||
|
||||
static const enum gd_secfmt cdi_sector_formats[] = {
|
||||
SECTOR_CDDA, 0, SECTOR_M2F1,
|
||||
static const int cdi_sector_formats[] = {
|
||||
GD_SECTOR_CDDA, 0, GD_SECTOR_M2F1,
|
||||
};
|
||||
|
||||
static const char *cdi_modes[] = {
|
||||
|
|
@ -34,23 +34,23 @@ struct cdi {
|
|||
int num_tracks;
|
||||
};
|
||||
|
||||
static int cdi_read_sector(struct disc *disc, int fad, enum gd_secfmt fmt,
|
||||
enum gd_secmask mask, void *dst) {
|
||||
static int cdi_read_sector(struct disc *disc, int fad, int sector_fmt,
|
||||
int sector_mask, void *dst) {
|
||||
struct cdi *cdi = (struct cdi *)disc;
|
||||
|
||||
struct track *track = disc_lookup_track(disc, fad);
|
||||
CHECK_NOTNULL(track);
|
||||
CHECK(fmt == SECTOR_ANY || fmt == track->sector_fmt);
|
||||
CHECK(mask == MASK_DATA);
|
||||
CHECK(sector_fmt == GD_SECTOR_ANY || sector_fmt == track->sector_fmt);
|
||||
CHECK(sector_mask == GD_MASK_DATA);
|
||||
|
||||
/* read the user data portion of the sector */
|
||||
int offset, size;
|
||||
|
||||
if (track->sector_fmt == SECTOR_CDDA) {
|
||||
if (track->sector_fmt == GD_SECTOR_CDDA) {
|
||||
offset = track->file_offset + fad * track->sector_size;
|
||||
size = track->sector_size;
|
||||
CHECK_EQ(size, 2352);
|
||||
} else if (track->sector_fmt == SECTOR_M2F1) {
|
||||
} else if (track->sector_fmt == GD_SECTOR_M2F1) {
|
||||
offset = track->file_offset + fad * track->sector_size + 8;
|
||||
size = track->sector_size - 288;
|
||||
CHECK_EQ(size, 2048);
|
||||
|
|
@ -67,13 +67,13 @@ static int cdi_read_sector(struct disc *disc, int fad, enum gd_secfmt fmt,
|
|||
return res;
|
||||
}
|
||||
|
||||
static void cdi_get_toc(struct disc *disc, enum gd_area area,
|
||||
struct track **first_track, struct track **last_track,
|
||||
int *leadin_fad, int *leadout_fad) {
|
||||
static void cdi_get_toc(struct disc *disc, int area, struct track **first_track,
|
||||
struct track **last_track, int *leadin_fad,
|
||||
int *leadout_fad) {
|
||||
struct cdi *cdi = (struct cdi *)disc;
|
||||
|
||||
/* cdi's have no high-density area */
|
||||
CHECK_EQ(area, AREA_SINGLE);
|
||||
CHECK_EQ(area, GD_AREA_SINGLE);
|
||||
|
||||
/* the toc on cdi's represents all tracks / sessions */
|
||||
struct session *first_session = &cdi->sessions[0];
|
||||
|
|
@ -108,7 +108,7 @@ static int cdi_get_num_sessions(struct disc *disc) {
|
|||
}
|
||||
|
||||
static int cdi_get_format(struct disc *disc) {
|
||||
return DISC_CDROM_XA;
|
||||
return GD_DISC_CDROM_XA;
|
||||
}
|
||||
|
||||
static void cdi_destroy(struct disc *disc) {
|
||||
|
|
@ -200,15 +200,15 @@ static int cdi_parse_track(struct disc *disc, uint32_t version,
|
|||
return 0;
|
||||
}
|
||||
|
||||
int sector_fmt = cdi_sector_formats[mode];
|
||||
int sector_size = cdi_sector_sizes[sector_type];
|
||||
enum gd_secfmt sector_fmt = cdi_sector_formats[mode];
|
||||
int data_offset = *track_offset + pregap_length * sector_size;
|
||||
|
||||
track->fad = pregap_length + lba;
|
||||
track->adr = 0;
|
||||
track->ctrl = sector_fmt == SECTOR_CDDA ? 0 : 4;
|
||||
track->sector_size = sector_size;
|
||||
track->ctrl = sector_fmt == GD_SECTOR_CDDA ? 0 : 4;
|
||||
track->sector_fmt = cdi_sector_formats[mode];
|
||||
track->sector_size = sector_size;
|
||||
track->file_offset = data_offset - track->fad * track->sector_size;
|
||||
|
||||
LOG_INFO("cdi_parse_track track=%d fad=%d off=%d mode=%s/%d", track->num,
|
||||
|
|
|
|||
|
|
@ -28,14 +28,14 @@ struct track *disc_lookup_track(struct disc *disc, int fad) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
int disc_read_sector(struct disc *disc, int fad, enum gd_secfmt fmt,
|
||||
enum gd_secmask mask, void *dst) {
|
||||
return disc->read_sector(disc, fad, fmt, mask, dst);
|
||||
int disc_read_sector(struct disc *disc, int fad, int sector_fmt,
|
||||
int sector_mask, void *dst) {
|
||||
return disc->read_sector(disc, fad, sector_fmt, sector_mask, dst);
|
||||
}
|
||||
|
||||
void disc_get_toc(struct disc *disc, enum gd_area area,
|
||||
struct track **first_track, struct track **last_track,
|
||||
int *leadin_fad, int *leadout_fad) {
|
||||
void disc_get_toc(struct disc *disc, int area, struct track **first_track,
|
||||
struct track **last_track, int *leadin_fad,
|
||||
int *leadout_fad) {
|
||||
disc->get_toc(disc, area, first_track, last_track, leadin_fad, leadout_fad);
|
||||
}
|
||||
|
||||
|
|
@ -67,7 +67,7 @@ void disc_get_meta(struct disc *disc, struct disc_meta *meta) {
|
|||
struct session *session = disc_get_session(disc, 1);
|
||||
|
||||
uint8_t tmp[DISC_MAX_SECTOR_SIZE];
|
||||
disc_read_sector(disc, session->leadin_fad, SECTOR_ANY, MASK_DATA, tmp);
|
||||
disc_read_sector(disc, session->leadin_fad, GD_SECTOR_ANY, GD_MASK_DATA, tmp);
|
||||
|
||||
memcpy(meta, tmp, sizeof(*meta));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,8 +13,8 @@ struct track {
|
|||
int fad;
|
||||
int adr;
|
||||
int ctrl;
|
||||
int sector_fmt;
|
||||
int sector_size;
|
||||
enum gd_secfmt sector_fmt;
|
||||
char filename[PATH_MAX];
|
||||
int file_offset;
|
||||
};
|
||||
|
|
@ -52,10 +52,9 @@ struct disc {
|
|||
int (*get_num_tracks)(struct disc *);
|
||||
struct track *(*get_track)(struct disc *, int);
|
||||
|
||||
void (*get_toc)(struct disc *, enum gd_area, struct track **, struct track **,
|
||||
int *, int *);
|
||||
int (*read_sector)(struct disc *, int, enum gd_secfmt, enum gd_secmask,
|
||||
void *);
|
||||
void (*get_toc)(struct disc *, int, struct track **, struct track **, int *,
|
||||
int *);
|
||||
int (*read_sector)(struct disc *, int, int, int, void *);
|
||||
};
|
||||
|
||||
struct disc *disc_create(const char *filename);
|
||||
|
|
@ -67,11 +66,10 @@ int disc_get_num_sessions(struct disc *disc);
|
|||
struct session *disc_get_session(struct disc *disc, int n);
|
||||
int disc_get_num_tracks(struct disc *disc);
|
||||
struct track *disc_get_track(struct disc *disc, int n);
|
||||
void disc_get_toc(struct disc *disc, enum gd_area area,
|
||||
struct track **first_track, struct track **last_track,
|
||||
int *leadin_fad, int *leadout_fad);
|
||||
int disc_read_sector(struct disc *disc, int fad, enum gd_secfmt fmt,
|
||||
enum gd_secmask mask, void *dst);
|
||||
void disc_get_toc(struct disc *disc, int area, struct track **first_track,
|
||||
struct track **last_track, int *leadin_fad, int *leadout_fad);
|
||||
int disc_read_sector(struct disc *disc, int fad, int sector_fmt,
|
||||
int sector_mask, void *dst);
|
||||
struct track *disc_lookup_track(struct disc *disc, int fad);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -11,14 +11,14 @@ struct gdi {
|
|||
int num_tracks;
|
||||
};
|
||||
|
||||
static int gdi_read_sector(struct disc *disc, int fad, enum gd_secfmt fmt,
|
||||
enum gd_secmask mask, void *dst) {
|
||||
static int gdi_read_sector(struct disc *disc, int fad, int sector_fmt,
|
||||
int sector_mask, void *dst) {
|
||||
struct gdi *gdi = (struct gdi *)disc;
|
||||
|
||||
struct track *track = disc_lookup_track(disc, fad);
|
||||
CHECK_NOTNULL(track);
|
||||
CHECK(fmt == SECTOR_ANY || fmt == track->sector_fmt);
|
||||
CHECK(mask == MASK_DATA);
|
||||
CHECK(sector_fmt == GD_SECTOR_ANY || sector_fmt == track->sector_fmt);
|
||||
CHECK(sector_mask == GD_MASK_DATA);
|
||||
|
||||
/* open the file backing the track */
|
||||
int n = (int)(track - gdi->tracks);
|
||||
|
|
@ -43,9 +43,9 @@ static int gdi_read_sector(struct disc *disc, int fad, enum gd_secfmt fmt,
|
|||
return res;
|
||||
}
|
||||
|
||||
static void gdi_get_toc(struct disc *disc, enum gd_area area,
|
||||
struct track **first_track, struct track **last_track,
|
||||
int *leadin_fad, int *leadout_fad) {
|
||||
static void gdi_get_toc(struct disc *disc, int area, struct track **first_track,
|
||||
struct track **last_track, int *leadin_fad,
|
||||
int *leadout_fad) {
|
||||
struct gdi *gdi = (struct gdi *)disc;
|
||||
|
||||
/* gdi's have one toc per area, and there is one session per area */
|
||||
|
|
@ -80,7 +80,7 @@ static int gdi_get_num_sessions(struct disc *disc) {
|
|||
}
|
||||
|
||||
static int gdi_get_format(struct disc *disc) {
|
||||
return DISC_GDROM;
|
||||
return GD_DISC_GDROM;
|
||||
}
|
||||
|
||||
static void gdi_destroy(struct disc *disc) {
|
||||
|
|
@ -151,8 +151,8 @@ static int gdi_parse(struct disc *disc, const char *filename) {
|
|||
track->num = gdi->num_tracks;
|
||||
track->fad = lba + GDROM_PREGAP;
|
||||
track->ctrl = ctrl;
|
||||
track->sector_fmt = GD_SECTOR_M1;
|
||||
track->sector_size = sector_size;
|
||||
track->sector_fmt = SECTOR_M1;
|
||||
track->file_offset = file_offset - track->fad * track->sector_size;
|
||||
snprintf(track->filename, sizeof(track->filename), "%s" PATH_SEPARATOR "%s",
|
||||
dirname, filename);
|
||||
|
|
|
|||
|
|
@ -67,8 +67,8 @@ struct gdrom {
|
|||
|
||||
/* cdread state */
|
||||
int cdr_dma;
|
||||
enum gd_secfmt cdr_secfmt;
|
||||
enum gd_secmask cdr_secmask;
|
||||
int cdr_secfmt;
|
||||
int cdr_secmask;
|
||||
int cdr_first_sector;
|
||||
int cdr_num_sectors;
|
||||
|
||||
|
|
@ -224,7 +224,7 @@ static void gdrom_pio_read(struct gdrom *gd, int arg) {
|
|||
|
||||
static void gdrom_spi_cmd(struct gdrom *gd, int arg) {
|
||||
uint8_t *data = gd->pio_buffer;
|
||||
enum gd_spi_cmd cmd = (enum gd_spi_cmd)data[0];
|
||||
int cmd = data[0];
|
||||
|
||||
LOG_GDROM("gdrom_spi_cmd 0x%x", cmd);
|
||||
|
||||
|
|
@ -235,82 +235,82 @@ static void gdrom_spi_cmd(struct gdrom *gd, int arg) {
|
|||
/*
|
||||
* packet command flow for pio data to host
|
||||
*/
|
||||
case SPI_REQ_STAT: {
|
||||
case GD_SPI_REQ_STAT: {
|
||||
int offset = data[2];
|
||||
int size = data[4];
|
||||
|
||||
uint8_t stat[SPI_STAT_SIZE];
|
||||
uint8_t stat[GD_SPI_STAT_SIZE];
|
||||
gdrom_get_status(gd, stat, sizeof(stat));
|
||||
|
||||
gdrom_spi_write(gd, stat + offset, size);
|
||||
} break;
|
||||
|
||||
case SPI_REQ_MODE: {
|
||||
case GD_SPI_REQ_MODE: {
|
||||
int offset = data[2];
|
||||
int size = data[4];
|
||||
|
||||
gdrom_spi_write(gd, (uint8_t *)&gd->hw_info + offset, size);
|
||||
} break;
|
||||
|
||||
case SPI_REQ_ERROR: {
|
||||
case GD_SPI_REQ_ERROR: {
|
||||
int size = data[4];
|
||||
|
||||
uint8_t err[SPI_ERR_SIZE];
|
||||
uint8_t err[GD_SPI_ERR_SIZE];
|
||||
gdrom_get_error(gd, err, sizeof(err));
|
||||
|
||||
gdrom_spi_write(gd, err, size);
|
||||
} break;
|
||||
|
||||
case SPI_GET_TOC: {
|
||||
enum gd_area area = (enum gd_area)(data[1] & 0x1);
|
||||
case GD_SPI_GET_TOC: {
|
||||
int area = (data[1] & 0x1);
|
||||
int size = (data[3] << 8) | data[4];
|
||||
|
||||
uint8_t toc[SPI_TOC_SIZE];
|
||||
uint8_t toc[GD_SPI_TOC_SIZE];
|
||||
gdrom_get_toc(gd, area, toc, sizeof(toc));
|
||||
|
||||
gdrom_spi_write(gd, toc, size);
|
||||
} break;
|
||||
|
||||
case SPI_REQ_SES: {
|
||||
case GD_SPI_REQ_SES: {
|
||||
int session = data[2];
|
||||
int size = data[4];
|
||||
|
||||
uint8_t ses[SPI_SES_SIZE];
|
||||
uint8_t ses[GD_SPI_SES_SIZE];
|
||||
gdrom_get_session(gd, session, ses, sizeof(ses));
|
||||
|
||||
gdrom_spi_write(gd, ses, sizeof(ses));
|
||||
} break;
|
||||
|
||||
case SPI_GET_SCD: {
|
||||
case GD_SPI_GET_SCD: {
|
||||
int format = data[1] & 0xf;
|
||||
int size = (data[3] << 8) | data[4];
|
||||
|
||||
uint8_t scd[SPI_SCD_SIZE];
|
||||
uint8_t scd[GD_SPI_SCD_SIZE];
|
||||
gdrom_get_subcode(gd, format, scd, sizeof(scd));
|
||||
|
||||
gdrom_spi_write(gd, scd, size);
|
||||
} break;
|
||||
|
||||
case SPI_CD_READ: {
|
||||
case GD_SPI_CD_READ: {
|
||||
int msf = (data[1] & 0x1);
|
||||
|
||||
gd->cdr_dma = gd->features.dma;
|
||||
gd->cdr_secfmt = (enum gd_secfmt)((data[1] & 0xe) >> 1);
|
||||
gd->cdr_secmask = (enum gd_secmask)((data[1] >> 4) & 0xff);
|
||||
gd->cdr_secfmt = (data[1] & 0xe) >> 1;
|
||||
gd->cdr_secmask = (data[1] >> 4) & 0xff;
|
||||
gd->cdr_first_sector = gdrom_get_fad(data[2], data[3], data[4], msf);
|
||||
gd->cdr_num_sectors = (data[8] << 16) | (data[9] << 8) | data[10];
|
||||
|
||||
gdrom_spi_cdread(gd);
|
||||
} break;
|
||||
|
||||
case SPI_CD_READ2: {
|
||||
LOG_FATAL("SPI_CD_READ2");
|
||||
case GD_SPI_CD_READ2: {
|
||||
LOG_FATAL("GD_SPI_CD_READ2");
|
||||
} break;
|
||||
|
||||
/*
|
||||
* packet command flow for pio data from host
|
||||
*/
|
||||
case SPI_SET_MODE: {
|
||||
case GD_SPI_SET_MODE: {
|
||||
int offset = data[2];
|
||||
int size = data[4];
|
||||
|
||||
|
|
@ -320,58 +320,58 @@ static void gdrom_spi_cmd(struct gdrom *gd, int arg) {
|
|||
/*
|
||||
* non-data command flow
|
||||
*/
|
||||
case SPI_TEST_UNIT: {
|
||||
case GD_SPI_TEST_UNIT: {
|
||||
gdrom_spi_end(gd);
|
||||
} break;
|
||||
|
||||
case SPI_CD_OPEN: {
|
||||
LOG_FATAL("SPI_CD_OPEN");
|
||||
case GD_SPI_CD_OPEN: {
|
||||
LOG_FATAL("GD_SPI_CD_OPEN");
|
||||
} break;
|
||||
|
||||
case SPI_CD_PLAY: {
|
||||
LOG_WARNING("ignoring SPI_CD_PLAY");
|
||||
case GD_SPI_CD_PLAY: {
|
||||
LOG_WARNING("ignoring GD_SPI_CD_PLAY");
|
||||
|
||||
gd->sectnum.status = DST_PAUSE;
|
||||
gd->sectnum.status = GD_STATUS_PAUSE;
|
||||
|
||||
gdrom_spi_end(gd);
|
||||
} break;
|
||||
|
||||
case SPI_CD_SEEK: {
|
||||
enum gd_seek_type param_type = (enum gd_seek_type)(data[1] & 0xf);
|
||||
case GD_SPI_CD_SEEK: {
|
||||
int param_type = data[1] & 0xf;
|
||||
|
||||
LOG_WARNING("ignoring SPI_CD_SEEK");
|
||||
LOG_WARNING("ignoring GD_SPI_CD_SEEK");
|
||||
|
||||
switch (param_type) {
|
||||
case SEEK_FAD:
|
||||
case SEEK_MSF:
|
||||
case SEEK_PAUSE:
|
||||
gd->sectnum.status = DST_PAUSE;
|
||||
case GD_SEEK_FAD:
|
||||
case GD_SEEK_MSF:
|
||||
case GD_SEEK_PAUSE:
|
||||
gd->sectnum.status = GD_STATUS_PAUSE;
|
||||
break;
|
||||
case SEEK_STOP:
|
||||
gd->sectnum.status = DST_STANDBY;
|
||||
case GD_SEEK_STOP:
|
||||
gd->sectnum.status = GD_STATUS_STANDBY;
|
||||
break;
|
||||
}
|
||||
|
||||
gdrom_spi_end(gd);
|
||||
} break;
|
||||
|
||||
case SPI_CD_SCAN: {
|
||||
LOG_WARNING("ignoring SPI_CD_SCAN");
|
||||
case GD_SPI_CD_SCAN: {
|
||||
LOG_WARNING("ignoring GD_SPI_CD_SCAN");
|
||||
|
||||
gd->sectnum.status = DST_PAUSE;
|
||||
gd->sectnum.status = GD_STATUS_PAUSE;
|
||||
|
||||
gdrom_spi_end(gd);
|
||||
} break;
|
||||
|
||||
/* SPI_CHK_SECU / SPI_REQ_SECU are part of an undocumented security check
|
||||
that has yet to be fully reverse engineered. the check doesn't seem to
|
||||
have any side effects, a canned response is sent when the results are
|
||||
/* GD_SPI_CHK_SECU and GD_SPI_REQ_SECU are part of an undocumented security
|
||||
check that has yet to be fully reverse engineered. the check doesn't seem
|
||||
to have any side effects, a canned response is sent when the results are
|
||||
requested */
|
||||
case SPI_CHK_SECU: {
|
||||
case GD_SPI_CHK_SECU: {
|
||||
gdrom_spi_end(gd);
|
||||
} break;
|
||||
|
||||
case SPI_REQ_SECU: {
|
||||
case GD_SPI_REQ_SECU: {
|
||||
gdrom_spi_write(gd, (uint8_t *)reply_71, sizeof(reply_71));
|
||||
} break;
|
||||
|
||||
|
|
@ -382,15 +382,14 @@ static void gdrom_spi_cmd(struct gdrom *gd, int arg) {
|
|||
}
|
||||
|
||||
static void gdrom_pio_write(struct gdrom *gd, int arg) {
|
||||
if (gd->state == STATE_READ_ATA_DATA && gd->pio_head == SPI_CMD_SIZE) {
|
||||
if (gd->state == STATE_READ_ATA_DATA && gd->pio_head == GD_SPI_CMD_SIZE) {
|
||||
gdrom_event(gd, EVENT_SPI_CMD, 0);
|
||||
} else if (gd->state == STATE_READ_SPI_DATA && gd->pio_head == gd->pio_size) {
|
||||
gdrom_event(gd, EVENT_SPI_DATA, 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void gdrom_ata_cmd(struct gdrom *gd, int arg) {
|
||||
enum gd_ata_cmd cmd = (enum gd_ata_cmd)arg;
|
||||
static void gdrom_ata_cmd(struct gdrom *gd, int cmd) {
|
||||
int read_data = 0;
|
||||
|
||||
LOG_GDROM("gdrom_ata_cmd 0x%x", cmd);
|
||||
|
|
@ -404,29 +403,29 @@ static void gdrom_ata_cmd(struct gdrom *gd, int arg) {
|
|||
gd->status.CHECK = 0;
|
||||
|
||||
switch (cmd) {
|
||||
case ATA_NOP: {
|
||||
case GD_ATA_NOP: {
|
||||
/* terminates the current command */
|
||||
gd->error.ABRT = 1;
|
||||
gd->status.CHECK = 1;
|
||||
} break;
|
||||
|
||||
case ATA_SOFT_RESET: {
|
||||
case GD_ATA_SOFT_RESET: {
|
||||
gdrom_set_disc(gd, gd->disc);
|
||||
} break;
|
||||
|
||||
case ATA_EXEC_DIAG: {
|
||||
LOG_FATAL("ATA_EXEC_DIAG");
|
||||
case GD_ATA_EXEC_DIAG: {
|
||||
LOG_FATAL("GD_ATA_EXEC_DIAG");
|
||||
} break;
|
||||
|
||||
case ATA_PACKET_CMD: {
|
||||
case GD_ATA_PACKET_CMD: {
|
||||
read_data = 1;
|
||||
} break;
|
||||
|
||||
case ATA_IDENTIFY_DEV: {
|
||||
LOG_FATAL("ATA_IDENTIFY_DEV");
|
||||
case GD_ATA_IDENTIFY_DEV: {
|
||||
LOG_FATAL("GD_ATA_IDENTIFY_DEV");
|
||||
} break;
|
||||
|
||||
case ATA_SET_FEATURES: {
|
||||
case GD_ATA_SET_FEATURES: {
|
||||
/* transfer mode settings are ignored */
|
||||
} break;
|
||||
|
||||
|
|
@ -455,9 +454,9 @@ static void gdrom_event(struct gdrom *gd, enum gd_event ev, int arg) {
|
|||
cb(gd, arg);
|
||||
}
|
||||
|
||||
int gdrom_copy_sectors(struct gdrom *gd, int fad, enum gd_secfmt fmt,
|
||||
enum gd_secmask mask, int num_sectors,
|
||||
struct address_space *space, uint32_t dst) {
|
||||
int gdrom_copy_sectors(struct gdrom *gd, int fad, int fmt, int mask,
|
||||
int num_sectors, struct address_space *space,
|
||||
uint32_t dst) {
|
||||
if (!gd->disc) {
|
||||
LOG_WARNING("gdrom_copy_sectors failed, no disc");
|
||||
return 0;
|
||||
|
|
@ -475,9 +474,8 @@ int gdrom_copy_sectors(struct gdrom *gd, int fad, enum gd_secfmt fmt,
|
|||
return read;
|
||||
}
|
||||
|
||||
int gdrom_read_sectors(struct gdrom *gd, int fad, enum gd_secfmt fmt,
|
||||
enum gd_secmask mask, int num_sectors, uint8_t *dst,
|
||||
int dst_size) {
|
||||
int gdrom_read_sectors(struct gdrom *gd, int fad, int fmt, int mask,
|
||||
int num_sectors, uint8_t *dst, int dst_size) {
|
||||
if (!gd->disc) {
|
||||
LOG_WARNING("gdrom_read_sectors failed, no disc");
|
||||
return 0;
|
||||
|
|
@ -500,11 +498,11 @@ int gdrom_read_sectors(struct gdrom *gd, int fad, enum gd_secfmt fmt,
|
|||
|
||||
void gdrom_get_subcode(struct gdrom *gd, int format, uint8_t *data, int size) {
|
||||
CHECK_NOTNULL(gd->disc);
|
||||
CHECK_GE(size, SPI_SCD_SIZE);
|
||||
CHECK_GE(size, GD_SPI_SCD_SIZE);
|
||||
|
||||
/* FIXME implement */
|
||||
memset(data, 0, SPI_SCD_SIZE);
|
||||
data[1] = AST_NOSTATUS;
|
||||
memset(data, 0, GD_SPI_SCD_SIZE);
|
||||
data[1] = GD_AUDIO_NOSTATUS;
|
||||
|
||||
switch (format) {
|
||||
case 0:
|
||||
|
|
@ -523,7 +521,7 @@ void gdrom_get_subcode(struct gdrom *gd, int format, uint8_t *data, int size) {
|
|||
void gdrom_get_session(struct gdrom *gd, int session_num, uint8_t *data,
|
||||
int size) {
|
||||
CHECK_NOTNULL(gd->disc);
|
||||
CHECK_GE(size, SPI_SES_SIZE);
|
||||
CHECK_GE(size, GD_SPI_SES_SIZE);
|
||||
|
||||
/* session response layout:
|
||||
|
||||
|
|
@ -574,10 +572,9 @@ void gdrom_get_session(struct gdrom *gd, int session_num, uint8_t *data,
|
|||
memcpy(&data[3], &fad, 3);
|
||||
}
|
||||
|
||||
void gdrom_get_toc(struct gdrom *gd, enum gd_area area, uint8_t *data,
|
||||
int size) {
|
||||
void gdrom_get_toc(struct gdrom *gd, int area, uint8_t *data, int size) {
|
||||
CHECK_NOTNULL(gd->disc);
|
||||
CHECK_GE(size, SPI_TOC_SIZE);
|
||||
CHECK_GE(size, GD_SPI_TOC_SIZE);
|
||||
|
||||
/* toc response layout:
|
||||
|
||||
|
|
@ -624,7 +621,7 @@ void gdrom_get_toc(struct gdrom *gd, enum gd_area area, uint8_t *data,
|
|||
&leadout_fad);
|
||||
|
||||
/* 0xffffffff represents an invalid track */
|
||||
memset(data, 0xff, SPI_TOC_SIZE);
|
||||
memset(data, 0xff, GD_SPI_TOC_SIZE);
|
||||
|
||||
/* write out entries for each track */
|
||||
uint32_t *entry = (uint32_t *)data;
|
||||
|
|
@ -644,7 +641,7 @@ void gdrom_get_toc(struct gdrom *gd, enum gd_area area, uint8_t *data,
|
|||
|
||||
void gdrom_get_error(struct gdrom *gd, uint8_t *data, int size) {
|
||||
CHECK_NOTNULL(gd->disc);
|
||||
CHECK_GE(size, SPI_ERR_SIZE);
|
||||
CHECK_GE(size, GD_SPI_ERR_SIZE);
|
||||
|
||||
/* cd status information response layout:
|
||||
|
||||
|
|
@ -681,7 +678,7 @@ void gdrom_get_error(struct gdrom *gd, uint8_t *data, int size) {
|
|||
|
||||
void gdrom_get_status(struct gdrom *gd, uint8_t *data, int size) {
|
||||
CHECK_NOTNULL(gd->disc);
|
||||
CHECK_GE(size, SPI_STAT_SIZE);
|
||||
CHECK_GE(size, GD_SPI_STAT_SIZE);
|
||||
|
||||
/* cd status information response layout:
|
||||
|
||||
|
|
@ -814,10 +811,10 @@ void gdrom_set_disc(struct gdrom *gd, struct disc *disc) {
|
|||
|
||||
gd->sectnum.full = 0;
|
||||
if (gd->disc) {
|
||||
gd->sectnum.status = DST_PAUSE;
|
||||
gd->sectnum.status = GD_STATUS_PAUSE;
|
||||
gd->sectnum.format = disc_get_format(disc);
|
||||
} else {
|
||||
gd->sectnum.status = DST_NODISC;
|
||||
gd->sectnum.status = GD_STATUS_NODISC;
|
||||
}
|
||||
|
||||
/* TODO how do GD_FEATURES, GD_INTREASON, GD_BYCTLLO and GD_BYCTLHI behave */
|
||||
|
|
|
|||
|
|
@ -20,14 +20,13 @@ void gdrom_get_drive_mode(struct gdrom *gd, struct gd_hw_info *info);
|
|||
void gdrom_set_drive_mode(struct gdrom *gd, struct gd_hw_info *info);
|
||||
void gdrom_get_status(struct gdrom *gd, uint8_t *data, int size);
|
||||
void gdrom_get_error(struct gdrom *gd, uint8_t *data, int size);
|
||||
void gdrom_get_toc(struct gdrom *gd, enum gd_area area_type, uint8_t *data,
|
||||
int size);
|
||||
void gdrom_get_toc(struct gdrom *gd, int area, uint8_t *data, int size);
|
||||
void gdrom_get_session(struct gdrom *gd, int session, uint8_t *data, int size);
|
||||
void gdrom_get_subcode(struct gdrom *gd, int format, uint8_t *data, int size);
|
||||
int gdrom_read_sectors(struct gdrom *gd, int fad, enum gd_secfmt fmt,
|
||||
enum gd_secmask mask, int n, uint8_t *dst, int dst_size);
|
||||
int gdrom_copy_sectors(struct gdrom *gd, int fad, enum gd_secfmt fmt,
|
||||
enum gd_secmask mask, int num_sectors,
|
||||
struct address_space *space, uint32_t dst);
|
||||
int gdrom_read_sectors(struct gdrom *gd, int fad, int fmt, int mask, int n,
|
||||
uint8_t *dst, int dst_size);
|
||||
int gdrom_copy_sectors(struct gdrom *gd, int fad, int fmt, int mask,
|
||||
int num_sectors, struct address_space *space,
|
||||
uint32_t dst);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -5,101 +5,101 @@
|
|||
|
||||
#define GDROM_PREGAP 150
|
||||
|
||||
enum gd_drive_status {
|
||||
DST_BUSY = 0x00, /* State transition */
|
||||
DST_PAUSE = 0x01, /* Pause */
|
||||
DST_STANDBY = 0x02, /* Standby (drive stop) */
|
||||
DST_PLAY = 0x03, /* CD playback */
|
||||
DST_SEEK = 0x04, /* Seeking */
|
||||
DST_SCAN = 0x05, /* Scanning */
|
||||
DST_OPEN = 0x06, /* Tray is open */
|
||||
DST_NODISC = 0x07, /* No disc */
|
||||
DST_RETRY = 0x08, /* Read retry in progress */
|
||||
DST_ERROR = 0x09, /* Reading of disc TOC failed */
|
||||
};
|
||||
|
||||
enum gd_disc {
|
||||
DISC_CDDA = 0x00,
|
||||
DISC_CDROM = 0x01,
|
||||
DISC_CDROM_XA = 0x02,
|
||||
DISC_CDROM_CDI = 0x03,
|
||||
DISC_GDROM = 0x08,
|
||||
};
|
||||
|
||||
/* ata / spi commands */
|
||||
enum gd_ata_cmd {
|
||||
ATA_NOP = 0x00,
|
||||
ATA_SOFT_RESET = 0x08,
|
||||
ATA_EXEC_DIAG = 0x90,
|
||||
ATA_PACKET_CMD = 0xa0,
|
||||
ATA_IDENTIFY_DEV = 0xa1,
|
||||
ATA_SET_FEATURES = 0xef,
|
||||
};
|
||||
|
||||
enum gd_spi_cmd {
|
||||
SPI_TEST_UNIT = 0x00, /* Verify access readiness */
|
||||
SPI_REQ_STAT = 0x10, /* Get CD status */
|
||||
SPI_REQ_MODE = 0x11, /* Get various settings */
|
||||
SPI_SET_MODE = 0x12, /* Make various settings */
|
||||
SPI_REQ_ERROR = 0x13, /* Get error details */
|
||||
SPI_GET_TOC = 0x14, /* Get all TOC data */
|
||||
SPI_REQ_SES = 0x15, /* Get specified session data */
|
||||
SPI_CD_OPEN = 0x16, /* Open tray */
|
||||
SPI_CD_PLAY = 0x20, /* Play CD */
|
||||
SPI_CD_SEEK = 0x21, /* Seek for playback position */
|
||||
SPI_CD_SCAN = 0x22, /* Perform scan */
|
||||
SPI_CD_READ = 0x30, /* Read CD */
|
||||
SPI_CD_READ2 = 0x31, /* CD read (pre-read position) */
|
||||
SPI_GET_SCD = 0x40, /* Get subcode */
|
||||
SPI_CHK_SECU = 0x70, /* Perform disk security check */
|
||||
SPI_REQ_SECU = 0x71, /* Get security check result */
|
||||
enum {
|
||||
GD_STATUS_BUSY = 0x00, /* State transition */
|
||||
GD_STATUS_PAUSE = 0x01, /* Pause */
|
||||
GD_STATUS_STANDBY = 0x02, /* Standby (drive stop) */
|
||||
GD_STATUS_PLAY = 0x03, /* CD playback */
|
||||
GD_STATUS_SEEK = 0x04, /* Seeking */
|
||||
GD_STATUS_SCAN = 0x05, /* Scanning */
|
||||
GD_STATUS_OPEN = 0x06, /* Tray is open */
|
||||
GD_STATUS_NODISC = 0x07, /* No disc */
|
||||
GD_STATUS_RETRY = 0x08, /* Read retry in progress */
|
||||
GD_STATUS_ERROR = 0x09, /* Reading of disc TOC failed */
|
||||
};
|
||||
|
||||
enum {
|
||||
SPI_CMD_SIZE = 12,
|
||||
SPI_ERR_SIZE = 10,
|
||||
SPI_TOC_SIZE = 408,
|
||||
SPI_SES_SIZE = 6,
|
||||
SPI_STAT_SIZE = 10,
|
||||
SPI_SCD_SIZE = 100,
|
||||
GD_DISC_CDDA = 0x00,
|
||||
GD_DISC_CDROM = 0x01,
|
||||
GD_DISC_CDROM_XA = 0x02,
|
||||
GD_DISC_CDROM_CDI = 0x03,
|
||||
GD_DISC_GDROM = 0x08,
|
||||
};
|
||||
|
||||
enum gd_area {
|
||||
AREA_SINGLE,
|
||||
AREA_HIGH,
|
||||
/* ata / spi commands */
|
||||
enum {
|
||||
GD_ATA_NOP = 0x00,
|
||||
GD_ATA_SOFT_RESET = 0x08,
|
||||
GD_ATA_EXEC_DIAG = 0x90,
|
||||
GD_ATA_PACKET_CMD = 0xa0,
|
||||
GD_ATA_IDENTIFY_DEV = 0xa1,
|
||||
GD_ATA_SET_FEATURES = 0xef,
|
||||
};
|
||||
|
||||
enum gd_audio_status {
|
||||
AST_INVALID = 0x00,
|
||||
AST_INPROGRESS = 0x11,
|
||||
AST_PAUSED = 0x12,
|
||||
AST_ENDED = 0x13,
|
||||
AST_ERROR = 0x14,
|
||||
AST_NOSTATUS = 0x15,
|
||||
enum {
|
||||
GD_SPI_TEST_UNIT = 0x00, /* Verify access readiness */
|
||||
GD_SPI_REQ_STAT = 0x10, /* Get CD status */
|
||||
GD_SPI_REQ_MODE = 0x11, /* Get various settings */
|
||||
GD_SPI_SET_MODE = 0x12, /* Make various settings */
|
||||
GD_SPI_REQ_ERROR = 0x13, /* Get error details */
|
||||
GD_SPI_GET_TOC = 0x14, /* Get all TOC data */
|
||||
GD_SPI_REQ_SES = 0x15, /* Get specified session data */
|
||||
GD_SPI_CD_OPEN = 0x16, /* Open tray */
|
||||
GD_SPI_CD_PLAY = 0x20, /* Play CD */
|
||||
GD_SPI_CD_SEEK = 0x21, /* Seek for playback position */
|
||||
GD_SPI_CD_SCAN = 0x22, /* Perform scan */
|
||||
GD_SPI_CD_READ = 0x30, /* Read CD */
|
||||
GD_SPI_CD_READ2 = 0x31, /* CD read (pre-read position) */
|
||||
GD_SPI_GET_SCD = 0x40, /* Get subcode */
|
||||
GD_SPI_CHK_SECU = 0x70, /* Perform disk security check */
|
||||
GD_SPI_REQ_SECU = 0x71, /* Get security check result */
|
||||
};
|
||||
|
||||
enum gd_secmask {
|
||||
MASK_OTHER = 0x1,
|
||||
MASK_DATA = 0x2,
|
||||
MASK_SUBHEADER = 0x4,
|
||||
MASK_HEADER = 0x8,
|
||||
enum {
|
||||
GD_SPI_CMD_SIZE = 12,
|
||||
GD_SPI_ERR_SIZE = 10,
|
||||
GD_SPI_TOC_SIZE = 408,
|
||||
GD_SPI_SES_SIZE = 6,
|
||||
GD_SPI_STAT_SIZE = 10,
|
||||
GD_SPI_SCD_SIZE = 100,
|
||||
};
|
||||
|
||||
enum gd_secfmt {
|
||||
SECTOR_ANY,
|
||||
SECTOR_CDDA,
|
||||
SECTOR_M1,
|
||||
SECTOR_M2,
|
||||
SECTOR_M2F1,
|
||||
SECTOR_M2F2,
|
||||
SECTOR_M2_NOXA,
|
||||
enum {
|
||||
GD_AREA_SINGLE,
|
||||
GD_AREA_HIGH,
|
||||
};
|
||||
|
||||
enum gd_seek_type {
|
||||
SEEK_FAD = 0x1,
|
||||
SEEK_MSF = 0x2,
|
||||
SEEK_STOP = 0x3,
|
||||
SEEK_PAUSE = 0x4,
|
||||
enum {
|
||||
GD_AUDIO_INVALID = 0x00,
|
||||
GD_AUDIO_INPROGRESS = 0x11,
|
||||
GD_AUDIO_PAUSED = 0x12,
|
||||
GD_AUDIO_ENDED = 0x13,
|
||||
GD_AUDIO_ERROR = 0x14,
|
||||
GD_AUDIO_NOSTATUS = 0x15,
|
||||
};
|
||||
|
||||
enum {
|
||||
GD_MASK_OTHER = 0x1,
|
||||
GD_MASK_DATA = 0x2,
|
||||
GD_MASK_SUBHEADER = 0x4,
|
||||
GD_MASK_HEADER = 0x8,
|
||||
};
|
||||
|
||||
enum {
|
||||
GD_SECTOR_ANY,
|
||||
GD_SECTOR_CDDA,
|
||||
GD_SECTOR_M1,
|
||||
GD_SECTOR_M2,
|
||||
GD_SECTOR_M2F1,
|
||||
GD_SECTOR_M2F2,
|
||||
GD_SECTOR_M2_NOXA,
|
||||
};
|
||||
|
||||
enum {
|
||||
GD_SEEK_FAD = 0x1,
|
||||
GD_SEEK_MSF = 0x2,
|
||||
GD_SEEK_STOP = 0x3,
|
||||
GD_SEEK_PAUSE = 0x4,
|
||||
};
|
||||
|
||||
/* internal registers accessed through holly */
|
||||
|
|
|
|||
Loading…
Reference in New Issue