libpcsxcore/sio.c

   1 /***************************************************************************
   2  *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team              *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
  18  ***************************************************************************/
  19
  20 /*
  21 * SIO functions.
  22 */
  23
  24 #include "sio.h"
  25 #include <sys/stat.h>
  26
  27 #ifdef USE_LIBRETRO_VFS
  28 #include <streams/file_stream_transforms.h>
  29 #endif
  30
  31 // Status Flags
  32 #define TX_RDY          0x0001
  33 #define RX_RDY          0x0002
  34 #define TX_EMPTY        0x0004
  35 #define PARITY_ERR      0x0008
  36 #define RX_OVERRUN      0x0010
  37 #define FRAMING_ERR     0x0020
  38 #define SYNC_DETECT     0x0040
  39 #define DSR                     0x0080
  40 #define CTS                     0x0100
  41 #define IRQ                     0x0200
  42
  43 // Control Flags
  44 #define TX_PERM         0x0001
  45 #define DTR                     0x0002
  46 #define RX_PERM         0x0004
  47 #define BREAK           0x0008
  48 #define RESET_ERR       0x0010
  49 #define RTS                     0x0020
  50 #define SIO_RESET       0x0040
  51
  52 // *** FOR WORKS ON PADS AND MEMORY CARDS *****
  53
  54 static unsigned char buf[256];
  55 static unsigned char cardh1[4] = { 0xff, 0x08, 0x5a, 0x5d };
  56 static unsigned char cardh2[4] = { 0xff, 0x08, 0x5a, 0x5d };
  57
  58 // Transfer Ready and the Buffer is Empty
  59 // static unsigned short StatReg = 0x002b;
  60 static unsigned short StatReg = TX_RDY | TX_EMPTY;
  61 static unsigned short ModeReg;
  62 static unsigned short CtrlReg;
  63 static unsigned short BaudReg;
  64
  65 static unsigned int bufcount;
  66 static unsigned int parp;
  67 static unsigned int mcdst, rdwr;
  68 static unsigned char adrH, adrL;
  69 static unsigned int padst;
  70
  71 char Mcd1Data[MCD_SIZE], Mcd2Data[MCD_SIZE];
  72 char McdDisable[2];
  73
  74 #define SIO_INT(eCycle) { \
  75         if (!Config.Sio) { \
  76                 psxRegs.interrupt |= (1 << PSXINT_SIO); \
  77                 psxRegs.intCycle[PSXINT_SIO].cycle = eCycle; \
  78                 psxRegs.intCycle[PSXINT_SIO].sCycle = psxRegs.cycle; \
  79                 new_dyna_set_event(PSXINT_SIO, eCycle); \
  80         } \
  81 }
  82
  83 // clk cycle byte
  84 // 4us * 8bits = (PSXCLK / 1000000) * 32; (linuzappz)
  85 // TODO: add SioModePrescaler and BaudReg
  86 #define SIO_CYCLES              535
  87
  88 void sioWrite8(unsigned char value) {
  89 #ifdef PAD_LOG
  90         PAD_LOG("sio write8 %x\n", value);
  91 #endif
  92         switch (padst) {
  93                 case 1: SIO_INT(SIO_CYCLES);
  94                         if ((value & 0x40) == 0x40) {
  95                                 padst = 2; parp = 1;
  96                                 if (!Config.UseNet) {
  97                                         switch (CtrlReg & 0x2002) {
  98                                                 case 0x0002:
  99                                                         buf[parp] = PAD1_poll(value);
 100                                                         break;
 101                                                 case 0x2002:
 102                                                         buf[parp] = PAD2_poll(value);
 103                                                         break;
 104                                         }
 105                                 }/* else {
 106 //                                      SysPrintf("%x: %x, %x, %x, %x\n", CtrlReg&0x2002, buf[2], buf[3], buf[4], buf[5]);
 107                                 }*/
 108
 109                                 if (!(buf[parp] & 0x0f)) {
 110                                         bufcount = 2 + 32;
 111                                 } else {
 112                                         bufcount = 2 + (buf[parp] & 0x0f) * 2;
 113                                 }
 114                                 if (buf[parp] == 0x41) {
 115                                         switch (value) {
 116                                                 case 0x43:
 117                                                         buf[1] = 0x43;
 118                                                         break;
 119                                                 case 0x45:
 120                                                         buf[1] = 0xf3;
 121                                                         break;
 122                                         }
 123                                 }
 124                                 // NegCon - Wipeout 3
 125                                 if( buf[parp] == 0x23 ) {
 126                                         switch (value) {
 127                                                 // enter config mode
 128                                                 case 0x43:
 129                                                         buf[1] = 0x79;
 130                                                         break;
 131
 132                                                 // get status
 133                                                 case 0x45:
 134                                                         buf[1] = 0xf3;
 135                                                         break;
 136                                         }
 137                                 }
 138                         }
 139                         else padst = 0;
 140                         return;
 141                 case 2:
 142                         parp++;
 143 /*                      if (buf[1] == 0x45) {
 144                                 buf[parp] = 0;
 145                                 SIO_INT(SIO_CYCLES);
 146                                 return;
 147                         }*/
 148                         if (!Config.UseNet) {
 149                                 switch (CtrlReg & 0x2002) {
 150                                         case 0x0002: buf[parp] = PAD1_poll(value); break;
 151                                         case 0x2002: buf[parp] = PAD2_poll(value); break;
 152                                 }
 153                         }
 154
 155                         if (parp == bufcount) { padst = 0; return; }
 156                         SIO_INT(SIO_CYCLES);
 157                         return;
 158         }
 159
 160         switch (mcdst) {
 161                 case 1:
 162                         SIO_INT(SIO_CYCLES);
 163                         if (rdwr) { parp++; return; }
 164                         parp = 1;
 165                         switch (value) {
 166                                 case 0x52: rdwr = 1; break;
 167                                 case 0x57: rdwr = 2; break;
 168                                 default: mcdst = 0;
 169                         }
 170                         return;
 171                 case 2: // address H
 172                         SIO_INT(SIO_CYCLES);
 173                         adrH = value;
 174                         *buf = 0;
 175                         parp = 0;
 176                         bufcount = 1;
 177                         mcdst = 3;
 178                         return;
 179                 case 3: // address L
 180                         SIO_INT(SIO_CYCLES);
 181                         adrL = value;
 182                         *buf = adrH;
 183                         parp = 0;
 184                         bufcount = 1;
 185                         mcdst = 4;
 186                         return;
 187                 case 4:
 188                         SIO_INT(SIO_CYCLES);
 189                         parp = 0;
 190                         switch (rdwr) {
 191                                 case 1: // read
 192                                         buf[0] = 0x5c;
 193                                         buf[1] = 0x5d;
 194                                         buf[2] = adrH;
 195                                         buf[3] = adrL;
 196                                         switch (CtrlReg & 0x2002) {
 197                                                 case 0x0002:
 198                                                         memcpy(&buf[4], Mcd1Data + (adrL | (adrH << 8)) * 128, 128);
 199                                                         break;
 200                                                 case 0x2002:
 201                                                         memcpy(&buf[4], Mcd2Data + (adrL | (adrH << 8)) * 128, 128);
 202                                                         break;
 203                                         }
 204                                         {
 205                                         char xor = 0;
 206                                         int i;
 207                                         for (i = 2; i < 128 + 4; i++)
 208                                                 xor ^= buf[i];
 209                                         buf[132] = xor;
 210                                         }
 211                                         buf[133] = 0x47;
 212                                         bufcount = 133;
 213                                         break;
 214                                 case 2: // write
 215                                         buf[0] = adrL;
 216                                         buf[1] = value;
 217                                         buf[129] = 0x5c;
 218                                         buf[130] = 0x5d;
 219                                         buf[131] = 0x47;
 220                                         bufcount = 131;
 221                                         break;
 222                         }
 223                         mcdst = 5;
 224                         return;
 225                 case 5:
 226                         parp++;
 227                         if ((rdwr == 1 && parp == 132) ||
 228                             (rdwr == 2 && parp == 129)) {
 229                                 // clear "new card" flags
 230                                 if (CtrlReg & 0x2000)
 231                                         cardh2[1] &= ~8;
 232                                 else
 233                                         cardh1[1] &= ~8;
 234                         }
 235                         if (rdwr == 2) {
 236                                 if (parp < 128) buf[parp + 1] = value;
 237                         }
 238                         SIO_INT(SIO_CYCLES);
 239                         return;
 240         }
 241
 242         switch (value) {
 243                 case 0x01: // start pad
 244                         StatReg |= RX_RDY;              // Transfer is Ready
 245
 246                         if (!Config.UseNet) {
 247                                 switch (CtrlReg & 0x2002) {
 248                                         case 0x0002: buf[0] = PAD1_startPoll(1); break;
 249                                         case 0x2002: buf[0] = PAD2_startPoll(2); break;
 250                                 }
 251                         } else {
 252                                 if ((CtrlReg & 0x2002) == 0x0002) {
 253                                         int i, j;
 254
 255                                         PAD1_startPoll(1);
 256                                         buf[0] = 0;
 257                                         buf[1] = PAD1_poll(0x42);
 258                                         if (!(buf[1] & 0x0f)) {
 259                                                 bufcount = 32;
 260                                         } else {
 261                                                 bufcount = (buf[1] & 0x0f) * 2;
 262                                         }
 263                                         buf[2] = PAD1_poll(0);
 264                                         i = 3;
 265                                         j = bufcount;
 266                                         while (j--) {
 267                                                 buf[i++] = PAD1_poll(0);
 268                                         }
 269                                         bufcount+= 3;
 270
 271                                         if (NET_sendPadData(buf, bufcount) == -1)
 272                                                 netError();
 273
 274                                         if (NET_recvPadData(buf, 1) == -1)
 275                                                 netError();
 276                                         if (NET_recvPadData(buf + 128, 2) == -1)
 277                                                 netError();
 278                                 } else {
 279                                         memcpy(buf, buf + 128, 32);
 280                                 }
 281                         }
 282
 283                         bufcount = 2;
 284                         parp = 0;
 285                         padst = 1;
 286                         SIO_INT(SIO_CYCLES);
 287                         return;
 288                 case 0x81: // start memcard
 289                         if (CtrlReg & 0x2000)
 290                         {
 291                                 if (McdDisable[1])
 292                                         goto no_device;
 293                                 memcpy(buf, cardh2, 4);
 294                         }
 295                         else
 296                         {
 297                                 if (McdDisable[0])
 298                                         goto no_device;
 299                                 memcpy(buf, cardh1, 4);
 300                         }
 301                         StatReg |= RX_RDY;
 302                         parp = 0;
 303                         bufcount = 3;
 304                         mcdst = 1;
 305                         rdwr = 0;
 306                         SIO_INT(SIO_CYCLES);
 307                         return;
 308                 default:
 309                 no_device:
 310                         StatReg |= RX_RDY;
 311                         buf[0] = 0xff;
 312                         parp = 0;
 313                         bufcount = 0;
 314                         return;
 315         }
 316 }
 317
 318 void sioWriteStat16(unsigned short value) {
 319 }
 320
 321 void sioWriteMode16(unsigned short value) {
 322         ModeReg = value;
 323 }
 324
 325 void sioWriteCtrl16(unsigned short value) {
 326         CtrlReg = value & ~RESET_ERR;
 327         if (value & RESET_ERR) StatReg &= ~IRQ;
 328         if ((CtrlReg & SIO_RESET) || !(CtrlReg & DTR)) {
 329                 padst = 0; mcdst = 0; parp = 0;
 330                 StatReg = TX_RDY | TX_EMPTY;
 331                 psxRegs.interrupt &= ~(1 << PSXINT_SIO);
 332         }
 333 }
 334
 335 void sioWriteBaud16(unsigned short value) {
 336         BaudReg = value;
 337 }
 338
 339 unsigned char sioRead8() {
 340         unsigned char ret = 0;
 341
 342         if ((StatReg & RX_RDY)/* && (CtrlReg & RX_PERM)*/) {
 343 //              StatReg &= ~RX_OVERRUN;
 344                 ret = buf[parp];
 345                 if (parp == bufcount) {
 346                         StatReg &= ~RX_RDY;             // Receive is not Ready now
 347                         if (mcdst == 5) {
 348                                 mcdst = 0;
 349                                 if (rdwr == 2) {
 350                                         switch (CtrlReg & 0x2002) {
 351                                                 case 0x0002:
 352                                                         memcpy(Mcd1Data + (adrL | (adrH << 8)) * 128, &buf[1], 128);
 353                                                         SaveMcd(Config.Mcd1, Mcd1Data, (adrL | (adrH << 8)) * 128, 128);
 354                                                         break;
 355                                                 case 0x2002:
 356                                                         memcpy(Mcd2Data + (adrL | (adrH << 8)) * 128, &buf[1], 128);
 357                                                         SaveMcd(Config.Mcd2, Mcd2Data, (adrL | (adrH << 8)) * 128, 128);
 358                                                         break;
 359                                         }
 360                                 }
 361                         }
 362                         if (padst == 2) padst = 0;
 363                         if (mcdst == 1) {
 364                                 mcdst = 2;
 365                                 StatReg|= RX_RDY;
 366                         }
 367                 }
 368         }
 369
 370 #ifdef PAD_LOG
 371         PAD_LOG("sio read8 ;ret = %x\n", ret);
 372 #endif
 373         return ret;
 374 }
 375
 376 unsigned short sioReadStat16() {
 377         return StatReg;
 378 }
 379
 380 unsigned short sioReadMode16() {
 381         return ModeReg;
 382 }
 383
 384 unsigned short sioReadCtrl16() {
 385         return CtrlReg;
 386 }
 387
 388 unsigned short sioReadBaud16() {
 389         return BaudReg;
 390 }
 391
 392 void netError() {
 393         ClosePlugins();
 394         SysMessage(_("Connection closed!\n"));
 395
 396         CdromId[0] = '\0';
 397         CdromLabel[0] = '\0';
 398
 399         SysRunGui();
 400 }
 401
 402 void sioInterrupt() {
 403 #ifdef PAD_LOG
 404         PAD_LOG("Sio Interrupt (CP0.Status = %x)\n", psxRegs.CP0.n.Status);
 405 #endif
 406 //      SysPrintf("Sio Interrupt\n");
 407         if (!(StatReg & IRQ)) {
 408                 StatReg |= IRQ;
 409                 psxHu32ref(0x1070) |= SWAPu32(0x80);
 410         }
 411 }
 412
 413 void LoadMcd(int mcd, char *str) {
 414         FILE *f;
 415         char *data = NULL;
 416
 417         if (mcd != 1 && mcd != 2)
 418                 return;
 419
 420         if (mcd == 1) {
 421                 data = Mcd1Data;
 422                 cardh1[1] |= 8; // mark as new
 423         }
 424         if (mcd == 2) {
 425                 data = Mcd2Data;
 426                 cardh2[1] |= 8;
 427         }
 428
 429         McdDisable[mcd - 1] = 0;
 430 #ifdef HAVE_LIBRETRO
 431         // memcard1 is handled by libretro
 432         if (mcd == 1)
 433                 return;
 434 #endif
 435
 436         if (str == NULL || strcmp(str, "none") == 0) {
 437                 McdDisable[mcd - 1] = 1;
 438                 return;
 439         }
 440         if (*str == 0)
 441                 return;
 442
 443         f = fopen(str, "rb");
 444         if (f == NULL) {
 445                 SysPrintf(_("The memory card %s doesn't exist - creating it\n"), str);
 446                 CreateMcd(str);
 447                 f = fopen(str, "rb");
 448                 if (f != NULL) {
 449                         struct stat buf;
 450
 451                         if (stat(str, &buf) != -1) {
 452                                 if (buf.st_size == MCD_SIZE + 64)
 453                                         fseek(f, 64, SEEK_SET);
 454                                 else if(buf.st_size == MCD_SIZE + 3904)
 455                                         fseek(f, 3904, SEEK_SET);
 456                         }
 457                         if (fread(data, 1, MCD_SIZE, f) != MCD_SIZE) {
 458 #ifndef NDEBUG
 459                                 SysPrintf(_("File IO error in <%s:%s>.\n"), __FILE__, __func__);
 460 #endif
 461                                 memset(data, 0x00, MCD_SIZE);
 462                         }
 463                         fclose(f);
 464                 }
 465                 else
 466                         SysMessage(_("Memory card %s failed to load!\n"), str);
 467         }
 468         else {
 469                 struct stat buf;
 470                 SysPrintf(_("Loading memory card %s\n"), str);
 471                 if (stat(str, &buf) != -1) {
 472                         if (buf.st_size == MCD_SIZE + 64)
 473                                 fseek(f, 64, SEEK_SET);
 474                         else if(buf.st_size == MCD_SIZE + 3904)
 475                                 fseek(f, 3904, SEEK_SET);
 476                 }
 477                 if (fread(data, 1, MCD_SIZE, f) != MCD_SIZE) {
 478 #ifndef NDEBUG
 479                         SysPrintf(_("File IO error in <%s:%s>.\n"), __FILE__, __func__);
 480 #endif
 481                         memset(data, 0x00, MCD_SIZE);
 482                 }
 483                 fclose(f);
 484         }
 485 }
 486
 487 void LoadMcds(char *mcd1, char *mcd2) {
 488         LoadMcd(1, mcd1);
 489         LoadMcd(2, mcd2);
 490 }
 491
 492 void SaveMcd(char *mcd, char *data, uint32_t adr, int size) {
 493         FILE *f;
 494
 495         if (mcd == NULL || *mcd == 0 || strcmp(mcd, "none") == 0)
 496                 return;
 497
 498         f = fopen(mcd, "r+b");
 499         if (f != NULL) {
 500                 struct stat buf;
 501
 502                 if (stat(mcd, &buf) != -1) {
 503                         if (buf.st_size == MCD_SIZE + 64)
 504                                 fseek(f, adr + 64, SEEK_SET);
 505                         else if (buf.st_size == MCD_SIZE + 3904)
 506                                 fseek(f, adr + 3904, SEEK_SET);
 507                         else
 508                                 fseek(f, adr, SEEK_SET);
 509                 } else
 510                         fseek(f, adr, SEEK_SET);
 511
 512                 fwrite(data + adr, 1, size, f);
 513                 fclose(f);
 514                 return;
 515         }
 516
 517 #if 0
 518         // try to create it again if we can't open it
 519         f = fopen(mcd, "wb");
 520         if (f != NULL) {
 521                 fwrite(data, 1, MCD_SIZE, f);
 522                 fclose(f);
 523         }
 524 #endif
 525
 526         ConvertMcd(mcd, data);
 527 }
 528
 529 void CreateMcd(char *mcd) {
 530         FILE *f;
 531         struct stat buf;
 532         int s = MCD_SIZE;
 533         int i = 0, j;
 534
 535         f = fopen(mcd, "wb");
 536         if (f == NULL)
 537                 return;
 538
 539         if (stat(mcd, &buf) != -1) {
 540                 if ((buf.st_size == MCD_SIZE + 3904) || strstr(mcd, ".gme")) {
 541                         s = s + 3904;
 542                         fputc('1', f);
 543                         s--;
 544                         fputc('2', f);
 545                         s--;
 546                         fputc('3', f);
 547                         s--;
 548                         fputc('-', f);
 549                         s--;
 550                         fputc('4', f);
 551                         s--;
 552                         fputc('5', f);
 553                         s--;
 554                         fputc('6', f);
 555                         s--;
 556                         fputc('-', f);
 557                         s--;
 558                         fputc('S', f);
 559                         s--;
 560                         fputc('T', f);
 561                         s--;
 562                         fputc('D', f);
 563                         s--;
 564                         for (i = 0; i < 7; i++) {
 565                                 fputc(0, f);
 566                                 s--;
 567                         }
 568                         fputc(1, f);
 569                         s--;
 570                         fputc(0, f);
 571                         s--;
 572                         fputc(1, f);
 573                         s--;
 574                         fputc('M', f);
 575                         s--;
 576                         fputc('Q', f);
 577                         s--;
 578                         for (i = 0; i < 14; i++) {
 579                                 fputc(0xa0, f);
 580                                 s--;
 581                         }
 582                         fputc(0, f);
 583                         s--;
 584                         fputc(0xff, f);
 585                         while (s-- > (MCD_SIZE + 1))
 586                                 fputc(0, f);
 587                 } else if ((buf.st_size == MCD_SIZE + 64) || strstr(mcd, ".mem") || strstr(mcd, ".vgs")) {
 588                         s = s + 64;
 589                         fputc('V', f);
 590                         s--;
 591                         fputc('g', f);
 592                         s--;
 593                         fputc('s', f);
 594                         s--;
 595                         fputc('M', f);
 596                         s--;
 597                         for (i = 0; i < 3; i++) {
 598                                 fputc(1, f);
 599                                 s--;
 600                                 fputc(0, f);
 601                                 s--;
 602                                 fputc(0, f);
 603                                 s--;
 604                                 fputc(0, f);
 605                                 s--;
 606                         }
 607                         fputc(0, f);
 608                         s--;
 609                         fputc(2, f);
 610                         while (s-- > (MCD_SIZE + 1))
 611                                 fputc(0, f);
 612                 }
 613         }
 614         fputc('M', f);
 615         s--;
 616         fputc('C', f);
 617         s--;
 618         while (s-- > (MCD_SIZE - 127))
 619                 fputc(0, f);
 620         fputc(0xe, f);
 621         s--;
 622
 623         for (i = 0; i < 15; i++) { // 15 blocks
 624                 fputc(0xa0, f);
 625                 s--;
 626                 fputc(0x00, f);
 627                 s--;
 628                 fputc(0x00, f);
 629                 s--;
 630                 fputc(0x00, f);
 631                 s--;
 632                 fputc(0x00, f);
 633                 s--;
 634                 fputc(0x00, f);
 635                 s--;
 636                 fputc(0x00, f);
 637                 s--;
 638                 fputc(0x00, f);
 639                 s--;
 640                 fputc(0xff, f);
 641                 s--;
 642                 fputc(0xff, f);
 643                 s--;
 644                 for (j = 0; j < 117; j++) {
 645                         fputc(0x00, f);
 646                         s--;
 647                 }
 648                 fputc(0xa0, f);
 649                 s--;
 650         }
 651
 652         for (i = 0; i < 20; i++) {
 653                 fputc(0xff, f);
 654                 s--;
 655                 fputc(0xff, f);
 656                 s--;
 657                 fputc(0xff, f);
 658                 s--;
 659                 fputc(0xff, f);
 660                 s--;
 661                 fputc(0x00, f);
 662                 s--;
 663                 fputc(0x00, f);
 664                 s--;
 665                 fputc(0x00, f);
 666                 s--;
 667                 fputc(0x00, f);
 668                 s--;
 669                 fputc(0xff, f);
 670                 s--;
 671                 fputc(0xff, f);
 672                 s--;
 673                 for (j = 0; j < 118; j++) {
 674                         fputc(0x00, f);
 675                         s--;
 676                 }
 677         }
 678
 679         while ((s--) >= 0)
 680                 fputc(0, f);
 681
 682         fclose(f);
 683 }
 684
 685 void ConvertMcd(char *mcd, char *data) {
 686         FILE *f;
 687         int i = 0;
 688         int s = MCD_SIZE;
 689
 690         if (strstr(mcd, ".gme")) {
 691                 f = fopen(mcd, "wb");
 692                 if (f != NULL) {
 693                         fwrite(data - 3904, 1, MCD_SIZE + 3904, f);
 694                         fclose(f);
 695                 }
 696                 f = fopen(mcd, "r+");
 697                 s = s + 3904;
 698                 fputc('1', f); s--;
 699                 fputc('2', f); s--;
 700                 fputc('3', f); s--;
 701                 fputc('-', f); s--;
 702                 fputc('4', f); s--;
 703                 fputc('5', f); s--;
 704                 fputc('6', f); s--;
 705                 fputc('-', f); s--;
 706                 fputc('S', f); s--;
 707                 fputc('T', f); s--;
 708                 fputc('D', f); s--;
 709                 for (i = 0; i < 7; i++) {
 710                         fputc(0, f); s--;
 711                 }
 712                 fputc(1, f); s--;
 713                 fputc(0, f); s--;
 714                 fputc(1, f); s--;
 715                 fputc('M', f); s--;
 716                 fputc('Q', f); s--;
 717                 for(i=0;i<14;i++) {
 718                         fputc(0xa0, f); s--;
 719                 }
 720                 fputc(0, f); s--;
 721                 fputc(0xff, f);
 722                 while (s-- > (MCD_SIZE+1)) fputc(0, f);
 723                 fclose(f);
 724         } else if(strstr(mcd, ".mem") || strstr(mcd,".vgs")) {
 725                 f = fopen(mcd, "wb");
 726                 if (f != NULL) {
 727                         fwrite(data-64, 1, MCD_SIZE+64, f);
 728                         fclose(f);
 729                 }
 730                 f = fopen(mcd, "r+");
 731                 s = s + 64;
 732                 fputc('V', f); s--;
 733                 fputc('g', f); s--;
 734                 fputc('s', f); s--;
 735                 fputc('M', f); s--;
 736                 for(i=0;i<3;i++) {
 737                         fputc(1, f); s--;
 738                         fputc(0, f); s--;
 739                         fputc(0, f); s--;
 740                         fputc(0, f); s--;
 741                 }
 742                 fputc(0, f); s--;
 743                 fputc(2, f);
 744                 while (s-- > (MCD_SIZE+1)) fputc(0, f);
 745                 fclose(f);
 746         } else {
 747                 f = fopen(mcd, "wb");
 748                 if (f != NULL) {
 749                         fwrite(data, 1, MCD_SIZE, f);
 750                         fclose(f);
 751                 }
 752         }
 753 }
 754
 755 void GetMcdBlockInfo(int mcd, int block, McdBlock *Info) {
 756         char *data = NULL, *ptr, *str, *sstr;
 757         unsigned short clut[16];
 758         unsigned short c;
 759         int i, x;
 760
 761         memset(Info, 0, sizeof(McdBlock));
 762
 763         if (mcd != 1 && mcd != 2)
 764                 return;
 765
 766         if (McdDisable[mcd - 1])
 767                 return;
 768
 769         if (mcd == 1) data = Mcd1Data;
 770         if (mcd == 2) data = Mcd2Data;
 771
 772         ptr = data + block * 8192 + 2;
 773
 774         Info->IconCount = *ptr & 0x3;
 775
 776         ptr += 2;
 777
 778         x = 0;
 779
 780         str = Info->Title;
 781         sstr = Info->sTitle;
 782
 783         for (i = 0; i < 48; i++) {
 784                 c = *(ptr) << 8;
 785                 c |= *(ptr + 1);
 786                 if (!c) break;
 787
 788                 // Convert ASCII characters to half-width
 789                 if (c >= 0x8281 && c <= 0x829A)
 790                         c = (c - 0x8281) + 'a';
 791                 else if (c >= 0x824F && c <= 0x827A)
 792                         c = (c - 0x824F) + '0';
 793                 else if (c == 0x8140) c = ' ';
 794                 else if (c == 0x8143) c = ',';
 795                 else if (c == 0x8144) c = '.';
 796                 else if (c == 0x8146) c = ':';
 797                 else if (c == 0x8147) c = ';';
 798                 else if (c == 0x8148) c = '?';
 799                 else if (c == 0x8149) c = '!';
 800                 else if (c == 0x815E) c = '/';
 801                 else if (c == 0x8168) c = '"';
 802                 else if (c == 0x8169) c = '(';
 803                 else if (c == 0x816A) c = ')';
 804                 else if (c == 0x816D) c = '[';
 805                 else if (c == 0x816E) c = ']';
 806                 else if (c == 0x817C) c = '-';
 807                 else {
 808                         str[i] = ' ';
 809                         sstr[x++] = *ptr++; sstr[x++] = *ptr++;
 810                         continue;
 811                 }
 812
 813                 str[i] = sstr[x++] = c;
 814                 ptr += 2;
 815         }
 816
 817         trim(str);
 818         trim(sstr);
 819
 820         ptr = data + block * 8192 + 0x60; // icon palette data
 821
 822         for (i = 0; i < 16; i++) {
 823                 clut[i] = *((unsigned short *)ptr);
 824                 ptr += 2;
 825         }
 826
 827         for (i = 0; i < Info->IconCount; i++) {
 828                 short *icon = &Info->Icon[i * 16 * 16];
 829
 830                 ptr = data + block * 8192 + 128 + 128 * i; // icon data
 831
 832                 for (x = 0; x < 16 * 16; x++) {
 833                         icon[x++] = clut[*ptr & 0xf];
 834                         icon[x] = clut[*ptr >> 4];
 835                         ptr++;
 836                 }
 837         }
 838
 839         ptr = data + block * 128;
 840
 841         Info->Flags = *ptr;
 842
 843         ptr += 0xa;
 844         strncpy(Info->ID, ptr, 12);
 845         ptr += 12;
 846         strncpy(Info->Name, ptr, 16);
 847 }
 848
 849 int sioFreeze(void *f, int Mode) {
 850         gzfreeze(buf, sizeof(buf));
 851         gzfreeze(&StatReg, sizeof(StatReg));
 852         gzfreeze(&ModeReg, sizeof(ModeReg));
 853         gzfreeze(&CtrlReg, sizeof(CtrlReg));
 854         gzfreeze(&BaudReg, sizeof(BaudReg));
 855         gzfreeze(&bufcount, sizeof(bufcount));
 856         gzfreeze(&parp, sizeof(parp));
 857         gzfreeze(&mcdst, sizeof(mcdst));
 858         gzfreeze(&rdwr, sizeof(rdwr));
 859         gzfreeze(&adrH, sizeof(adrH));
 860         gzfreeze(&adrL, sizeof(adrL));
 861         gzfreeze(&padst, sizeof(padst));
 862
 863         return 0;
 864 }