bios.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023 Adrian "asie" Siekierka
 *
 * Licensed under the Apache License, Version 2.0 with LLVM Exceptions,
 * See https://github.com/llvm-mos/llvm-mos-sdk/blob/main/LICENSE for license
 * information.
 */
 
#ifndef _PCE_CD_BIOS_H_
#define _PCE_CD_BIOS_H_
 
#include "types.h"
#include <pce.h>
#include <stdbool.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum {
  PCE_CDB_SUCCESS = 0x00,
  PCE_CDB_NOT_READY = 0x04,
  PCE_CDB_NO_DISC = 0x0B,
  PCD_CDB_DRIVE_OPEN = 0x0D,
  PCE_CDB_READ_ERROR = 0x11,
  PCE_CDB_SEEK_ERROR = 0x15,
  PCE_CDB_HEADER_READ_ERROR = 0x16,
  PCE_CDB_NOT_AUDIO_TRACK = 0x1C,
  PCE_CDB_NOT_DATA_TRACK = 0x1D,
  PCE_CDB_INVALID_COMMAND = 0x20,
  PCE_CDB_INVALID_ADDRESS = 0x21,
  PCE_CDB_INVALID_PARAMETER = 0x22,
  PCE_CDB_END_OF_DISK = 0x25,
  PCE_CDB_INVALID_PARAMETER_LIST = 0x2A,
  PCE_CDB_NOT_PLAYING_AUDIO = 0x2C
} pce_cdb_error_code;
 
typedef enum {
  PCE_CDB_ADDRESS_BYTES = 0x00,
  PCE_CDB_ADDRESS = 0x01,
  PCE_CDB_BANK_MPR2 = 0x02,
  PCE_CDB_BANK_MPR3 = 0x03,
  PCE_CDB_BANK_MPR4 = 0x04,
  PCE_CDB_BANK_MPR5 = 0x05,
  PCE_CDB_BANK_MPR6 = 0x06,
  PCE_CDB_VRAM_BYTES = 0xFE,
  PCE_CDB_VRAM = 0xFF
} pce_cdb_address_type;
 
typedef enum {
  PCE_CDB_ID_IRQ_EXTERNAL = 0x00,
  PCE_CDB_ID_IRQ_VDC = 0x01,
  PCE_CDB_ID_IRQ_TIMER = 0x02,
  PCE_CDB_ID_NMI = 0x03,
  PCE_CDB_ID_HBLANK = 0x04,
  PCE_CDB_ID_VBLANK = 0x05,
  PCE_CDB_ID_SOFT_RESET = 0x06
} pcd_cdb_irq_vector;
 
typedef enum {
  PCE_CDB_MASK_IRQ_EXTERNAL = 0x01,
  PCE_CDB_MASK_IRQ_VDC = 0x02,
  PCE_CDB_MASK_IRQ_TIMER = 0x04,
  PCE_CDB_MASK_NMI = 0x08,
  PCE_CDB_MASK_HBLANK = 0x10,
  PCE_CDB_MASK_HBLANK_NO_BIOS = 0x20,
  PCE_CDB_MASK_VBLANK = 0x40,
  PCE_CDB_MASK_VBLANK_NO_BIOS = 0x80,
} pcd_cdb_irq_vector_mask;
 
bool pce_cdb_vram_in_use(void);
 
__attribute__((noreturn)) void pce_cdb_start(void);
 
uint8_t pce_cdb_cd_reset(void);
 
typedef enum {
  PCE_CDB_LOCATION_TYPE_SECTOR = 0x00,
  PCE_CDB_LOCATION_TYPE_TIME = 0x40,
  PCE_CDB_LOCATION_TYPE_TRACK = 0x80,
  PCE_CDB_LOCATION_TYPE_CURRENT = 0xC0,
  PCE_CDB_LOCATION_TYPE_UNTIL_END = 0xC0,
} pce_cdb_location_type;
 
typedef enum {
  PCE_CDB_BASE_SET_BOTH = 0,
  PCE_CDB_BASE_SET_FIRST = 1,
  PCE_CDB_BASE_SET_SECOND = 2,
  PCE_CDB_BASE_SET_NONE = 3
} pce_cdb_base_set_mode;
 
void pce_cdb_cd_base(pce_sector_t base, uint8_t mode);
 
uint8_t pce_cdb_cd_read(pce_sector_t sector, uint8_t address_type,
                        uint16_t address, uint16_t length);
 
