pcsx2/plugins/dev9ghzdrk/flash.cpp

265 lines
9.6 KiB
C++
Raw Normal View History

/* 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;
}