VMU peripheral - Revision history

Tails86 at 00:31, 3 February 2025

2025-02-03T00:31:07Z

← Older revision		Revision as of 00:31, 3 February 2025
Line 39:		Line 39:
	== Screen ==		== Screen ==

	The "block write" command (0x0C) with screen function code and 48 data words is used to write monochrome images to the screen. A screen is 48 bits wide and 32 bits tall. For each bit in the 48 data words, a value of 1 means the pixel is on (black) and 0 means the pixel is off (white). Data is written from left to right and top to bottom (when holding the VMU in the upright orientation i.e. controller flipped upside down). The most significant bit of the first word sets the pixel on the top, left of the screen. The two most significant bytes write to the 33rd through 48th bit of the first row. The next two bytes write to the 1st through 16th bits of the second row. This is repeated for the rest of the 48 words like pictured below.		The "block write" command (0x0C) with screen function code and 48 data words is used to write monochrome images to the screen. The payload of this command should look like the following.
			{\| class="wikitable"
			\|-
			! Word 0 !! Word 1 !! Words 2..49
			\|-
			\| [[Maple_bus#Function_Codes\|Function code]] <br> 0x0000000C \|\| [[Maple_bus#Location_Word\|Location word]] <br> 0x00000000 \|\| Screen data
			\|}

			A screen is 48 bits wide and 32 bits tall. For each bit in the 48 data words, a value of 1 means the pixel is on (black) and 0 means the pixel is off (white). Data is written from left to right and top to bottom (when holding the VMU in the upright orientation i.e. controller flipped upside down). The most significant bit of the first word sets the pixel on the top, left of the screen. The two most significant bytes write to the 33rd through 48th bit of the first row. The next two bytes write to the 1st through 16th bits of the second row. This is repeated for the rest of the 48 words like pictured below.

	[[File:Dreamcast Screen Words.png\|Dreamcast Screen Words]]		[[File:Dreamcast Screen Words.png\|Dreamcast Screen Words]]

GyroVorbis at 15:27, 29 January 2025

2025-01-29T15:27:27Z

← Older revision		Revision as of 15:27, 29 January 2025
Line 7:		Line 7:
	The "block read" and "block write" commands (0x0B and 0x0C) with storage function code are used to read and write blocks of memory in the storage peripheral.		The "block read" and "block write" commands (0x0B and 0x0C) with storage function code are used to read and write blocks of memory in the storage peripheral.

	Normally, there are 256 blocks of memory that make up the entire storage space, and normally each block consists of 512 bytes. That makes a total of 128 KB of memory. These values are configurable according to the Maple Bus spec, but anything other than these values ~~are~~ not practically usable by most games due to ~~memory access~~ APIs.<ref>''[https://www.dreamcast-talk.com/forum/viewtopic.php?f=5&t=15562&p=171565] TapamN \| 400 block VMU on emulator''</ref>		Normally, there are 256 blocks of memory that make up the entire storage space, and normally each block consists of 512 bytes. That makes a total of 128 KB of memory. These values are configurable according to the Maple Bus spec, but anything other than these values is not practically usable by most games due to many high-level APIs and libraries within the SDKs not adhering properly to the Maple spec and making hardcoded assumptions about the volume information.<ref>''[https://www.dreamcast-talk.com/forum/viewtopic.php?f=5&t=15562&p=171565] TapamN \| 400 block VMU on emulator''</ref>

	=== Function Definition ===		=== Function Definition ===

Unknown user: /* Screen */

2023-03-11T02:47:49Z

Screen

← Older revision		Revision as of 02:47, 11 March 2023
Line 39:		Line 39:
	== Screen ==		== Screen ==

	The "block write" command (0x0C) with screen function code and 48 data words is used to write monochrome images to the screen. A screen is 48 bits wide and 32 bits tall. For each bit in the 48 data words, a value of 1 means the pixel is on (black) and 0 means the pixel is off (white). Data is written from left to right and top to bottom. The most significant bit of the first word sets the pixel on the top, left of the screen. The two most significant bytes write to the 33rd through 48th bit of the first row. The next two bytes write to the 1st through 16th bits of the second row. This is repeated for the rest of the 48 words like pictured below.		The "block write" command (0x0C) with screen function code and 48 data words is used to write monochrome images to the screen. A screen is 48 bits wide and 32 bits tall. For each bit in the 48 data words, a value of 1 means the pixel is on (black) and 0 means the pixel is off (white). Data is written from left to right and top to bottom (when holding the VMU in the upright orientation i.e. controller flipped upside down). The most significant bit of the first word sets the pixel on the top, left of the screen. The two most significant bytes write to the 33rd through 48th bit of the first row. The next two bytes write to the 1st through 16th bits of the second row. This is repeated for the rest of the 48 words like pictured below.

	[[File:Dreamcast Screen Words.png\|Dreamcast Screen Words]]		[[File:Dreamcast Screen Words.png\|Dreamcast Screen Words]]

Unknown user: Added "get media info" command

2023-01-15T01:54:42Z

Added "get media info" command

@@ Line 16: / Line 16: @@
 |-
 | bit 7: removable (1: true)<br>bit 6: CRC (1: needed)<br>bits 0-5: unused (0) || bits 4-7: number of write accesses per block<br>bits 0-3: number of read accesses per block || number of bytes per block<br>(x + 1)*32 bytes || number of partitions (x + 1)
 |}

Unknown user at 01:37, 5 January 2023

2023-01-05T01:37:47Z

← Older revision		Revision as of 01:37, 5 January 2023
Line 2:		Line 2:

	'''NOTE:''' Some information here is misleading and/or incomplete		'''NOTE:''' Some information here is misleading and/or incomplete

	~~== Screen ==~~

	The "block write" command (0x0C) with screen function code and 48 data words is used to write monochrome images to the screen. A screen is 48 bits wide and 32 bits tall. For each bit in the 48 data words, a value of 1 means the pixel is on (black) and 0 means the pixel is off (white). Data is written from left to right and top to bottom. The most significant bit of the first word sets the pixel on the top, left of the screen. The two most significant bytes write to the 33rd through 48th bit of the first row. The next two bytes write to the 1st through 16th bits of the second row. This is repeated for the rest of the 48 words like pictured below.

	~~[[File:Dreamcast Screen Words.png\|Dreamcast Screen Words]]~~

	== Storage ==		== Storage ==
Line 31:		Line 25:
	* A VMU cannot handle successive block write packets faster than about 10 ms per write		* A VMU cannot handle successive block write packets faster than about 10 ms per write
	** After such error, the storage functionality acts as if it never received this sequence and never returns a response packet - it may be possible to successfully resend this sequence, but writing a "get last error" command would be necessary before starting over at the first sequence		** After such error, the storage functionality acts as if it never received this sequence and never returns a response packet - it may be possible to successfully resend this sequence, but writing a "get last error" command would be necessary before starting over at the first sequence
			** The Dreamcast does each read/write sequence on the same cadence as controller polling (about every 16 ms)

			== Screen ==

			The "block write" command (0x0C) with screen function code and 48 data words is used to write monochrome images to the screen. A screen is 48 bits wide and 32 bits tall. For each bit in the 48 data words, a value of 1 means the pixel is on (black) and 0 means the pixel is off (white). Data is written from left to right and top to bottom. The most significant bit of the first word sets the pixel on the top, left of the screen. The two most significant bytes write to the 33rd through 48th bit of the first row. The next two bytes write to the 1st through 16th bits of the second row. This is repeated for the rest of the 48 words like pictured below.

			[[File:Dreamcast Screen Words.png\|Dreamcast Screen Words]]

	== Timer ==		== Timer ==

Unknown user: /* Function Definition */

2023-01-01T07:36:44Z

Function Definition

← Older revision		Revision as of 07:36, 1 January 2023
Line 21:		Line 21:
	! Byte 0 (LSB) !! Byte 1 !! Byte 2 !! Byte 3 (MSB)		! Byte 0 (LSB) !! Byte 1 !! Byte 2 !! Byte 3 (MSB)
	\|-		\|-
	\| bit 7: removable (1: true)<br>bit 6: CRC (1: needed)<br>bits 0-5: unused (0) \|\| bits 4-7: number of write accesses per block<br>bits 0-3: number of read accesses per block \|\| number of bytes per block<br>(x + 1)*32 bytes \|\| number of partitions		\| bit 7: removable (1: true)<br>bit 6: CRC (1: needed)<br>bits 0-5: unused (0) \|\| bits 4-7: number of write accesses per block<br>bits 0-3: number of read accesses per block \|\| number of bytes per block<br>(x + 1)*32 bytes \|\| number of partitions (x + 1)
	\|}		\|}