void pce_cdb_cd_seek(pce_sector_t sector);
 
__attribute__((noreturn)) void pce_cdb_cd_exec(pce_sector_t sector,
                                               uint8_t address_type,
                                               uint16_t address,
                                               uint16_t length);
 
typedef enum {
  PCE_CDB_CDDA_PLAY_MUTE = 0,
  PCE_CDB_CDDA_PLAY_REPEAT = 1,
  PCE_CDB_CDDA_PLAY_ONE_SHOT = 2,
  PCE_CDB_CDDA_PLAY_NOT_BUSY = 3,
  PCE_CDB_CDDA_PLAY_PREVIOUS = 4,
} pce_cdb_cdda_play_mode;
 
uint8_t pce_cdb_cdda_play(uint8_t start_type, pce_sector_t start,
                          uint8_t end_type, pce_sector_t end, uint8_t mode);
 
typedef enum {
  PCE_CDB_CDDA_SEARCH_PAUSE_BLOCK = 0,
  PCE_CDB_CDDA_SEARCH_PAUSE_NONBLOCK = 1,
  PCE_CDB_CDDA_SEARCH_PLAY_BLOCK = 2,
  PCE_CDB_CDDA_SEARCH_PLAY_NONBLOCK = 3
} pce_cdb_cdda_search_mode;
 
uint8_t pce_cdb_cdda_search(pce_sector_t sector, uint8_t mode);
 
uint8_t pce_cdb_cdda_pause(void);
 
uint8_t pce_cdb_cd_busy(void);
 
uint8_t pce_cdb_cd_not_ready(void);
 
#define PCE_CDB_SUBQ_TYPE_2CH 0x0
#define PCE_CDB_SUBQ_TYPE_4CH 0x4
#define PCE_CDB_SUBQ_TYPE_DATA 0x8
#define PCE_CDB_SUBQ_TYPE_MASK 0xC
#define PCE_CDB_SUBQ_SCMS 0x2
#define PCE_CDB_SUBQ_PRE_EMPHASIS 0x1
 
typedef struct pce_cdb_subq_data {
  uint8_t status;  // playback status
  uint8_t control; // control/mode bits
  uint8_t track;
  uint8_t index;
  pce_sector_t track_time;
  pce_sector_t total_time;
} pce_cdb_subq_data_t;
 
uint8_t pce_cdb_cdda_read_subcode_q(pce_cdb_subq_data_t *buffer);
 
typedef struct pce_cdb_toc_data {
  union {
    struct {
      uint8_t track, track_end, __unused1;
    };
    struct {
      uint8_t minute, second, frame;
    };
    struct {
      uint8_t hi, md, lo;
    };
  };
  uint8_t control;
} pce_cdb_toc_data_t;
 
uint8_t pce_cdb_cd_read_toc_track_count(pce_cdb_toc_data_t *buffer);
uint8_t pce_cdb_cd_read_toc_lead_out_time(pce_cdb_toc_data_t *buffer);
uint8_t pce_cdb_cd_read_toc_track_time(pce_cdb_toc_data_t *buffer,
                                       uint8_t track_id);
uint8_t pce_cdb_cd_read_toc_track_sector(pce_cdb_toc_data_t *buffer,
                                         uint8_t track_id);
 
uint8_t pce_cdb_cd_scan(void);
 
typedef enum {
  PCE_CDB_SUBCODE_W = 0x01,
  PCE_CDB_SUBCODE_V = 0x02,
  PCE_CDB_SUBCODE_U = 0x04,
  PCE_CDB_SUBCODE_T = 0x08,
  PCE_CDB_SUBCODE_S = 0x10,
  PCE_CDB_SUBCODE_R = 0x20,
  PCE_CDB_SUBCODE_Q = 0x40,
  PCE_CDB_SUBCODE_P = 0x80
} pce_cdb_subcode;
 
bool pce_cdb_cd_read_subcode_bits(uint8_t *buffer);
 
uint16_t pce_cdb_cdda_read_sample(uint8_t channel);
 
typedef enum {
  PCE_CDB_FADER_NONE = 0x00,
  PCE_CDB_FADER_PCM_6_SEC = 0x08,
  PCE_CDB_FADER_ADPCM_6_SEC = 0x0A,
  PCE_CDB_FADER_PCM_2_5_SEC = 0x0C,
  PCE_CDB_FADER_ADPCM_2_5_SEC = 0x0E,
} pce_cdb_fader_mode;
 
void pce_cdb_fader(uint8_t mode);
 
