#include "card.h"
#include <placeholder.h>
#include <string.h>
#include "crypt.h"
#include <dolphin/card.h>
#include <dolphin/os.h>

Data Structures
struct	CardBlockHeader
	0x20-byte header at the start of every data block on the card. More...
struct	CardCmdBuf
	fn_803B1338 stages its commands in 0x28-byte stack slots. More...
struct	CardActiveRequest
	hsd_804D1138: the request the ring is currently completing. More...
struct	fn_803AF3F0_free_blk
struct	fn_803AF3F0_write_blk

Macros
#define	BANNER_SMALL 0xE00
#define	BANNER_LARGE 0x1800

Enumerations
enum	hsd_804D799C_t { running , running_async , idle }
	0 = running commands, 1 = async CARD call in flight, 2 = idle. More...

Functions
	ASSERT_SIZE (CardCmdBuf, 0x28)
	ASSERT_SIZE (CardActiveRequest, 0x10)
static int	fn_803AA790 (void)
static int	fn_803AC168 (const CardCmd *cmd)
	Copies the command into the ring; pointed-to state and buffers are not copied and must remain valid until execution completes.
static s32	fn_803AC258 (CardState *statestate, s32 block_idx)
static s32	fn_803AC2A4 (CardState *statestate)
static void	fn_803AC2D4 (void)
static void	fn_803AC2E0 (void)
static void	fn_803AC334 (void)
static void	fn_803AC3F8 (CardState statestate, u8 data, s32 file_idx)
static void	hsd_803AC558 (CardState statestate, u8 data)
static u32	fn_803AC634 (CardState *statestate, s32 file_idx)
static s32	fn_803AC6B8 (CardState *statestate, s32 file_idx)
static s32	fn_803AC7DC (CardState *)
static s32	fn_803ACBE8 (CardState *statestate, s32 block_idx)
static s32	fn_803ACC0C (CardState statestate, s32 block_idx, s32 block_id, s32 seq_num, void expected_data, s32 data_size)
static s32	fn_803ACD58 (CardState statestate, void banner, void *icons)
static s32	fn_803ACF30 (CardState statestate, void comment, void banner, void icons)
static s32	fn_803ACFC0 (CardState statestate, s32 block_idx, s32 block_id, s32 seq_num, void payload, s32 payload_size, s32 file_idx)
static s32	fn_803AD16C (CardState *statestate)
static int	fn_803ADE4C (CardState *statestate, int file_no, CardCallback callback)
static int	fn_803ADF90 (CardState statestate, s32 file_idx, u8 buf, int async, CardCallback callback)
static int	fn_803AE7F8 (CardState statestate, s32 file_idx, u8 buf, bool async, CardCallback callback)
static int	fn_803AF3F0 (CardState statestate, s32 file_idx, u8 buf, bool async, CardCallback callback)
static int	fn_803B0120 (CardState statestate, s32 file_idx, u8 buf, bool async, CardCallback callback)
static int	fn_803B0E9C (CardState statestate, void banner, u8 *icons, int is_new, int async)
static int	fn_803B1338 (CardState *statestate, int async)
static int	fn_803B1F78 (CardState statestate, const char filename, void banner, void icons, CardCallback callback)
static int	fn_803B21E8 (CardState statestate, void banner, void *icons, CardCallback callback)
static int	fn_803B26CC (CardState statestate, void comment, void banner, void icons, CardCallback callback)
static void	hsd_803A949C (s32 chan, s32 card_result)
static s32	fn_803ACB74 (s32 seq_a, s32 seq_b)
static int	checkOpen (CardState *statestate)
static s32	retryCardOpen (s32 chan, const char filename, CARDFileInfo file_info)
static s32	retryCardFastOpen (s32 chan, s32 file_no, CARDFileInfo *file_info)
static s32	retryCardReadAsync (CARDFileInfo file_info, void buffer, s32 length, s32 offset, CARDCallback callback)
static s32	retryCardWriteAsync (CARDFileInfo file_info, void buffer, s32 length, s32 offset, CARDCallback callback)
static s32	retryCardClose (CARDFileInfo *file_info)
static s32	retryCardCreateAsync (s32 chan, const char filename, s32 size, CARDFileInfo file_info, CARDCallback callback)
static s32	retryCardGetStatus (s32 chan, s32 file_no, CARDStat *stat)
static s32	retryCardSetStatusAsync (s32 chan, s32 file_no, CARDStat *stat, CARDCallback callback)
static int	setupCardIcons (const CardCmd *cmd)
static void	unpackCardStat (const CardCmd cmd, CARDStat stat)
static void	rollbackCardCommands (s32 snap)
static void	initHeaderBlockCommand (CardCmd buf, CardState statestate, u32 block, void comment, void banner, void *icons)
static s32	queueHeaderBlock (CardState statestate, u32 block, void comment, void banner, void icons)
static s32	queueHeaderBlocks (CardState statestate, void comment, void banner, void icons)
void	hsd_803AAA48 (void)
	Drives queued requests and commands until idle or waiting for CARD I/O.
