Shamusworld >> Repos - virtualjaguar/blob - src/eeprom.cpp

   1 #include "eeprom.h"
   2
   3 #define eeprom_LOG
   4
   5 static uint16 eeprom_ram[64];
   6
   7 void eeprom_set_di(uint32 state);
   8 void eeprom_set_cs(uint32 state);
   9 uint32 eeprom_get_do(void);
  10
  11 #define EE_STATE_START                  1
  12 #define EE_STATE_OP_A                   2
  13 #define EE_STATE_OP_B                   3
  14 #define EE_STATE_0                              4
  15 #define EE_STATE_1                              5
  16 #define EE_STATE_2                              6
  17 #define EE_STATE_3                              7
  18 #define EE_STATE_0_0                    8
  19 #define EE_READ_ADDRESS                 9
  20 #define EE_STATE_0_0_0                  10
  21 #define EE_STATE_0_0_1                  11
  22 #define EE_STATE_0_0_2                  12
  23 #define EE_STATE_0_0_3                  13
  24 #define EE_STATE_0_0_1_0                14
  25 #define EE_READ_DATA                    15
  26 #define EE_STATE_BUSY                   16
  27 #define EE_STATE_1_0                    17
  28 #define EE_STATE_1_1                    18
  29 #define EE_STATE_2_0                    19
  30 #define EE_STATE_3_0                    20
  31
  32 uint16 jerry_ee_state = EE_STATE_START;
  33 uint16 jerry_ee_op = 0;
  34 uint16 jerry_ee_rstate = 0;
  35 uint16 jerry_ee_address_data = 0;
  36 uint16 jerry_ee_address_cnt = 6;
  37 uint16 jerry_ee_data = 0;
  38 uint16 jerry_ee_data_cnt = 16;
  39 uint16 jerry_writes_enabled = 0;
  40 uint16 jerry_ee_direct_jump = 0;
  41 FILE * jerry_ee_fp;
  42 extern char * jaguar_boot_dir;
  43
  44 //////////////////////////////////////////////////////////////////////////////
  45 //
  46 //////////////////////////////////////////////////////////////////////////////
  47 //
  48 //
  49 //
  50 //
  51 //
  52 //
  53 //////////////////////////////////////////////////////////////////////////////
  54 void eeprom_init(void)
  55 {
  56         static char eeprom_filename[256];
  57         sprintf(eeprom_filename,"%s\\%s%.8x.eep",jaguar_boot_dir,jaguar_eeproms_path,jaguar_mainRom_crc32);
  58         jerry_ee_fp=fopen(eeprom_filename,"rb");
  59         if (jerry_ee_fp)
  60         {
  61                 fread(eeprom_ram,1,128,jerry_ee_fp);
  62                 fclose(jerry_ee_fp);
  63                 fprintf(log_get(),"eeprom: loaded from %s\n",eeprom_filename);
  64                 jerry_ee_fp=fopen(eeprom_filename,"wrb");
  65         }
  66         else
  67         {
  68                 fprintf(log_get(),"eeprom: creating %s\n",eeprom_filename);
  69                 jerry_ee_fp=fopen(eeprom_filename,"wb");
  70                 if (jerry_ee_fp==NULL)
  71                         fprintf(log_get(),"eeprom: could not open/create %s\n",eeprom_filename);
  72         }
  73 }
  74 //////////////////////////////////////////////////////////////////////////////
  75 //
  76 //////////////////////////////////////////////////////////////////////////////
  77 //
  78 //
  79 //
  80 //
  81 //
  82 //
  83 //////////////////////////////////////////////////////////////////////////////
  84 void eeprom_reset(void)
  85 {
  86         if (jerry_ee_fp==NULL)
  87                 memset(eeprom_ram,0xff,64*2);
  88 }
  89 //////////////////////////////////////////////////////////////////////////////
  90 //
  91 //////////////////////////////////////////////////////////////////////////////
  92 //
  93 //
  94 //
  95 //
  96 //
  97 //
  98 //////////////////////////////////////////////////////////////////////////////
  99 void eeprom_done(void)
 100 {
 101         if (jerry_ee_fp)
 102         {
 103                 fwrite(eeprom_ram,1,128,jerry_ee_fp);
 104                 fclose(jerry_ee_fp);
 105         }
 106         else
 107                 fprintf(log_get(),"eeprom: not saved\n");
 108 }
 109 //////////////////////////////////////////////////////////////////////////////
 110 //
 111 //////////////////////////////////////////////////////////////////////////////
 112 //
 113 //
 114 //
 115 //
 116 //
 117 //
 118 //////////////////////////////////////////////////////////////////////////////
 119 void eeprom_byte_write(uint32 offset, uint8 data)
 120 {
 121         switch (offset)
 122         {
 123         case 0xf14001: break;
 124         case 0xf14801: eeprom_set_di(data&0x01); break;
 125         case 0xf15001: eeprom_set_cs(1); break;
 126 //      default: fprintf(log_get(),"eeprom: unmapped 0x%.8x\n",offset); break;
 127         }
 128 }
 129 //////////////////////////////////////////////////////////////////////////////
 130 //
 131 //////////////////////////////////////////////////////////////////////////////
 132 //
 133 //
 134 //
 135 //
 136 //
 137 //
 138 //////////////////////////////////////////////////////////////////////////////
 139 void eeprom_word_write(uint32 offset, uint16 data)
 140 {
 141         eeprom_byte_write(offset+0,(data>>8)&0xff);
 142         eeprom_byte_write(offset+1,(data&0xff));
 143 }
 144 //////////////////////////////////////////////////////////////////////////////
 145 //
 146 //////////////////////////////////////////////////////////////////////////////
 147 //
 148 //
 149 //
 150 //
 151 //
 152 //
 153 //////////////////////////////////////////////////////////////////////////////
 154 uint8 eeprom_byte_read(uint32 offset)
 155 {
 156         switch (offset)
 157         {
 158         case 0xf14001: return(eeprom_get_do());  break;
 159         case 0xf14801: break;
 160         case 0xf15001: eeprom_set_cs(1); break;
 161 //      default: fprintf(log_get(),"eeprom: unmapped 0x%.8x\n",offset); break;
 162         }
 163         return(0x00);
 164 }
 165 //////////////////////////////////////////////////////////////////////////////
 166 //
 167 //////////////////////////////////////////////////////////////////////////////
 168 //
 169 //
 170 //
 171 //
 172 //
 173 //
 174 //////////////////////////////////////////////////////////////////////////////
 175 uint16 eeprom_word_read(uint32 offset)
 176 {
 177         uint16 data=eeprom_byte_read(offset+0);
 178         data<<=8;
 179         data|=eeprom_byte_read(offset+1);
 180         return(data);
 181 }
 182 //////////////////////////////////////////////////////////////////////////////
 183 //
 184 //////////////////////////////////////////////////////////////////////////////
 185 //
 186 //
 187 //
 188 //
 189 //
 190 //
 191 //////////////////////////////////////////////////////////////////////////////
 192 void eeprom_set_di(uint32 data)
 193 {
 194 //      fprintf(log_get(),"eeprom: di=%i\n",data);
 195 //      fprintf(log_get(),"eeprom: state %i\n",jerry_ee_state);
 196         switch (jerry_ee_state)
 197         {
 198         case EE_STATE_START: {
 199                                                         jerry_ee_state=EE_STATE_OP_A;
 200                                                         break;
 201                                                  }
 202         case EE_STATE_OP_A:  {
 203                                                         jerry_ee_op=(data<<1);
 204                                                         jerry_ee_state=EE_STATE_OP_B;
 205                                                         break;
 206                                                  }
 207         case EE_STATE_OP_B:  {
 208                                                         jerry_ee_op|=data;
 209                                                         jerry_ee_direct_jump=0;
 210 //                                                      fprintf(log_get(),"eeprom: opcode %i\n",jerry_ee_op);
 211                                                         switch (jerry_ee_op)
 212                                                         {
 213                                                         case 0: jerry_ee_state=EE_STATE_0; break;
 214                                                         case 1: jerry_ee_state=EE_STATE_1; break;
 215                                                         case 2: jerry_ee_state=EE_STATE_2; break;
 216                                                         case 3: jerry_ee_state=EE_STATE_3; break;
 217                                                         }
 218                                                         eeprom_set_di(data);
 219                                                         break;
 220                                                  }
 221         case EE_STATE_0:        {
 222                                                         jerry_ee_rstate=EE_STATE_0_0;
 223                                                         jerry_ee_state=EE_READ_ADDRESS;
 224                                                         jerry_ee_direct_jump=1;
 225                                                         jerry_ee_address_cnt=6;
 226                                                         jerry_ee_address_data=0;
 227                                                         break;
 228                                                 }
 229         case EE_STATE_0_0:      {
 230                                                         switch ((jerry_ee_address_data>>4)&0x03)
 231                                                         {
 232                                                         case 0: jerry_ee_state=EE_STATE_0_0_0; break;
 233                                                         case 1: jerry_ee_state=EE_STATE_0_0_1; break;
 234                                                         case 2: jerry_ee_state=EE_STATE_0_0_2; break;
 235                                                         case 3: jerry_ee_state=EE_STATE_0_0_3; break;
 236                                                         }
 237                                                         eeprom_set_di(data);
 238                                                         break;
 239                                                 }
 240         case EE_STATE_0_0_0:{
 241                                                         // writes disable
 242                                                         // fprintf(log_get(),"eeprom: read only\n");
 243                                                         jerry_writes_enabled=0;
 244                                                         jerry_ee_state=EE_STATE_START;
 245                                                         break;
 246                                                 }
 247         case EE_STATE_0_0_1:{
 248                                                         // writes all
 249                                                         jerry_ee_rstate=EE_STATE_0_0_1_0;
 250                                                         jerry_ee_state=EE_READ_DATA;
 251                                                         jerry_ee_data_cnt=16;
 252                                                         jerry_ee_data=0;
 253                                                         jerry_ee_direct_jump=1;
 254                                                         break;
 255                                                 }
 256         case EE_STATE_0_0_1_0:{
 257                                                         // fprintf(log_get(),"eeprom: filling eeprom with 0x%.4x\n",data);
 258                                                         if (jerry_writes_enabled)
 259                                                         {
 260                                                                 for (int i=0;i<64;i++)
 261                                                                         eeprom_ram[i]=jerry_ee_data;
 262                                                         }
 263                                                         //else
 264                                                         //      fprintf(log_get(),"eeprom: not writing because read only\n");
 265                                                         jerry_ee_state=EE_STATE_BUSY;
 266                                                         break;
 267                                                   }
 268         case EE_STATE_0_0_2:{
 269                                                         // erase all
 270                                                         //fprintf(log_get(),"eeprom: erasing eeprom\n");
 271                                                         if (jerry_writes_enabled)
 272                                                         {
 273                                                                 for (int i=0;i<64;i++)
 274                                                                         eeprom_ram[i]=0xffff;
 275                                                         }
 276                                                         jerry_ee_state=EE_STATE_BUSY;
 277                                                         break;
 278                                                 }
 279         case EE_STATE_0_0_3:{
 280                                                         // writes enable
 281                                                         //fprintf(log_get(),"eeprom: read/write\n");
 282                                                         jerry_writes_enabled=1;
 283                                                         jerry_ee_state=EE_STATE_START;
 284                                                         break;
 285                                                 }
 286         case EE_STATE_1:        {
 287                                                         jerry_ee_rstate=EE_STATE_1_0;
 288                                                         jerry_ee_state=EE_READ_ADDRESS;
 289                                                         jerry_ee_address_cnt=6;
 290                                                         jerry_ee_address_data=0;
 291                                                         jerry_ee_direct_jump=1;
 292                                                         break;
 293                                                 }
 294         case EE_STATE_1_0:      {
 295                                                         jerry_ee_rstate=EE_STATE_1_1;
 296                                                         jerry_ee_state=EE_READ_DATA;
 297                                                         jerry_ee_data_cnt=16;
 298                                                         jerry_ee_data=0;
 299                                                         jerry_ee_direct_jump=1;
 300                                                         break;
 301                                                 }
 302         case EE_STATE_1_1:      {
 303                                                         //fprintf(log_get(),"eeprom: writing 0x%.4x at 0x%.2x\n",jerry_ee_data,jerry_ee_address_data);
 304                                                         if (jerry_writes_enabled)
 305                                                                 eeprom_ram[jerry_ee_address_data]=jerry_ee_data;
 306                                                         jerry_ee_state=EE_STATE_BUSY;
 307                                                         break;
 308                                                 }
 309         case EE_STATE_2:        {
 310                                                         jerry_ee_rstate=EE_STATE_2_0;
 311                                                         jerry_ee_state=EE_READ_ADDRESS;
 312                                                         jerry_ee_address_cnt=6;
 313                                                         jerry_ee_address_data=0;
 314                                                         jerry_ee_data_cnt=16;
 315                                                         jerry_ee_data=0;
 316                                                         break;
 317                                                 }
 318         case EE_STATE_3:        {
 319                                                         jerry_ee_rstate=EE_STATE_3_0;
 320                                                         jerry_ee_state=EE_READ_ADDRESS;
 321                                                         jerry_ee_address_cnt=6;
 322                                                         jerry_ee_address_data=0;
 323                                                         jerry_ee_direct_jump=1;
 324                                                         break;
 325                                                 }
 326         case EE_STATE_3_0:      {
 327                                                         //fprintf(log_get(),"eeprom: erasing 0x%.2x\n",jerry_ee_address_data);
 328                                                         if (jerry_writes_enabled)
 329                                                                 eeprom_ram[jerry_ee_address_data]=0xffff;
 330                                                         jerry_ee_state=EE_STATE_BUSY;
 331                                                         break;
 332                                                 }
 333         case EE_READ_DATA:
 334                                                 {
 335                                                         //fprintf(log_get(),"eeprom:\t\t\t%i bit %i\n",data,jerry_ee_data_cnt-1);
 336                                                         jerry_ee_data<<=1;
 337                                                         jerry_ee_data|=data;
 338                                                         jerry_ee_data_cnt--;
 339                                                         if (!jerry_ee_data_cnt)
 340                                                         {
 341                                                                 jerry_ee_state=jerry_ee_rstate;
 342                                                                 if (jerry_ee_direct_jump)
 343                                                                         eeprom_set_di(data);
 344                                                         }
 345                                                         break;
 346                                                 }
 347         case EE_READ_ADDRESS:
 348                                                 {
 349                                                         jerry_ee_address_data<<=1;
 350                                                         jerry_ee_address_data|=data;
 351                                                         jerry_ee_address_cnt--;
 352 //                                                      fprintf(log_get(),"eeprom:\t%i bits remaining\n",jerry_ee_address_cnt);
 353                                                         if (!jerry_ee_address_cnt)
 354                                                         {
 355                                                                 jerry_ee_state=jerry_ee_rstate;
 356                                                                 //fprintf(log_get(),"eeprom:\t\tread address 0x%.2x\n",jerry_ee_address_data);
 357                                                                 if (jerry_ee_direct_jump)
 358                                                                         eeprom_set_di(data);
 359                                                         }
 360                                                         break;
 361                                                 }
 362         default:                        {
 363                                                         jerry_ee_state=EE_STATE_OP_A;
 364                                                         break;
 365                                                  }
 366
 367         }
 368 }
 369 //////////////////////////////////////////////////////////////////////////////
 370 //
 371 //////////////////////////////////////////////////////////////////////////////
 372 //
 373 //
 374 //
 375 //
 376 //
 377 //
 378 //////////////////////////////////////////////////////////////////////////////
 379 void eeprom_set_cs(uint32 state)
 380 {
 381 //      fprintf(log_get(),"eeprom: cs=%i\n",state);
 382         jerry_ee_state=EE_STATE_START;
 383         jerry_ee_op=0;
 384         jerry_ee_rstate=0;
 385         jerry_ee_address_data=0;
 386         jerry_ee_address_cnt=6;
 387         jerry_ee_data=0;
 388         jerry_ee_data_cnt=16;
 389         jerry_writes_enabled=1;
 390 }
 391 //////////////////////////////////////////////////////////////////////////////
 392 //
 393 //////////////////////////////////////////////////////////////////////////////
 394 //
 395 //
 396 //
 397 //
 398 //
 399 //
 400 //////////////////////////////////////////////////////////////////////////////
 401 uint32 eeprom_get_do(void)
 402 {
 403         uint16 data=1;
 404         switch (jerry_ee_state)
 405         {
 406         case EE_STATE_START: {
 407                                                         data=1;
 408                                                         break;
 409                                                  }
 410         case EE_STATE_BUSY: {
 411                                                         jerry_ee_state=EE_STATE_START;
 412                                                         data=0;
 413                                                         break;
 414                                                  }
 415         case EE_STATE_2_0:      {
 416                                                         jerry_ee_data_cnt--;
 417                                                         data=((eeprom_ram[jerry_ee_address_data]&(1<<jerry_ee_data_cnt))>>jerry_ee_data_cnt);
 418                                                         if (!jerry_ee_data_cnt)
 419                                                         {
 420                                                                 //fprintf(log_get(),"eeprom: read 0x%.4x at 0x%.2x cpu %i pc=0x%.8x\n",eeprom_ram[jerry_ee_address_data],jerry_ee_address_data,jaguar_cpu_in_exec,s68000readPC());
 421                                                                 jerry_ee_state=EE_STATE_START;
 422                                                         }
 423                                                         break;
 424                                                 }
 425         }
 426 //      fprintf(log_get(),"eeprom: do=%i\n",data);
 427         return(data);
 428 }