void pce_cdb_adpcm_reset(void);
 
uint8_t pce_cdb_adpcm_read_from_cd(pce_sector_t sector, uint8_t length,
                                   uint16_t address);
 
uint8_t pce_cdb_adpcm_read_next_cd(pce_sector_t sector, uint8_t length);
 
uint8_t pce_cdb_adpcm_write_to_ram(uint16_t source, uint8_t dest_type,
                                   uint16_t dest, uint16_t length);
 
uint8_t pce_cdb_adpcm_read_from_ram(uint8_t source_type, uint16_t source,
                                    uint16_t dest, uint16_t length);
 
typedef enum {
  PCE_CDB_ADPCM_ONE_SHOT = 0x00,
  PCE_CDB_ADPCM_REPEAT = 0x80
} pce_cdb_adpcm_mode;
 
uint8_t pce_cdb_adpcm_play(uint16_t address, uint16_t length, uint8_t divider,
                           uint8_t mode);
 
uint8_t pce_cdb_adpcm_continue(uint8_t mode);
 
uint8_t pce_cdb_adpcm_stream(pce_sector_t sector, pce_sector_t length,
                             uint8_t divider);
 
void pce_cdb_adpcm_stop(void);
 
typedef enum {
  ADPCM_BUSY = 0x00FF,
  ADPCM_STOPPED = 0x0100,
  ADPCM_BUFFER_UNDER_HALF = 0x0400
} pce_cdb_adpcm_status_flags;
 
uint16_t pce_cdb_adpcm_status(void);
 
uint16_t pce_cdb_version(void);
 
void pce_cdb_irq_set(uint8_t type, void (*irq_handler)(void));
 
void pce_cdb_irq_enable(uint8_t mask);
 
void pce_cdb_irq_disable(uint8_t mask);
 
#define PCE_CDB_VDC_BG_WIDTH_32 (0)
#define PCE_CDB_VDC_BG_WIDTH_64 (1)
#define PCE_CDB_VDC_BG_WIDTH_128 (2)
#define PCE_CDB_VDC_BG_HEIGHT_32 (0 << 2)
#define PCE_CDB_VDC_BG_HEIGHT_64 (1 << 2)
#define PCE_CDB_VDC_BG_SIZE_32_32                                              \
  (PCE_CDB_VDC_BG_WIDTH_32 | PCE_CDB_VDC_BG_HEIGHT_32)
#define PCE_CDB_VDC_BG_SIZE_64_32                                              \
  (PCE_CDB_VDC_BG_WIDTH_64 | PCE_CDB_VDC_BG_HEIGHT_32)
#define PCE_CDB_VDC_BG_SIZE_128_32                                             \
  (PCE_CDB_VDC_BG_WIDTH_128 | PCE_CDB_VDC_BG_HEIGHT_32)
#define PCE_CDB_VDC_BG_SIZE_32_64                                              \
  (PCE_CDB_VDC_BG_WIDTH_32 | PCE_CDB_VDC_BG_HEIGHT_64)
#define PCE_CDB_VDC_BG_SIZE_64_64                                              \
  (PCE_CDB_VDC_BG_WIDTH_64 | PCE_CDB_VDC_BG_HEIGHT_64)
#define PCE_CDB_VDC_BG_SIZE_128_64                                             \
  (PCE_CDB_VDC_BG_WIDTH_128 | PCE_CDB_VDC_BG_HEIGHT_64)
 
void pce_cdb_vdc_bg_set_size(uint8_t size);
 
#define PCE_CDB_VDC_CLOCK_5MHZ 0
#define PCE_CDB_VDC_CLOCK_7MHZ 1
 
bool pce_cdb_vdc_set_resolution(uint8_t clock, uint8_t width_tiles,
                                uint8_t height_tiles);
 
#define PCE_CDB_VDC_COPY_1 0
#define PCE_CDB_VDC_COPY_32 1
#define PCE_CDB_VDC_COPY_64 2
#define PCE_CDB_VDC_COPY_128 3
 
void pce_cdb_vdc_set_copy(uint8_t mode);
 
void pce_cdb_vdc_set_bg_column_copy(void);
 
void pce_cdb_vdc_set_bg_row_copy(void);
 
void pce_cdb_wait_vblank(void);
 
void pce_cdb_vdc_irq_scanline_enable(void);
 
void pce_cdb_vdc_irq_scanline_disable(void);
 
void pce_cdb_vdc_irq_vblank_enable(void);
 