int	hsd_803AC340 (CardIconInfo *icon_info)
void	hsd_803AC3E0 (CardState statestate, int file_idx, int file_size, int file_flags, u8 data)
static u32	fn_803AC6B8_first_block_count (CardState *statestate)
static s32	fn_803AC6B8_blocks_before (CardState *statestate, s32 file_idx)
static s32	fn_803AC7DC_block_count (CardState *statestate, s32 file_idx)
static u8 *	fn_803ACFC0_header (CardState *statestate, s32 hdr_offset)
static u8 *	fn_803ACFC0_checksum_start (s32 hdr_offset, CardState *statestate)
static s32	fn_803AD16C_total_blocks (CardState *statestate)
static s32	fn_803AD16C_logical_index (s32 blocks_before, s32 i)
static s32	fn_803AD16C_file_size (CardState *statestate, s32 file_idx)
static int	fn_803AD16C_nonnegative (s32 logical)
static void	fn_803AD16C_own (void *value)
static s32	fn_803AD16C_queue_clear (CardState *statestate, s32 phys, s32 offset, s32 file_idx)
static s32	fn_803AD16C_queue_read (CardState *statestate, s32 phys)
static s32	fn_803AD16C_queue_write (CardState *statestate, s32 phys, s32 block_id, s32 seq)
static s32	fn_803AD16C_queue_write_last (CardState *statestate, s32 phys, s32 block_id, s32 seq)
static s32	queueCardReadCommand (CardState statestate, s32 block, void data, s32 length, s32 offset)
static s32	calculateDataBlockSize (CardState *statestate, s32 file_idx, s32 block_idx)
static s32	calculateFileBlockCount (CardState *statestate, s32 file_idx)
static s32	retryCardRead (CARDFileInfo info, void buffer, s32 length, s32 offset)
static void	cancelQueuedCardCommands (void)
static s32	queueCardClearCommand (CardState statestate, u8 dst, s32 size)
static s32	queueClearDataBlock (CardState statestate, u8 dst, s32 size)
static s32	cardDataBlockOffset (const CardState *statestate, u32 sector_size, s32 data_block)
static int	queueReadDataBlock (CardState statestate, s32 block_idx, u8 dst, s32 size)
static s32	readCardDataBlockFirst (CardState statestate, u32 sector_size, s32 data_block, u8 dst, s32 length)
static s32	readCardDataBlockFinal (CardState statestate, u32 sector_size, s32 data_block, u8 dst, s32 length)
static void	fn_803AE7F8_rewind (void)
static void	fn_803AE7F8_close (CardState *statestate)
static s32	fn_803AF3F0_chunk_size (CardState *statestate)
static s32	fn_803AF3F0_queue_verify_first (CardState statestate, s32 phys, s32 block_id, s32 seq, void data, s32 size)
static s32	fn_803AF3F0_queue_verify_final (CardState statestate, s32 phys, s32 block_id, s32 seq, void data, s32 size)
static s32	fn_803AF3F0_queue_write_first (CardState statestate, s32 phys, s32 block_id, s32 seq, void data, s32 size, s32 file_idx)
static s32	fn_803AF3F0_queue_write_final (CardState statestate, s32 phys, s32 block_id, s32 seq, void data, s32 size, s32 file_idx)
static void	fn_803AF3F0_rewind (void)
static void	fn_803AF3F0_close (CardState *statestate)
static s32	fn_803AF3F0_open (s32 chan, s32 file_no, CARDFileInfo *info)
static void	fn_803AF3F0_check_seq (CardState statestate, const s32 primary, s32 count, s32 current_seq, s32 *needs_rewrite)
static void	fn_803AF3F0_calc_file_blocks (s32 file_idx, CardState statestate, s32 file_blocks, s32 *total_blocks)
static s32	fn_803B0120_first_chunk (CardState *statestate)
static void	fn_803B0120_rewind (void)
static void	fn_803B0120_close (CardState *statestate)
static s32	fn_803B0120_close_result (CardState *statestate)
static s32	fn_803B0120_block_offset (CardState *statestate, s32 block_idx)
static s32	fn_803B0120_queue_verify (CardState statestate, s32 phys, s32 block_id, s32 seq, void data, s32 size)
static s32	fn_803B0120_queue_write (CardState statestate, s32 phys, s32 block_id, s32 seq, void data, s32 size, s32 file_idx)
static s32	queueVerifyCardHeader (CardState statestate, CardCmd cmd, void banner, void icons)
static s32	fn_803B0E9C_write_block (CardState *statestate, s32 block_idx)
static s32	fn_803B0E9C_write_block_final (CardState *statestate, s32 block_idx)
static s32	fn_803B0E9C_read_first (CardState *statestate, u32 sector_size)
static s32	fn_803B1338_queue_write (CardState statestate, s32 phys, s32 block_id, void data, s32 size, s32 file_idx, CardCmdBuf init_buf, CardCmdBuf buf)
static u8 *	fn_803B1338_data_at (u8 *file_payload, s32 offset)
static s32	fn_803B1338_data_size (CardState *statestate)
static s32	fn_803B1338_queue_write_data (CardState statestate, s32 phys, s32 block_id, u8 fdata, s32 offset, s32 file_idx, CardCmdBuf init_buf, CardCmdBuf buf)
void	hsd_803B2374 (void)
void	hsd_803B24E4 (CardState statestate, int chan, int sector_size, void work_buf)
int	hsd_803B2550 (CardState statestate, const char filename, CardCallback callback)
int	hsd_803B2674 (CardState *statestate)
int	hsd_803B27F4 (CardState statestate, void comment, void banner, void icons, CardCallback callback)
	Queues a header read into the non-NULL destination buffers.