Unknown user: /* Block Write */

2023-01-01T06:52:45Z

Block Write

← Older revision		Revision as of 06:52, 1 January 2023
Line 29:		Line 29:
	=== Block Write ===		=== Block Write ===
	Execute a sequence of [[Maple_bus#Commands\|block writes]] to write data to storage. The number of sequences is dependent on the number of write accesses per block defined in the function definition above. On successful execution, a [[Maple_bus#Commands\|acknowledge]] packet will be returned. After the final write sequence, execute a [[Maple_bus#Commands\|get last error]] command with an incremented phase value to commit the block from RAM to storage.		Execute a sequence of [[Maple_bus#Commands\|block writes]] to write data to storage. The number of sequences is dependent on the number of write accesses per block defined in the function definition above. On successful execution, a [[Maple_bus#Commands\|acknowledge]] packet will be returned. After the final write sequence, execute a [[Maple_bus#Commands\|get last error]] command with an incremented phase value to commit the block from RAM to storage.
	* A VMU cannot handle successive block write packets faster than about 10 ms per write~~. If writing too fast, no response may be seen.~~		* A VMU cannot handle successive block write packets faster than about 10 ms per write
	** After such error, the storage functionality acts as if it never received this sequence - it may be possible to resend this sequence, but writing a "get last error" command would be necessary before starting over at the first sequence		** After such error, the storage functionality acts as if it never received this sequence and never returns a response packet - it may be possible to successfully resend this sequence, but writing a "get last error" command would be necessary before starting over at the first sequence

	== Timer ==		== Timer ==

Unknown user at 06:48, 1 January 2023

2023-01-01T06:48:50Z

← Older revision		Revision as of 06:48, 1 January 2023
Line 29:		Line 29:
	=== Block Write ===		=== Block Write ===
	Execute a sequence of [[Maple_bus#Commands\|block writes]] to write data to storage. The number of sequences is dependent on the number of write accesses per block defined in the function definition above. On successful execution, a [[Maple_bus#Commands\|acknowledge]] packet will be returned. After the final write sequence, execute a [[Maple_bus#Commands\|get last error]] command with an incremented phase value to commit the block from RAM to storage.		Execute a sequence of [[Maple_bus#Commands\|block writes]] to write data to storage. The number of sequences is dependent on the number of write accesses per block defined in the function definition above. On successful execution, a [[Maple_bus#Commands\|acknowledge]] packet will be returned. After the final write sequence, execute a [[Maple_bus#Commands\|get last error]] command with an incremented phase value to commit the block from RAM to storage.
	* If any block write fails, it is necessary to send "get last error" before starting over at the first write sequence.		* A VMU cannot handle successive block write packets faster than about 10 ms per write. If writing too fast, no response may be seen.
	* A VMU cannot handle successive block write packets faster than about 10 ms. If writing too fast, the ~~response of~~ "get last error" ~~will~~ be ~~"file error".~~		** After such error, the storage functionality acts as if it never received this sequence - it may be possible to resend this sequence, but writing a "get last error" command would be necessary before starting over at the first sequence

	== Timer ==		== Timer ==

Unknown user at 06:39, 1 January 2023

2023-01-01T06:39:38Z

← Older revision		Revision as of 06:39, 1 January 2023
Line 3:		Line 3:
	'''NOTE:''' Some information here is misleading and/or incomplete		'''NOTE:''' Some information here is misleading and/or incomplete

	=== Screen ===		== Screen ==

	The "block write" command (0x0C) with screen function code and 48 data words is used to write monochrome images to the screen. A screen is 48 bits wide and 32 bits tall. For each bit in the 48 data words, a value of 1 means the pixel is on (black) and 0 means the pixel is off (white). Data is written from left to right and top to bottom. The most significant bit of the first word sets the pixel on the top, left of the screen. The two most significant bytes write to the 33rd through 48th bit of the first row. The next two bytes write to the 1st through 16th bits of the second row. This is repeated for the rest of the 48 words like pictured below.		The "block write" command (0x0C) with screen function code and 48 data words is used to write monochrome images to the screen. A screen is 48 bits wide and 32 bits tall. For each bit in the 48 data words, a value of 1 means the pixel is on (black) and 0 means the pixel is off (white). Data is written from left to right and top to bottom. The most significant bit of the first word sets the pixel on the top, left of the screen. The two most significant bytes write to the 33rd through 48th bit of the first row. The next two bytes write to the 1st through 16th bits of the second row. This is repeated for the rest of the 48 words like pictured below.
Line 9:		Line 9:
	[[File:Dreamcast Screen Words.png\|Dreamcast Screen Words]]		[[File:Dreamcast Screen Words.png\|Dreamcast Screen Words]]

	=== Storage ===		== Storage ==

	The "block read" and "block write" commands (0x0B and 0x0C) with storage function code are used to read and write blocks of memory in the storage peripheral.		The "block read" and "block write" commands (0x0B and 0x0C) with storage function code are used to read and write blocks of memory in the storage peripheral.
Line 15:		Line 15:
	Normally, there are 256 blocks of memory that make up the entire storage space, and normally each block consists of 512 bytes. That makes a total of 128 KB of memory. These values are configurable according to the Maple Bus spec, but anything other than these values are not practically usable by most games due to memory access APIs.<ref>''[https://www.dreamcast-talk.com/forum/viewtopic.php?f=5&t=15562&p=171565] TapamN \| 400 block VMU on emulator''</ref>		Normally, there are 256 blocks of memory that make up the entire storage space, and normally each block consists of 512 bytes. That makes a total of 128 KB of memory. These values are configurable according to the Maple Bus spec, but anything other than these values are not practically usable by most games due to memory access APIs.<ref>''[https://www.dreamcast-talk.com/forum/viewtopic.php?f=5&t=15562&p=171565] TapamN \| 400 block VMU on emulator''</ref>

	==== Function Definition ====		=== Function Definition ===
	The function definition may be found in the peripheral's [[Maple_bus#Device_Info_Payload_Structure_.28cmd_0x05.29\|device info packet]]. It is necessary to read this word to know how to access blocks of memory on the storage.		The function definition may be found in the peripheral's [[Maple_bus#Device_Info_Payload_Structure_.28cmd_0x05.29\|device info packet]]. It is necessary to read this word to know how to access blocks of memory on the storage.
	{\| class="wikitable"		{\| class="wikitable"
Line 24:		Line 24:
	\|}		\|}

	==== Block Read ====		=== Block Read ===
	Execute a sequence of [[Maple_bus#Commands\|block reads]] to read data from storage. The number of sequences is dependent on the number of read accesses per block defined in the function definition above. On successful execution, a [[Maple_bus#Commands\|data transfer]] packet will be returned.		Execute a sequence of [[Maple_bus#Commands\|block reads]] to read data from storage. The number of sequences is dependent on the number of read accesses per block defined in the function definition above. On successful execution, a [[Maple_bus#Commands\|data transfer]] packet will be returned.

	==== Block Write ====		=== Block Write ===
	Execute a sequence of [[Maple_bus#Commands\|block writes]] to write data to storage. The number of sequences is dependent on the number of write accesses per block defined in the function definition above. On successful execution, a [[Maple_bus#Commands\|acknowledge]] packet will be returned. After the final write sequence, execute a [[Maple_bus#Commands\|get last error]] command with an incremented phase value to commit the block from RAM to storage.		Execute a sequence of [[Maple_bus#Commands\|block writes]] to write data to storage. The number of sequences is dependent on the number of write accesses per block defined in the function definition above. On successful execution, a [[Maple_bus#Commands\|acknowledge]] packet will be returned. After the final write sequence, execute a [[Maple_bus#Commands\|get last error]] command with an incremented phase value to commit the block from RAM to storage.
	* If any block write fails, it is necessary to send "get last error" before starting over at the first write sequence.		* If any block write fails, it is necessary to send "get last error" before starting over at the first write sequence.
	* A VMU cannot handle successive block write packets faster than about 10 ms. If writing too fast, the response of "get last error" will be "file error".		* A VMU cannot handle successive block write packets faster than about 10 ms. If writing too fast, the response of "get last error" will be "file error".

	=== Timer ===		== Timer ==

	The timer function allows the host to activate the buzzer on the VMU and get button conditions.		The timer function allows the host to activate the buzzer on the VMU and get button conditions.

Unknown user at 06:38, 1 January 2023

2023-01-01T06:38:20Z

← Older revision		Revision as of 06:38, 1 January 2023
Line 35:		Line 35:

	The timer function allows the host to activate the buzzer on the VMU and get button conditions.		The timer function allows the host to activate the buzzer on the VMU and get button conditions.

			== References ==
			<references />