EverDrive-64 X7: Difference between revisions
m
no edit summary
(Created page with "The EverDrive-64 X7 is a flash cart made by [https://krikzz.com/store/ Krikzz]. = Serial Communication = The EverDrive-64 X7 supports serial over...") |
mNo edit summary |
||
| (5 intermediate revisions by one other user not shown) | |||
Line 37:
|4
|}
The <code>REG_USB_CFG</code> register contains various bits as described below
{| class="wikitable"
|+REG_USB_CFG bits
!Name
!Description
!Bits (15-0)
!Hex Mask
|-
|USB_LE_CFG
|Set to a 1 when reading and writing data
|15
|0x8000
|-
|USB_LE_CTR
|Set to a 1 when reading and writing data
|14
|0x4000
|-
|USB_STA_BSY
|Behavior not known
|13
|0x2000
|-
|USB_STA_PWR
|Set to when 1 when data can be read or written
|12
|0x1000
|-
|USB_STA_TXE
|Set to 0 when data can be written
|11
|0x0800
|-
|USB_CFG_RD/USB_STA_RXF
|Writing a 1 switches the controller to read mode. Writing a 0 switches the controller to write mode.
Reads as a 0 when data is available to be read.
|10
|0x0400
|-
|USB_CFG_ACT/USB_STA_ACT
|Writing a 1 starts reading or writing to REG_USB_DATA. The direction of data is specified by the value of USB_CFG_RD. The amount of data written is specified by baddr.
When reading this bit, a 1 indicates the USB port is busy reading or writing data.
|9
|0x0200
|-
|baddr
|These 5 bits give the address into REG_USB_DAT where USB data is read from and written to. Data is read starting at <code>baddr</code> offset until the end of the REG_USB_DAT buffer. This means the amount of data read is <code>512 - baddr</code>. Because of this, when copying data to and from REG_USB_DAT, you don't always start copying at the beginning of the buffer.
|8..0
|0x01FF
|}
== Initializing EverDrive ==
Below is the code used to initialize the EverDrive to be used for USB IO from krikzz's reference code with comments
<syntaxhighlight lang="c">
/*************************************************************************
* Peripheral Interface (PI) Registers
*/
#define PI_BASE_REG 0x04600000
/* PI dom1 latency (R/W): [7:0] domain 1 device latency */
#define PI_BSD_DOM1_LAT_REG (PI_BASE_REG+0x14)
/* PI dom1 pulse width (R/W): [7:0] domain 1 device R/W strobe pulse width */
#define PI_BSD_DOM1_PWD_REG (PI_BASE_REG+0x18)
#define IO_WRITE(addr,data) (*(vu32 *)PHYS_TO_K1(addr)=(u32)(data))
void bi_init() {
// sets the PI manager latency
IO_WRITE(PI_BSD_DOM1_LAT_REG, 0x04);
// sets the PI manager pulse
IO_WRITE(PI_BSD_DOM1_PWD_REG, 0x0C);
// the specific value of 0xAA55 needs to be written here to enable USB IO
bi_reg_wr(REG_KEY, 0xAA55);
bi_reg_wr(REG_SYS_CFG, 0);
// this flushes serial buffer of any pending data
bi_usb_init();
// sets the save type. Not needed for USB IO
bi_set_save_type(SAVE_OFF);
}
</syntaxhighlight>
The example code sets latency and pulse for the values expected for USB communication. Different devices such as flash, sram, or cartridge would expect different values. You should change these to the appropriate values for the device before doing a DMA to that device. If you are using libultra there is a function designed to configure the PI manager for you before starting a DMA using <code>osEPiStartDma</code>. The first parameter of this function accepts a pointer to a <code>OSPiHandle</code> which contains the latency and pulse values that should be used by the PI manager.
== Sending Data to the Host ==
Below is the example code for sending data to the host PC in the function <code>bi_usb_wr</code>. Keep in mind that <code>src</code> should be aligned on 8 byte boundaries since it is used in a DMA transfer. For the same reason the length should be a multiple of 2.
<syntaxhighlight lang="c">
#define USB_LE_CFG 0x8000
#define USB_LE_CTR 0x4000
#define USB_CFG_ACT 0x0200
#define USB_CFG_RD 0x0400
#define USB_CFG_WR 0x0000
#define USB_STA_ACT 0x0200
#define USB_STA_RXF 0x0400
#define USB_STA_TXE 0x0800
#define USB_STA_PWR 0x1000
#define USB_STA_BSY 0x2000
#define USB_CMD_RD_NOP (USB_LE_CFG | USB_LE_CTR | USB_CFG_RD)
#define USB_CMD_RD (USB_LE_CFG | USB_LE_CTR | USB_CFG_RD | USB_CFG_ACT)
#define USB_CMD_WR_NOP (USB_LE_CFG | USB_LE_CTR | USB_CFG_WR)
#define USB_CMD_WR (USB_LE_CFG | USB_LE_CTR | USB_CFG_WR | USB_CFG_ACT)
#define REG_BASE 0x1F800000
#define KSEG1 0xA0000000
#define REG_ADDR(reg) (KSEG1 | REG_BASE | (reg))
u8 bi_usb_busy() {
u32 tout = 0;
// wait for the USB_STA_ACT bit to clear in REG_USB_CFG
// indicating the USB port is no longer busy
while ((bi_reg_rd(REG_USB_CFG) & USB_STA_ACT) != 0) {
// check to see if the operation has timed out
if (tout++ != 8192)continue;
// Turn off USB serial communication
bi_reg_wr(REG_USB_CFG, USB_CMD_RD_NOP);
return BI_ERR_USB_TOUT;
}
return 0;
}
u8 bi_usb_wr(void *src, u32 len) {
u8 resp = 0;
u16 blen, baddr;
// switch USB to write mode but don't start the transfer yet
bi_reg_wr(REG_USB_CFG, USB_CMD_WR_NOP);
while (len) {
// data can only be sent in chunks of 512 bytes
blen = 512;
if (blen > len)blen = len;
// calculate the offset into REG_USB_DAT from the length of data
baddr = 512 - blen;
// DMA the data from ram into the temporary buffer on the cartridge
// Note that sending less than 512 bytes will result it baddr being
// a positive value making the start of the DMA copy be somewhere
// in the middle of REG_USB_DAT instead of always starting at the
// beginning
sysPI_wr(src, REG_ADDR(REG_USB_DAT + baddr), blen);
src += 512;
// Start sending data from REG_USB_DAT over the usb starting at
// baddr and ending at the end of the 512 byte buffer.
bi_reg_wr(REG_USB_CFG, USB_CMD_WR | baddr);
// Wait for the data to finish sending over USB
resp = bi_usb_busy();
if (resp)break;
len -= blen;
}
return resp;
}
</syntaxhighlight>
== Reading Data from the Host ==
Below is an example of reading data from the host PC. Since <code>dst</code> is used in a DMA transfer it must be aligned to 8 bytes. For the same reason, len should be multiple of 2. The EverDrive-64 X7 also has the limitation that at least 16 bytes must be read. For this reason you should pad data sent to the EverDrive to a multiple of 16 bytes. You also must not read more data than what as been send from the host PC otherwise the read operation will time out while waiting for data that never comes. To solve this you can either prefix data sent to the EverDrive with a header indicating the amount of data being sent or you read data 16 bytes at a time calling <code>bi_usb_can_wr</code> each time to check if there is more data.
<syntaxhighlight lang="c">
// returns 1 if there is data waiting to be read
u8 bi_usb_can_wr() {
// check if USB_STA_PWR is 1 and USB_STA_TXE is 0 in REG_USB_CFG
u32 status = bi_reg_rd(REG_USB_CFG) & (USB_STA_PWR | USB_STA_TXE);
if (status == USB_STA_PWR)return 1;
return 0;
}
u8 bi_usb_rd(void *dst, u32 len) {
u8 resp = 0;
u16 blen, baddr;
while (len) {
// data cannot be read in chunks larger than 512 bytes
blen = 512;
if (blen > len)blen = len;
baddr = 512 - blen;
// tell the EverDrive to write data received from USB to
// to REG_USB_DAT starting at address baddr. It will continue
// to write data until the end of the 512 byte buffer. If
// there is not enough data to fill the buffer it will wait
// until that data is received
bi_reg_wr(REG_USB_CFG, USB_CMD_RD | baddr);
// wait for the serial data to be copied into REG_USB_DAT
// if there is not enough data to write to the end of the
// buffer this operation will time out
resp = bi_usb_busy();
if (resp)break;
// copy data from REG_USB_DAT into ram
sysPI_rd(dst, REG_ADDR(REG_USB_DAT + baddr), blen);
dst += blen;
len -= blen;
}
return resp;
}
</syntaxhighlight>
== Common Code ==
Code used for both reading and writing
<syntaxhighlight lang="c">
void sysPI_rd(void *ram, unsigned long pi_address, unsigned long len) {
pi_address &= 0x1FFFFFFF;
// invalidates the cache so the new values in ram after reading
// wont mismatch what is in the cache
// this is part of libdragon, for the libultra equivalent use osInvalDCache
data_cache_hit_writeback_invalidate(ram, len);
// the rest of the code is for a DMA transfer from the cartridge into RAM.
// use osEPiStartDma for libultra
disable_interrupts();
while (dma_busy());
IO_WRITE(PI_STATUS_REG, 3);
PI_regs->ram_address = ram;
PI_regs->pi_address = pi_address; //(pi_address | 0x10000000) & 0x1FFFFFFF;
PI_regs->write_length = len - 1;
while (dma_busy());
enable_interrupts();
}
void sysPI_wr(void *ram, unsigned long pi_address, unsigned long len) {
pi_address &= 0x1FFFFFFF;
// Writes the cache back to ram so the DMA gets the correct value
// this is part of libdragon, for the libultra equivalent use osWritebackDCache
data_cache_hit_writeback(ram, len);
// the rest of the code is for a DMA transfer from the RAM into the cartridge.
// use osEPiStartDma for libultra
disable_interrupts();
while (dma_busy());
IO_WRITE(PI_STATUS_REG, 3);
PI_regs->ram_address = ram;
PI_regs->pi_address = pi_address; //(pi_address | 0x10000000) & 0x1FFFFFFF;
PI_regs->read_length = len - 1;
while (dma_busy());
enable_interrupts();
}
// Writes a given value to the given register on the EverDrive
void bi_reg_wr(u16 reg, u32 val) {
sysPI_wr(&val, REG_ADDR(reg), 4);
}
// Reads the given register value
u32 bi_reg_rd(u16 reg) {
u32 val;
sysPI_rd(&val, REG_ADDR(reg), 4);
return val;
}
</syntaxhighlight>
[[Category:Flash Carts]]
| |||