int	hsd_803B286C (CardState statestate, const char filename, const char comment, void banner, void *icons, CardCallback callback)
	Queues file creation.
int	hsd_803B2928 (CardState statestate, const char comment, void banner, void icons, CardCallback callback)
	Queues a header/status update.
int	hsd_803B29D8 (CardState statestate, int file_idx, u8 buf, CardCallback callback)
	Queues a logical-file read into the borrowed destination buffer.
int	hsd_803B2A4C (CardState statestate, int file_idx, u8 buf, CardCallback callback)
	Queues a logical-file write from the borrowed source buffer.
int	hsd_SetCardIconInfo (CardState statestate, CardIconInfo icon_info)

Variables
static volatile s32	curr_head
	Command ring head (next command to run).
static volatile s32	curr_tail
	Command ring tail (next free slot).
static volatile s32	curr_result
	Result of the request in progress: negative = CARD error, 1 = data verified so the queued writes are skipped, 2 = verify mismatch.
static s32	hsd_804D798C
static s32	hsd_804D7990
static s32	hsd_804D7994
static int	hsd_804D7998
	Ring tail saved before queueing a request; -1 when nothing to roll back.
static enum hsd_804D799C_t	hsd_804D799C
static CardActiveRequest	active_requests
static CardCmd	commands [128]
static CardRequest	requests [32]

u8	hsd_804D79C8
s32	hsd_804D79C4
s32	hsd_804D79C0
u8 *	hsd_804D79BC
u8 *	hsd_804D79B8
u8	hsd_804D79B0 [8]
s32	hsd_804D79AC
s32	hsd_804D79A8
u8 *	hsd_804D79A4
u8 *	hsd_804D79A0

Macro Definition Documentation

◆ BANNER_SMALL

#define BANNER_SMALL 0xE00

◆ BANNER_LARGE

#define BANNER_LARGE 0x1800

Enumeration Type Documentation

◆ hsd_804D799C_t

enum hsd_804D799C_t

0 = running commands, 1 = async CARD call in flight, 2 = idle.

Enumerator
running
running_async
idle

Function Documentation

◆ ASSERT_SIZE() [1/2]

ASSERT_SIZE	(	CardCmdBuf	,
		0x28	)

◆ ASSERT_SIZE() [2/2]

ASSERT_SIZE	(	CardActiveRequest	,
		0x10	)

◆ fn_803AA790()

int fn_803AA790 ( void )

static

◆ fn_803AC168()

int fn_803AC168 ( const CardCmd * cmd )

static

Copies the command into the ring; pointed-to state and buffers are not copied and must remain valid until execution completes.