void pce_cdb_vdc_irq_vblank_disable(void);
 
void pce_cdb_vdc_bg_enable(void);
 
void pce_cdb_vdc_bg_disable(void);
 
void pce_cdb_vdc_sprite_enable(void);
 
void pce_cdb_vdc_sprite_disable(void);
 
void pce_cdb_vdc_bg_sprite_enable(void);
 
void pce_cdb_vdc_bg_sprite_disable(void);
 
#define PCE_CDB_SPR_INDEX ((volatile uint8_t *)0x2216)
#define PCE_CDB_SPRITE ((volatile vdc_sprite_t *)0x2217)
#define PCE_CDB_SPR_Y ((volatile uint16_t *)0x2217)
#define PCE_CDB_SPR_Y_LO ((volatile uint8_t *)0x2217)
#define PCE_CDB_SPR_Y_HI ((volatile uint8_t *)0x2218)
#define PCE_CDB_SPR_X ((volatile uint16_t *)0x2219)
#define PCE_CDB_SPR_X_LO ((volatile uint8_t *)0x2219)
#define PCE_CDB_SPR_X_HI ((volatile uint8_t *)0x221A)
#define PCE_CDB_SPR_PATTERN ((volatile uint16_t *)0x221B)
#define PCE_CDB_SPR_PATTERN_LO ((volatile uint8_t *)0x221B)
#define PCE_CDB_SPR_PATTERN_HI ((volatile uint8_t *)0x221C)
#define PCE_CDB_SPR_ATTR ((volatile uint16_t *)0x221D)
#define PCE_CDB_SPR_ATTR_LO ((volatile uint8_t *)0x221D)
#define PCE_CDB_SPR_ATTR_HI ((volatile uint8_t *)0x221E)
 
typedef enum {
  PCE_CDB_VRAM_DMA_IRQ_SATB_DONE = 0x01,
  PCE_CDB_VRAM_DMA_IRQ_DONE = 0x02,
  PCE_CDB_VRAM_DMA_SRC_INC = 0x00,
  PCE_CDB_VRAM_DMA_SRC_DEC = 0x04,
  PCE_CDB_VRAM_DMA_DEST_INC = 0x00,
  PCE_CDB_VRAM_DMA_DEST_DEC = 0x08,
  PCE_CDB_VRAM_DMA_REPEAT_SATB = 0x10
} pce_cdb_vdc_vram_dma_flags;
 
void pce_cdb_vdc_configure_dma(uint8_t value);
 
void pce_cdb_vdc_sprite_table_set_vram_addr(uint16_t address);
 
void pce_cdb_vdc_sprite_table_clear(void);
 
void pce_cdb_vdc_sprite_table_put(void);
 
void pce_cdb_vdc_irq_scanline_set(uint16_t line);
 
void pce_cdb_vdc_vram_read_at(uint16_t addr);
 
void pce_cdb_vdc_vram_write_at(uint16_t addr);
 
uint8_t pce_cdb_bin_to_bcd(uint8_t value);
 
uint8_t pce_cdb_bcd_to_bin(uint8_t value);
 
typedef struct pce_cdb_divmod_u16_result {
  uint16_t quot;
  uint16_t rem;
} pce_cdb_divmod_u16_result_t;
 
typedef struct pce_cdb_divmod_s16_result {
  int16_t quot;
  int16_t rem;
} pce_cdb_divmod_s16_result_t;
 
uint16_t pce_cdb_mul_u8(uint8_t a, uint8_t b);
 
int16_t pce_cdb_mul_s8(int8_t a, int8_t b);
 
uint32_t pce_cdb_mul_u16(uint16_t a, uint16_t b);
 
pce_cdb_divmod_u16_result_t pce_cdb_divmod_u16(uint16_t a, uint16_t b);
 
pce_cdb_divmod_s16_result_t pce_cdb_divmod_s16(int16_t a, int16_t b);
 
uint8_t pce_cdb_sqrt(uint16_t a);
 
bool pce_cdb_ram_query(uint8_t *bank_start, uint8_t *bank_size);
 
void pce_cdb_colors_bg_none(void);
 
void pce_cdb_colors_bg_at(void *address, uint8_t count);
 
void pce_cdb_colors_sprite_none(void);
 
void pce_cdb_colors_sprite_at(void *address, uint8_t count);
 
bool pce_cdb_colors_read(void);
 
bool pce_cdb_colors_set(void);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _PCE_CD_BIOS_H_ */