mirror of https://github.com/PCSX2/pcsx2.git
265 lines
9.6 KiB
C++
265 lines
9.6 KiB
C++
/* PCSX2 - PS2 Emulator for PCs
|
|
* Copyright (C) 2002-2014 David Quintana [gigaherz]
|
|
*
|
|
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
|
|
* of the GNU Lesser General Public License as published by the Free Software Found-
|
|
* ation, either version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with PCSX2.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
// The code has been designed for 64Mb flash and uses as file support the second memory card
|
|
#include <stdio.h>
|
|
#include <winsock2.h>
|
|
#include "DEV9.h"
|
|
|
|
#define PAGE_SIZE_BITS 9
|
|
#define PAGE_SIZE (1<<PAGE_SIZE_BITS)
|
|
#define ECC_SIZE (16)
|
|
#define PAGE_SIZE_ECC (PAGE_SIZE+ECC_SIZE)
|
|
#define BLOCK_SIZE (16 * PAGE_SIZE)
|
|
#define BLOCK_SIZE_ECC (16 * PAGE_SIZE_ECC)
|
|
#define CARD_SIZE (1024 * BLOCK_SIZE)
|
|
#define CARD_SIZE_ECC (1024 * BLOCK_SIZE_ECC)
|
|
|
|
|
|
static volatile u32 ctrl, cmd= (u32)-1, address, id, counter, addrbyte;
|
|
static u8 data[PAGE_SIZE_ECC], file[CARD_SIZE_ECC];
|
|
|
|
static void xfromman_call20_calculateXors(unsigned char buffer[128], unsigned char xor[4]);
|
|
|
|
static void calculateECC(u8 page[PAGE_SIZE_ECC]){
|
|
memset(page+PAGE_SIZE, 0x00, ECC_SIZE);
|
|
xfromman_call20_calculateXors(page + 0*(PAGE_SIZE>>2), page+PAGE_SIZE+0*3);//(ECC_SIZE>>2));
|
|
xfromman_call20_calculateXors(page + 1*(PAGE_SIZE>>2), page+PAGE_SIZE+1*3);//(ECC_SIZE>>2));
|
|
xfromman_call20_calculateXors(page + 2*(PAGE_SIZE>>2), page+PAGE_SIZE+2*3);//(ECC_SIZE>>2));
|
|
xfromman_call20_calculateXors(page + 3*(PAGE_SIZE>>2), page+PAGE_SIZE+3*3);//(ECC_SIZE>>2));
|
|
}
|
|
|
|
static char* getCmdName(u32 cmd){
|
|
switch(cmd) {
|
|
case SM_CMD_READ1: return "READ1";
|
|
case SM_CMD_READ2: return "READ2";
|
|
case SM_CMD_READ3: return "READ3";
|
|
case SM_CMD_RESET: return "RESET";
|
|
case SM_CMD_WRITEDATA: return "WRITEDATA";
|
|
case SM_CMD_PROGRAMPAGE: return "PROGRAMPAGE";
|
|
case SM_CMD_ERASEBLOCK: return "ERASEBLOCK";
|
|
case SM_CMD_ERASECONFIRM: return "ERASECONFIRM";
|
|
case SM_CMD_GETSTATUS: return "GETSTATUS";
|
|
case SM_CMD_READID: return "READID";
|
|
default: return "unknown";
|
|
}
|
|
}
|
|
|
|
void CALLBACK FLASHinit(){
|
|
FILE *fd;
|
|
|
|
id= FLASH_ID_64MBIT;
|
|
counter= 0;
|
|
addrbyte= 0;
|
|
|
|
address = 0;
|
|
memset(data, 0xFF, PAGE_SIZE);
|
|
calculateECC(data);
|
|
ctrl = FLASH_PP_READY;
|
|
|
|
if (fd=fopen("flash.dat", "rb")){
|
|
fread(file, 1, CARD_SIZE_ECC, fd);
|
|
fclose(fd);
|
|
}else
|
|
memset(file, 0xFF, CARD_SIZE_ECC);
|
|
}
|
|
|
|
u32 CALLBACK FLASHread32(u32 addr, int size) {
|
|
u32 value, refill= 0;
|
|
|
|
switch(addr) {
|
|
case FLASH_R_DATA:
|
|
memcpy(&value, &data[counter], size);
|
|
counter += size;
|
|
DEV9_LOG("*FLASH DATA %dbit read 0x%08lX %s\n", size*8, value, (ctrl & FLASH_PP_READ) ? "READ_ENABLE" : "READ_DISABLE");
|
|
if (cmd == SM_CMD_READ3){
|
|
if (counter >= PAGE_SIZE_ECC){
|
|
counter= PAGE_SIZE;
|
|
refill= 1;
|
|
}
|
|
}else{
|
|
if ( (ctrl & FLASH_PP_NOECC) && (counter >= PAGE_SIZE)){
|
|
counter %= PAGE_SIZE;
|
|
refill= 1;
|
|
}else
|
|
if (!(ctrl & FLASH_PP_NOECC) && (counter >= PAGE_SIZE_ECC)){
|
|
counter %= PAGE_SIZE_ECC;
|
|
refill= 1;
|
|
}
|
|
}
|
|
|
|
if (refill){
|
|
ctrl &= ~FLASH_PP_READY;
|
|
address += PAGE_SIZE;
|
|
address %= CARD_SIZE;
|
|
memcpy(data, file+(address>>PAGE_SIZE_BITS)*PAGE_SIZE_ECC, PAGE_SIZE);
|
|
calculateECC(data); // calculate ECC; should be in the file already
|
|
ctrl |= FLASH_PP_READY;
|
|
}
|
|
|
|
return value;
|
|
|
|
case FLASH_R_CMD:
|
|
DEV9_LOG("*FLASH CMD %dbit read %s DENIED\n", size*8, getCmdName(cmd));
|
|
return cmd;
|
|
|
|
case FLASH_R_ADDR:
|
|
DEV9_LOG("*FLASH ADDR %dbit read DENIED\n", size*8);
|
|
return 0;
|
|
|
|
case FLASH_R_CTRL:
|
|
DEV9_LOG("*FLASH CTRL %dbit read 0x%08lX\n", size*8, ctrl);
|
|
return ctrl;
|
|
|
|
case FLASH_R_ID:
|
|
if (cmd == SM_CMD_READID){
|
|
DEV9_LOG("*FLASH ID %dbit read 0x%08lX\n", size*8, id);
|
|
return id;//0x98=Toshiba/0xEC=Samsung maker code should be returned first
|
|
}else
|
|
if (cmd == SM_CMD_GETSTATUS){
|
|
value= 0x80 | ((ctrl & 1) << 6); // 0:0=pass, 6:ready/busy, 7:1=not protected
|
|
DEV9_LOG("*FLASH STATUS %dbit read 0x%08lX\n", size*8, value);
|
|
return value;
|
|
}//else fall off
|
|
|
|
default:
|
|
DEV9_LOG("*FLASH Unkwnown %dbit read at address %lx\n", size*8, addr);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void CALLBACK FLASHwrite32(u32 addr, u32 value, int size) {
|
|
|
|
switch(addr & 0x1FFFFFFF) {
|
|
case FLASH_R_DATA:
|
|
|
|
DEV9_LOG("*FLASH DATA %dbit write 0x%08lX %s\n", size*8, value, (ctrl & FLASH_PP_WRITE) ? "WRITE_ENABLE" : "WRITE_DISABLE");
|
|
memcpy(&data[counter], &value, size);
|
|
counter += size;
|
|
counter %= PAGE_SIZE_ECC;//should not get past the last byte, but at the end
|
|
break;
|
|
|
|
case FLASH_R_CMD:
|
|
if (!(ctrl & FLASH_PP_READY)){
|
|
if ((value != SM_CMD_GETSTATUS) && (value != SM_CMD_RESET)){
|
|
DEV9_LOG("*FLASH CMD %dbit write %s ILLEGAL in busy mode - IGNORED\n", size*8, getCmdName(value));
|
|
break;
|
|
}
|
|
}
|
|
if (cmd == SM_CMD_WRITEDATA){
|
|
if ((value != SM_CMD_PROGRAMPAGE) && (value != SM_CMD_RESET)){
|
|
DEV9_LOG("*FLASH CMD %dbit write %s ILLEGAL after WRITEDATA cmd - IGNORED\n", size*8, getCmdName(value));
|
|
ctrl &= ~FLASH_PP_READY;//go busy, reset is needed
|
|
break;
|
|
}
|
|
}
|
|
DEV9_LOG("*FLASH CMD %dbit write %s\n", size*8, getCmdName(value));
|
|
switch (value){ // A8 bit is encoded in READ cmd;)
|
|
case SM_CMD_READ1: counter= 0; if (cmd != SM_CMD_GETSTATUS) address= counter; addrbyte= 0; break;
|
|
case SM_CMD_READ2: counter= PAGE_SIZE/2; if (cmd != SM_CMD_GETSTATUS) address= counter; addrbyte= 0; break;
|
|
case SM_CMD_READ3: counter= PAGE_SIZE; if (cmd != SM_CMD_GETSTATUS) address= counter; addrbyte= 0; break;
|
|
case SM_CMD_RESET: FLASHinit(); break;
|
|
case SM_CMD_WRITEDATA: counter= 0; address= counter; addrbyte= 0; break;
|
|
case SM_CMD_ERASEBLOCK: counter= 0; memset(data, 0xFF, PAGE_SIZE); address= counter; addrbyte= 1; break;
|
|
case SM_CMD_PROGRAMPAGE: //fall
|
|
case SM_CMD_ERASECONFIRM:
|
|
ctrl &= ~FLASH_PP_READY;
|
|
calculateECC(data);
|
|
memcpy(file+(address/PAGE_SIZE)*PAGE_SIZE_ECC, data, PAGE_SIZE_ECC);
|
|
/*write2file*/
|
|
ctrl |= FLASH_PP_READY; break;
|
|
case SM_CMD_GETSTATUS: break;
|
|
case SM_CMD_READID: counter= 0; address= counter; addrbyte= 0; break;
|
|
default:
|
|
ctrl &= ~FLASH_PP_READY;
|
|
return;//ignore any other command; go busy, reset is needed
|
|
}
|
|
cmd= value;
|
|
break;
|
|
|
|
case FLASH_R_ADDR:
|
|
DEV9_LOG("*FLASH ADDR %dbit write 0x%08lX\n", size*8, value);
|
|
address |= (value & 0xFF) << (addrbyte == 0 ? 0 : (1 + 8 * addrbyte));
|
|
addrbyte++;
|
|
DEV9_LOG("*FLASH ADDR = 0x%08lX (addrbyte=%d)\n", address, addrbyte);
|
|
if (!(value & 0x100)){ // address is complete
|
|
if ((cmd == SM_CMD_READ1) || (cmd == SM_CMD_READ2) || (cmd == SM_CMD_READ3)) {
|
|
ctrl &= ~FLASH_PP_READY;
|
|
memcpy(data, file+(address>>PAGE_SIZE_BITS)*PAGE_SIZE_ECC, PAGE_SIZE);
|
|
calculateECC(data); // calculate ECC; should be in the file already
|
|
ctrl |= FLASH_PP_READY;
|
|
}
|
|
addrbyte= 0; // address reset
|
|
{
|
|
u32 bytes, pages, blocks;
|
|
|
|
blocks = address / BLOCK_SIZE;
|
|
pages = address-(blocks*BLOCK_SIZE);
|
|
bytes = pages % PAGE_SIZE;
|
|
pages = pages / PAGE_SIZE;
|
|
DEV9_LOG("*FLASH ADDR = 0x%08lX (%d:%d:%d) (addrbyte=%d) FINAL\n", address, blocks, pages, bytes, addrbyte);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FLASH_R_CTRL:
|
|
DEV9_LOG("*FLASH CTRL %dbit write 0x%08lX\n", size*8, value);
|
|
ctrl = (ctrl & FLASH_PP_READY) | (value & ~FLASH_PP_READY);
|
|
break;
|
|
|
|
case FLASH_R_ID:
|
|
DEV9_LOG("*FLASH ID %dbit write 0x%08lX DENIED :P\n", size*8, value);
|
|
break;
|
|
|
|
default:
|
|
DEV9_LOG("*FLASH Unkwnown %dbit write at address 0x%08lX= 0x%08lX IGNORED\n", size*8, addr, value);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static unsigned char xor_table[256]={
|
|
0x00, 0x87, 0x96, 0x11, 0xA5, 0x22, 0x33, 0xB4, 0xB4, 0x33, 0x22, 0xA5, 0x11, 0x96, 0x87, 0x00,
|
|
0xC3, 0x44, 0x55, 0xD2, 0x66, 0xE1, 0xF0, 0x77, 0x77, 0xF0, 0xE1, 0x66, 0xD2, 0x55, 0x44, 0xC3,
|
|
0xD2, 0x55, 0x44, 0xC3, 0x77, 0xF0, 0xE1, 0x66, 0x66, 0xE1, 0xF0, 0x77, 0xC3, 0x44, 0x55, 0xD2,
|
|
0x11, 0x96, 0x87, 0x00, 0xB4, 0x33, 0x22, 0xA5, 0xA5, 0x22, 0x33, 0xB4, 0x00, 0x87, 0x96, 0x11,
|
|
0xE1, 0x66, 0x77, 0xF0, 0x44, 0xC3, 0xD2, 0x55, 0x55, 0xD2, 0xC3, 0x44, 0xF0, 0x77, 0x66, 0xE1,
|
|
0x22, 0xA5, 0xB4, 0x33, 0x87, 0x00, 0x11, 0x96, 0x96, 0x11, 0x00, 0x87, 0x33, 0xB4, 0xA5, 0x22,
|
|
0x33, 0xB4, 0xA5, 0x22, 0x96, 0x11, 0x00, 0x87, 0x87, 0x00, 0x11, 0x96, 0x22, 0xA5, 0xB4, 0x33,
|
|
0xF0, 0x77, 0x66, 0xE1, 0x55, 0xD2, 0xC3, 0x44, 0x44, 0xC3, 0xD2, 0x55, 0xE1, 0x66, 0x77, 0xF0,
|
|
0xF0, 0x77, 0x66, 0xE1, 0x55, 0xD2, 0xC3, 0x44, 0x44, 0xC3, 0xD2, 0x55, 0xE1, 0x66, 0x77, 0xF0,
|
|
0x33, 0xB4, 0xA5, 0x22, 0x96, 0x11, 0x00, 0x87, 0x87, 0x00, 0x11, 0x96, 0x22, 0xA5, 0xB4, 0x33,
|
|
0x22, 0xA5, 0xB4, 0x33, 0x87, 0x00, 0x11, 0x96, 0x96, 0x11, 0x00, 0x87, 0x33, 0xB4, 0xA5, 0x22,
|
|
0xE1, 0x66, 0x77, 0xF0, 0x44, 0xC3, 0xD2, 0x55, 0x55, 0xD2, 0xC3, 0x44, 0xF0, 0x77, 0x66, 0xE1,
|
|
0x11, 0x96, 0x87, 0x00, 0xB4, 0x33, 0x22, 0xA5, 0xA5, 0x22, 0x33, 0xB4, 0x00, 0x87, 0x96, 0x11,
|
|
0xD2, 0x55, 0x44, 0xC3, 0x77, 0xF0, 0xE1, 0x66, 0x66, 0xE1, 0xF0, 0x77, 0xC3, 0x44, 0x55, 0xD2,
|
|
0xC3, 0x44, 0x55, 0xD2, 0x66, 0xE1, 0xF0, 0x77, 0x77, 0xF0, 0xE1, 0x66, 0xD2, 0x55, 0x44, 0xC3,
|
|
0x00, 0x87, 0x96, 0x11, 0xA5, 0x22, 0x33, 0xB4, 0xB4, 0x33, 0x22, 0xA5, 0x11, 0x96, 0x87, 0x00};
|
|
|
|
static void xfromman_call20_calculateXors(unsigned char buffer[128], unsigned char xor[4]){
|
|
register unsigned char a=0, b=0, c=0, i;
|
|
|
|
for (i=0; i<128; i++){
|
|
a ^= xor_table[buffer[i]];
|
|
if (xor_table[buffer[i]] & 0x80){
|
|
b ^= ~i;
|
|
c ^= i;
|
|
}
|
|
}
|
|
|
|
xor[0]=(~a) & 0x77;
|
|
xor[1]=(~b) & 0x7F;
|
|
xor[2]=(~c) & 0x7F;
|
|
}
|