Returns 0 when queued, or -265 when the ring is full.

◆ fn_803AC258()

s32 fn_803AC258	(	CardState *	state,
		s32	block_idx )

static

◆ fn_803AC2A4()

s32 fn_803AC2A4 ( CardState * state )

static

◆ fn_803AC2D4()

void fn_803AC2D4 ( void )

static

◆ fn_803AC2E0()

void fn_803AC2E0 ( void )

static

◆ fn_803AC334()

void fn_803AC334 ( void )

static

◆ fn_803AC3F8()

void fn_803AC3F8	(	CardState *	state,
		u8 *	data,
		s32	file_idx )

static

◆ hsd_803AC558()

void hsd_803AC558	(	CardState *	state,
		u8 *	data )

static

◆ fn_803AC634()

u32 fn_803AC634	(	CardState *	state,
		s32	file_idx )

static

◆ fn_803AC6B8()

s32 fn_803AC6B8	(	CardState *	state,
		s32	file_idx )

static

◆ fn_803AC7DC()

s32 fn_803AC7DC ( CardState * state )

static

◆ fn_803ACBE8()

s32 fn_803ACBE8	(	CardState *	state,
		s32	block_idx )

static

◆ fn_803ACC0C()

s32 fn_803ACC0C	(	CardState *	state,
		s32	block_idx,
		s32	block_id,
		s32	seq_num,
		void *	expected_data,
		s32	data_size )

static

◆ fn_803ACD58()

s32 fn_803ACD58	(	CardState *	state,
		void *	banner,
		void *	icons )

static

◆ fn_803ACF30()

s32 fn_803ACF30	(	CardState *	state,
		void *	comment,
		void *	banner,
		void *	icons )

static

◆ fn_803ACFC0()

s32 fn_803ACFC0	(	CardState *	state,
		s32	block_idx,
		s32	block_id,
		s32	seq_num,
		void *	payload,
		s32	payload_size,
		s32	file_idx )

static

◆ fn_803AD16C()

s32 fn_803AD16C ( CardState * state )

static

◆ fn_803ADE4C()

int fn_803ADE4C	(	CardState *	state,
		int	file_no,
		CardCallback	callback )

static

◆ fn_803ADF90()

int fn_803ADF90	(	CardState *	state,
		s32	file_idx,
		u8 *	buf,
		int	async,
		CardCallback	callback )

static

◆ fn_803AE7F8()

int fn_803AE7F8	(	CardState *	state,
		s32	file_idx,
		u8 *	buf,
		bool	async,
		CardCallback	callback )

static

◆ fn_803AF3F0()

int fn_803AF3F0	(	CardState *	state,
		s32	file_idx,
		u8 *	buf,
		bool	async,
		CardCallback	callback )

static

◆ fn_803B0120()

int fn_803B0120	(	CardState *	state,
		s32	file_idx,
		u8 *	buf,
		bool	async,
		CardCallback	callback )

static

◆ fn_803B0E9C()

int fn_803B0E9C	(	CardState *	state,
		void *	banner,
		u8 *	icons,
		int	is_new,
		int	async )

static

◆ fn_803B1338()

int fn_803B1338	(	CardState *	state,
		int	async )

static

◆ fn_803B1F78()

int fn_803B1F78	(	CardState *	state,
		const char *	filename,
		void *	banner,
		void *	icons,
		CardCallback	callback )

static

◆ fn_803B21E8()

int fn_803B21E8	(	CardState *	state,
		void *	banner,
		void *	icons,
		CardCallback	callback )

static

◆ fn_803B26CC()

int fn_803B26CC	(	CardState *	state,
		void *	comment,
		void *	banner,
		void *	icons,
		CardCallback	callback )

static

◆ hsd_803A949C()

void hsd_803A949C	(	s32	chan,
		s32	card_result )

static

◆ fn_803ACB74()

s32 fn_803ACB74	(	s32	seq_a,
		s32	seq_b )

inlinestatic

◆ checkOpen()

int checkOpen ( CardState * state )

static

◆ retryCardOpen()

s32 retryCardOpen	(	s32	chan,
		const char *	filename,
		CARDFileInfo *	file_info )

inlinestatic

◆ retryCardFastOpen()

s32 retryCardFastOpen	(	s32	chan,
		s32	file_no,
		CARDFileInfo *	file_info )

inlinestatic

◆ retryCardReadAsync()

s32 retryCardReadAsync	(	CARDFileInfo *	file_info,
		void *	buffer,
		s32	length,
		s32	offset,
		CARDCallback	callback )

inlinestatic

◆ retryCardWriteAsync()

s32 retryCardWriteAsync	(	CARDFileInfo *	file_info,
		void *	buffer,
		s32	length,
		s32	offset,
		CARDCallback	callback )

inlinestatic

◆ retryCardClose()

s32 retryCardClose ( CARDFileInfo * file_info )

inlinestatic

◆ retryCardCreateAsync()

s32 retryCardCreateAsync	(	s32	chan,
		const char *	filename,
		s32	size,
		CARDFileInfo *	file_info,
		CARDCallback	callback )

inlinestatic

◆ retryCardGetStatus()

s32 retryCardGetStatus	(	s32	chan,
		s32	file_no,
		CARDStat *	stat )

inlinestatic

◆ retryCardSetStatusAsync()

s32 retryCardSetStatusAsync	(	s32	chan,
		s32	file_no,
		CARDStat *	stat,
		CARDCallback	callback )

inlinestatic

◆ setupCardIcons()

int setupCardIcons ( const CardCmd * cmd )

inlinestatic

◆ unpackCardStat()

void unpackCardStat	(	const CardCmd *	cmd,
		CARDStat *	stat )

inlinestatic

◆ rollbackCardCommands()

void rollbackCardCommands ( s32 snap )

static

◆ initHeaderBlockCommand()

void initHeaderBlockCommand	(	CardCmd *	buf,
		CardState *	state,
		u32	block,
		void *	comment,
		void *	banner,
		void *	icons )

inlinestatic

◆ queueHeaderBlock()

s32 queueHeaderBlock	(	CardState *	state,
		u32	block,
		void *	comment,
		void *	banner,
		void *	icons )

inlinestatic

◆ queueHeaderBlocks()

s32 queueHeaderBlocks	(	CardState *	state,
		void *	comment,
		void *	banner,
		void *	icons )

inlinestatic

◆ hsd_803AAA48()

void hsd_803AAA48 ( void )

Drives queued requests and commands until idle or waiting for CARD I/O.

Async CARD calls start with interrupts disabled; the busy flag is set after the call returns, before interrupts are restored. CARD completion callbacks must therefore not run inline from those calls.

◆ hsd_803AC340()

int hsd_803AC340 ( CardIconInfo * icon_info )

◆ hsd_803AC3E0()

void hsd_803AC3E0	(	CardState *	state,
		int	file_idx,
		int	file_size,
		int	file_flags,
		u8 *	data )

◆ fn_803AC6B8_first_block_count()

u32 fn_803AC6B8_first_block_count ( CardState * state )

inlinestatic

◆ fn_803AC6B8_blocks_before()

s32 fn_803AC6B8_blocks_before	(	CardState *	state,
		s32	file_idx )

inlinestatic

◆ fn_803AC7DC_block_count()

s32 fn_803AC7DC_block_count	(	CardState *	state,
		s32	file_idx )

inlinestatic

◆ fn_803ACFC0_header()

u8 * fn_803ACFC0_header	(	CardState *	state,
		s32	hdr_offset )

inlinestatic

◆ fn_803ACFC0_checksum_start()

u8 * fn_803ACFC0_checksum_start	(	s32	hdr_offset,
		CardState *	state )

inlinestatic

◆ fn_803AD16C_total_blocks()

s32 fn_803AD16C_total_blocks ( CardState * state )

inlinestatic

◆ fn_803AD16C_logical_index()

s32 fn_803AD16C_logical_index	(	s32	blocks_before,
		s32	i )

inlinestatic

◆ fn_803AD16C_file_size()

s32 fn_803AD16C_file_size	(	CardState *	state,
		s32	file_idx )

inlinestatic

◆ fn_803AD16C_nonnegative()

int fn_803AD16C_nonnegative ( s32 logical )

inlinestatic

◆ fn_803AD16C_own()

void fn_803AD16C_own ( void * value )

inlinestatic

◆ fn_803AD16C_queue_clear()

s32 fn_803AD16C_queue_clear	(	CardState *	state,
		s32	phys,
		s32	offset,
		s32	file_idx )

inlinestatic

◆ fn_803AD16C_queue_read()

s32 fn_803AD16C_queue_read	(	CardState *	state,
		s32	phys )

inlinestatic

◆ fn_803AD16C_queue_write()

s32 fn_803AD16C_queue_write	(	CardState *	state,
		s32	phys,
		s32	block_id,
		s32	seq )

inlinestatic

◆ fn_803AD16C_queue_write_last()

s32 fn_803AD16C_queue_write_last	(	CardState *	state,
		s32	phys,
		s32	block_id,
		s32	seq )

inlinestatic

◆ queueCardReadCommand()

s32 queueCardReadCommand	(	CardState *	state,
		s32	block,
		void *	data,
		s32	length,
		s32	offset )

inlinestatic

◆ calculateDataBlockSize()

s32 calculateDataBlockSize	(	CardState *	state,
		s32	file_idx,
		s32	block_idx )

inlinestatic

◆ calculateFileBlockCount()

s32 calculateFileBlockCount	(	CardState *	state,
		s32	file_idx )

inlinestatic

◆ retryCardRead()

s32 retryCardRead	(	CARDFileInfo *	info,
		void *	buffer,
		s32	length,
		s32	offset )

inlinestatic

◆ cancelQueuedCardCommands()

void cancelQueuedCardCommands ( void )

inlinestatic

◆ queueCardClearCommand()

s32 queueCardClearCommand	(	CardState *	state,
		u8 *	dst,
		s32	size )

inlinestatic

◆ queueClearDataBlock()

s32 queueClearDataBlock	(	CardState *	state,
		u8 *	dst,
		s32	size )

inlinestatic

◆ cardDataBlockOffset()

s32 cardDataBlockOffset	(	const CardState *	state,
		u32	sector_size,
		s32	data_block )

inlinestatic

◆ queueReadDataBlock()

int queueReadDataBlock	(	CardState *	state,
		s32	block_idx,
		u8 *	dst,
		s32	size )

inlinestatic

◆ readCardDataBlockFirst()

s32 readCardDataBlockFirst	(	CardState *	state,
		u32	sector_size,
		s32	data_block,
		u8 *	dst,
		s32	length )

inlinestatic

◆ readCardDataBlockFinal()

s32 readCardDataBlockFinal	(	CardState *	state,
		u32	sector_size,
		s32	data_block,
		u8 *	dst,
		s32	length )

inlinestatic

◆ fn_803AE7F8_rewind()

void fn_803AE7F8_rewind ( void )

inlinestatic

◆ fn_803AE7F8_close()

void fn_803AE7F8_close ( CardState * state )

inlinestatic

◆ fn_803AF3F0_chunk_size()

s32 fn_803AF3F0_chunk_size ( CardState * state )

inlinestatic

◆ fn_803AF3F0_queue_verify_first()

s32 fn_803AF3F0_queue_verify_first	(	CardState *	state,
		s32	phys,
		s32	block_id,
		s32	seq,
		void *	data,
		s32	size )

inlinestatic

◆ fn_803AF3F0_queue_verify_final()

s32 fn_803AF3F0_queue_verify_final	(	CardState *	state,
		s32	phys,
		s32	block_id,
		s32	seq,
		void *	data,
		s32	size )

inlinestatic

◆ fn_803AF3F0_queue_write_first()

s32 fn_803AF3F0_queue_write_first	(	CardState *	state,
		s32	phys,
		s32	block_id,
		s32	seq,
		void *	data,
		s32	size,
		s32	file_idx )

inlinestatic

◆ fn_803AF3F0_queue_write_final()

s32 fn_803AF3F0_queue_write_final	(	CardState *	state,
		s32	phys,
		s32	block_id,
		s32	seq,
		void *	data,
		s32	size,
		s32	file_idx )

inlinestatic

◆ fn_803AF3F0_rewind()

void fn_803AF3F0_rewind ( void )

inlinestatic

◆ fn_803AF3F0_close()

void fn_803AF3F0_close ( CardState * state )

inlinestatic

◆ fn_803AF3F0_open()

s32 fn_803AF3F0_open	(	s32	chan,
		s32	file_no,
		CARDFileInfo *	info )

inlinestatic

◆ fn_803AF3F0_check_seq()

void fn_803AF3F0_check_seq	(	CardState *	state,
		const s32 *	primary,
		s32	count,
		s32	current_seq,
		s32 *	needs_rewrite )

inlinestatic

◆ fn_803AF3F0_calc_file_blocks()

void fn_803AF3F0_calc_file_blocks	(	s32	file_idx,
		CardState *	state,
		s32 *	file_blocks,
		s32 *	total_blocks )

inlinestatic

◆ fn_803B0120_first_chunk()

s32 fn_803B0120_first_chunk ( CardState * state )

inlinestatic

◆ fn_803B0120_rewind()

void fn_803B0120_rewind ( void )

inlinestatic

◆ fn_803B0120_close()

void fn_803B0120_close ( CardState * state )

inlinestatic

◆ fn_803B0120_close_result()

s32 fn_803B0120_close_result ( CardState * state )

inlinestatic

◆ fn_803B0120_block_offset()

s32 fn_803B0120_block_offset	(	CardState *	state,
		s32	block_idx )

inlinestatic

◆ fn_803B0120_queue_verify()

s32 fn_803B0120_queue_verify	(	CardState *	state,
		s32	phys,
		s32	block_id,
		s32	seq,
		void *	data,
		s32	size )

inlinestatic

◆ fn_803B0120_queue_write()

s32 fn_803B0120_queue_write	(	CardState *	state,
		s32	phys,
		s32	block_id,
		s32	seq,
		void *	data,
		s32	size,
		s32	file_idx )

inlinestatic

◆ queueVerifyCardHeader()

s32 queueVerifyCardHeader	(	CardState *	state,
		CardCmd *	cmd,
		void *	banner,
		void *	icons )

inlinestatic

◆ fn_803B0E9C_write_block()

s32 fn_803B0E9C_write_block	(	CardState *	state,
		s32	block_idx )

inlinestatic

◆ fn_803B0E9C_write_block_final()

s32 fn_803B0E9C_write_block_final	(	CardState *	state,
		s32	block_idx )

inlinestatic

◆ fn_803B0E9C_read_first()

s32 fn_803B0E9C_read_first	(	CardState *	state,
		u32	sector_size )

inlinestatic

◆ fn_803B1338_queue_write()

s32 fn_803B1338_queue_write	(	CardState *	state,
		s32	phys,
		s32	block_id,
		void *	data,
		s32	size,
		s32	file_idx,
		CardCmdBuf *	init_buf,
		CardCmdBuf *	buf )

inlinestatic

◆ fn_803B1338_data_at()

u8 * fn_803B1338_data_at	(	u8 *	file_payload,
		s32	offset )

inlinestatic

◆ fn_803B1338_data_size()

s32 fn_803B1338_data_size ( CardState * state )

inlinestatic

◆ fn_803B1338_queue_write_data()

s32 fn_803B1338_queue_write_data	(	CardState *	state,
		s32	phys,
		s32	block_id,
		u8 *	fdata,
		s32	offset,
		s32	file_idx,
		CardCmdBuf *	init_buf,
		CardCmdBuf *	buf )

inlinestatic

◆ hsd_803B2374()

void hsd_803B2374 ( void )

◆ hsd_803B24E4()

void hsd_803B24E4	(	CardState *	state,
		int	chan,
		int	sector_size,
		void *	work_buf )

◆ hsd_803B2550()

int hsd_803B2550	(	CardState *	state,
		const char *	filename,
		CardCallback	callback )

◆ hsd_803B2674()

int hsd_803B2674 ( CardState * state )

◆ hsd_803B27F4()

int hsd_803B27F4	(	CardState *	state,
		void *	comment,
		void *	banner,
		void *	icons,
		CardCallback	callback )

Queues a header read into the non-NULL destination buffers.

Returns 0 when queued, not when complete; a negative return does not queue a request or invoke the callback. The same return contract applies to the create, status, read and write request functions below.

◆ hsd_803B286C()

int hsd_803B286C	(	CardState *	state,
		const char *	filename,
		const char *	comment,
		void *	banner,
		void *	icons,
		CardCallback	callback )

Queues file creation.

Copies 0x40 bytes from comment into state even if the queue is full; filename, banner and icons are borrowed.

◆ hsd_803B2928()

int hsd_803B2928	(	CardState *	state,
		const char *	comment,
		void *	banner,
		void *	icons,
		CardCallback	callback )

Queues a header/status update.

Copies 0x40 bytes from comment into state even if the queue is full; banner and icons are borrowed.

◆ hsd_803B29D8()

int hsd_803B29D8	(	CardState *	state,
		int	file_idx,
		u8 *	buf,
		CardCallback	callback )

Queues a logical-file read into the borrowed destination buffer.

◆ hsd_803B2A4C()

int hsd_803B2A4C	(	CardState *	state,
		int	file_idx,
		u8 *	buf,
		CardCallback	callback )

Queues a logical-file write from the borrowed source buffer.

◆ hsd_SetCardIconInfo()

int hsd_SetCardIconInfo	(	CardState *	state,
		CardIconInfo *	icon_info )

Variable Documentation

◆ hsd_804D79C8

u8 hsd_804D79C8

Todo: these don't go here

◆ hsd_804D79C4

s32 hsd_804D79C4

◆ hsd_804D79C0

s32 hsd_804D79C0

◆ hsd_804D79BC

u8* hsd_804D79BC

◆ hsd_804D79B8

u8* hsd_804D79B8

◆ hsd_804D79B0

u8 hsd_804D79B0[8]

◆ hsd_804D79AC

s32 hsd_804D79AC

◆ hsd_804D79A8

s32 hsd_804D79A8

◆ hsd_804D79A4

u8* hsd_804D79A4

◆ hsd_804D79A0

u8* hsd_804D79A0

◆ curr_head

volatile s32 curr_head

static

Command ring head (next command to run).

◆ curr_tail

volatile s32 curr_tail

static

Command ring tail (next free slot).

◆ curr_result

volatile s32 curr_result

static

Result of the request in progress: negative = CARD error, 1 = data verified so the queued writes are skipped, 2 = verify mismatch.

◆ hsd_804D798C

s32 hsd_804D798C

static

◆ hsd_804D7990

s32 hsd_804D7990

static

◆ hsd_804D7994

s32 hsd_804D7994

static

◆ hsd_804D7998

int hsd_804D7998

static

Ring tail saved before queueing a request; -1 when nothing to roll back.

◆ hsd_804D799C

enum hsd_804D799C_t hsd_804D799C

static

◆ active_requests

CardActiveRequest active_requests

static

◆ commands

CardCmd commands[128]

static

◆ requests

CardRequest requests[32]

static

Data Structures

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ BANNER_SMALL

◆ BANNER_LARGE

Enumeration Type Documentation

◆ hsd_804D799C_t

Function Documentation

◆ ASSERT_SIZE() [1/2]

◆ ASSERT_SIZE() [2/2]

◆ fn_803AA790()

◆ fn_803AC168()

◆ fn_803AC258()

◆ fn_803AC2A4()

◆ fn_803AC2D4()

◆ fn_803AC2E0()

◆ fn_803AC334()

◆ fn_803AC3F8()

◆ hsd_803AC558()

◆ fn_803AC634()

◆ fn_803AC6B8()

◆ fn_803AC7DC()

◆ fn_803ACBE8()

◆ fn_803ACC0C()

◆ fn_803ACD58()

◆ fn_803ACF30()

◆ fn_803ACFC0()

◆ fn_803AD16C()

◆ fn_803ADE4C()

◆ fn_803ADF90()

◆ fn_803AE7F8()

◆ fn_803AF3F0()

◆ fn_803B0120()

◆ fn_803B0E9C()

◆ fn_803B1338()

◆ fn_803B1F78()

◆ fn_803B21E8()

◆ fn_803B26CC()

◆ hsd_803A949C()

◆ fn_803ACB74()

◆ checkOpen()

◆ retryCardOpen()

◆ retryCardFastOpen()

◆ retryCardReadAsync()

◆ retryCardWriteAsync()

◆ retryCardClose()

◆ retryCardCreateAsync()

◆ retryCardGetStatus()

◆ retryCardSetStatusAsync()

◆ setupCardIcons()

◆ unpackCardStat()

◆ rollbackCardCommands()

◆ initHeaderBlockCommand()

◆ queueHeaderBlock()

◆ queueHeaderBlocks()

◆ hsd_803AAA48()

◆ hsd_803AC340()

◆ hsd_803AC3E0()

◆ fn_803AC6B8_first_block_count()

◆ fn_803AC6B8_blocks_before()

◆ fn_803AC7DC_block_count()

◆ fn_803ACFC0_header()

◆ fn_803ACFC0_checksum_start()

◆ fn_803AD16C_total_blocks()

◆ fn_803AD16C_logical_index()

◆ fn_803AD16C_file_size()

◆ fn_803AD16C_nonnegative()

◆ fn_803AD16C_own()

◆ fn_803AD16C_queue_clear()

◆ fn_803AD16C_queue_read()

◆ fn_803AD16C_queue_write()

◆ fn_803AD16C_queue_write_last()

◆ queueCardReadCommand()

◆ calculateDataBlockSize()

◆ calculateFileBlockCount()

◆ retryCardRead()

◆ cancelQueuedCardCommands()