platform ps2, handle audio similar to psp
[picodrive.git] / pico / cart.c
index ad15ab9..a196dfd 100644 (file)
@@ -1,26 +1,37 @@
-// This is part of Pico Library\r
-\r
-// (c) Copyright 2004 Dave, All rights reserved.\r
-// (c) Copyright 2006-2007, Grazvydas "notaz" Ignotas\r
-// Free for non-commercial use.\r
-\r
-// For commercial use, separate licencing terms must be obtained.\r
-\r
+/*\r
+ * PicoDrive\r
+ * (c) Copyright Dave, 2004\r
+ * (C) notaz, 2006-2010\r
+ * (C) irixxxx, 2020-2024\r
+ *\r
+ * This work is licensed under the terms of MAME license.\r
+ * See COPYING file in the top-level directory.\r
+ */\r
 \r
 #include "pico_int.h"\r
 \r
 #include "pico_int.h"\r
-#include "../zlib/zlib.h"\r
-#include "../unzip/unzip.h"\r
-#include "../unzip/unzip_stream.h"\r
+#include <cpu/debug.h>\r
+\r
+#if defined(USE_LIBCHDR)\r
+#include "libchdr/chd.h"\r
+#include "libchdr/cdrom.h"\r
+#endif\r
 \r
 \r
+#include <unzip/unzip.h>\r
+#include <zlib.h>\r
 \r
 \r
-static char *rom_exts[] = { "bin", "gen", "smd", "iso" };\r
+static int rom_alloc_size;\r
+static const char *rom_exts[] = { "bin", "gen", "smd", "md", "32x", "pco", "iso", "sms", "gg", "sg", "sc" };\r
 \r
 \r
-void (*PicoCartUnloadHook)(void) = NULL;\r
+void (*PicoCartUnloadHook)(void);\r
+void (*PicoCartMemSetup)(void);\r
 \r
 void (*PicoCartLoadProgressCB)(int percent) = NULL;\r
 \r
 void (*PicoCartLoadProgressCB)(int percent) = NULL;\r
-void (*PicoCDLoadProgressCB)(int percent) = NULL; // handled in Pico/cd/cd_file.c\r
+void (*PicoCDLoadProgressCB)(const char *fname, int percent) = NULL; // handled in Pico/cd/cd_file.c\r
+\r
+int PicoGameLoaded;\r
 \r
 \r
-static void PicoCartDetect(void);\r
+static void PicoCartDetect(const char *carthw_cfg);\r
+static void PicoCartDetectMS(void);\r
 \r
 /* cso struct */\r
 typedef struct _cso_struct\r
 \r
 /* cso struct */\r
 typedef struct _cso_struct\r
@@ -45,7 +56,7 @@ typedef struct _cso_struct
 }\r
 cso_struct;\r
 \r
 }\r
 cso_struct;\r
 \r
-static int uncompress2(void *dest, int destLen, void *source, int sourceLen)\r
+static int uncompress_buf(void *dest, int destLen, void *source, int sourceLen)\r
 {\r
     z_stream stream;\r
     int err;\r
 {\r
     z_stream stream;\r
     int err;\r
@@ -71,73 +82,115 @@ static int uncompress2(void *dest, int destLen, void *source, int sourceLen)
     return inflateEnd(&stream);\r
 }\r
 \r
     return inflateEnd(&stream);\r
 }\r
 \r
+static const char *get_ext(const char *path)\r
+{\r
+  const char *ext;\r
+  if (strlen(path) < 4)\r
+    return ""; // no ext\r
+\r
+  // allow 2 or 3 char extensions for now\r
+  ext = path + strlen(path) - 2;\r
+  if (ext[-1] != '.') ext--;\r
+  if (ext[-1] != '.')\r
+    return "";\r
+  return ext;\r
+}\r
+\r
+struct zip_file {\r
+  pm_file file;\r
+  ZIP *zip;\r
+  struct zipent *entry;\r
+  z_stream stream;\r
+  unsigned char inbuf[16384];\r
+  long start;\r
+  unsigned int pos;\r
+};\r
+\r
+#if defined(USE_LIBCHDR)\r
+struct chd_struct {\r
+  pm_file file;\r
+  int fpos;\r
+  int sectorsize;\r
+  chd_file *chd;\r
+  int unitbytes;\r
+  int hunkunits;\r
+  u8 *hunk;\r
+  int hunknum;\r
+};\r
+#endif\r
+\r
 pm_file *pm_open(const char *path)\r
 {\r
   pm_file *file = NULL;\r
   const char *ext;\r
   FILE *f;\r
 \r
 pm_file *pm_open(const char *path)\r
 {\r
   pm_file *file = NULL;\r
   const char *ext;\r
   FILE *f;\r
 \r
-  if (path == NULL) return NULL;\r
-\r
-  if (strlen(path) < 5) ext = NULL; // no ext\r
-  else ext = path + strlen(path) - 3;\r
+  if (path == NULL)\r
+    return NULL;\r
 \r
 \r
-  if (ext && strcasecmp(ext, "zip") == 0)\r
+  ext = get_ext(path);\r
+  if (strcasecmp(ext, "zip") == 0)\r
   {\r
   {\r
+    struct zip_file *zfile = NULL;\r
     struct zipent *zipentry;\r
     struct zipent *zipentry;\r
-    gzFile gzf = NULL;\r
     ZIP *zipfile;\r
     ZIP *zipfile;\r
-    int i;\r
+    int i, ret;\r
 \r
     zipfile = openzip(path);\r
 \r
     zipfile = openzip(path);\r
-\r
     if (zipfile != NULL)\r
     {\r
       /* search for suitable file (right extension or large enough file) */\r
       while ((zipentry = readzip(zipfile)) != NULL)\r
       {\r
     if (zipfile != NULL)\r
     {\r
       /* search for suitable file (right extension or large enough file) */\r
       while ((zipentry = readzip(zipfile)) != NULL)\r
       {\r
-        if (zipentry->uncompressed_size >= 128*1024) goto found_rom_zip;\r
-        if (strlen(zipentry->name) < 5) continue;\r
+        ext = get_ext(zipentry->name);\r
+\r
+        if (zipentry->uncompressed_size >= 32*1024)\r
+          goto found_rom_zip;\r
 \r
 \r
-        ext = zipentry->name+strlen(zipentry->name)-3;\r
         for (i = 0; i < sizeof(rom_exts)/sizeof(rom_exts[0]); i++)\r
         for (i = 0; i < sizeof(rom_exts)/sizeof(rom_exts[0]); i++)\r
-          if (strcasecmp(ext, rom_exts[i]) == 0) goto found_rom_zip;\r
+          if (strcasecmp(ext, rom_exts[i]) == 0)\r
+            goto found_rom_zip;\r
       }\r
 \r
       /* zipfile given, but nothing found suitable for us inside */\r
       goto zip_failed;\r
 \r
 found_rom_zip:\r
       }\r
 \r
       /* zipfile given, but nothing found suitable for us inside */\r
       goto zip_failed;\r
 \r
 found_rom_zip:\r
-      /* try to convert to gzip stream, so we could use standard gzio functions from zlib */\r
-      gzf = zip2gz(zipfile, zipentry);\r
-      if (gzf == NULL)  goto zip_failed;\r
-\r
-      file = malloc(sizeof(*file));\r
-      if (file == NULL) goto zip_failed;\r
-      file->file  = zipfile;\r
-      file->param = gzf;\r
-      file->size  = zipentry->uncompressed_size;\r
-      file->type  = PMT_ZIP;\r
-      return file;\r
+      zfile = calloc(1, sizeof(*zfile));\r
+      if (zfile == NULL)\r
+        goto zip_failed;\r
+      ret = seekcompresszip(zipfile, zipentry);\r
+      if (ret != 0)\r
+        goto zip_failed;\r
+      ret = inflateInit2(&zfile->stream, -15);\r
+      if (ret != Z_OK) {\r
+        elprintf(EL_STATUS, "zip: inflateInit2 %d", ret);\r
+        goto zip_failed;\r
+      }\r
+      zfile->zip = zipfile;\r
+      zfile->entry = zipentry;\r
+      zfile->start = ftell(zipfile->fp);\r
+      zfile->file.file = zfile;\r
+      zfile->file.size = zipentry->uncompressed_size;\r
+      zfile->file.type = PMT_ZIP;\r
+      strncpy(zfile->file.ext, ext, sizeof(zfile->file.ext) - 1);\r
+      return &zfile->file;\r
 \r
 zip_failed:\r
 \r
 zip_failed:\r
-      if (gzf) {\r
-        gzclose(gzf);\r
-        zipfile->fp = NULL; // gzclose() closed it\r
-      }\r
       closezip(zipfile);\r
       closezip(zipfile);\r
+      free(zfile);\r
       return NULL;\r
     }\r
   }\r
       return NULL;\r
     }\r
   }\r
-  else if (ext && strcasecmp(ext, "cso") == 0)\r
+  else if (strcasecmp(ext, "cso") == 0)\r
   {\r
     cso_struct *cso = NULL, *tmp = NULL;\r
   {\r
     cso_struct *cso = NULL, *tmp = NULL;\r
-    int size;\r
+    int i, size;\r
     f = fopen(path, "rb");\r
     if (f == NULL)\r
       goto cso_failed;\r
 \r
     f = fopen(path, "rb");\r
     if (f == NULL)\r
       goto cso_failed;\r
 \r
-#ifndef __EPOC32__\r
+#ifdef __GP2X__\r
     /* we use our own buffering */\r
     setvbuf(f, NULL, _IONBF, 0);\r
 #endif\r
     /* we use our own buffering */\r
     setvbuf(f, NULL, _IONBF, 0);\r
 #endif\r
@@ -148,6 +201,9 @@ zip_failed:
 \r
     if (fread(&cso->header, 1, sizeof(cso->header), f) != sizeof(cso->header))\r
       goto cso_failed;\r
 \r
     if (fread(&cso->header, 1, sizeof(cso->header), f) != sizeof(cso->header))\r
       goto cso_failed;\r
+    cso->header.block_size = CPU_LE4(cso->header.block_size);\r
+    cso->header.total_bytes = CPU_LE4(cso->header.total_bytes);\r
+    cso->header.total_bytes_high = CPU_LE4(cso->header.total_bytes_high);\r
 \r
     if (strncmp(cso->header.magic, "CISO", 4) != 0) {\r
       elprintf(EL_STATUS, "cso: bad header");\r
 \r
     if (strncmp(cso->header.magic, "CISO", 4) != 0) {\r
       elprintf(EL_STATUS, "cso: bad header");\r
@@ -171,17 +227,20 @@ zip_failed:
       elprintf(EL_STATUS, "cso: premature EOF");\r
       goto cso_failed;\r
     }\r
       elprintf(EL_STATUS, "cso: premature EOF");\r
       goto cso_failed;\r
     }\r
+    for (i = 0; i < size/4; i++)\r
+      cso->index[i] = CPU_LE4(cso->index[i]);\r
 \r
     // all ok\r
     cso->fpos_in = ftell(f);\r
     cso->fpos_out = 0;\r
     cso->block_in_buff = -1;\r
 \r
     // all ok\r
     cso->fpos_in = ftell(f);\r
     cso->fpos_out = 0;\r
     cso->block_in_buff = -1;\r
-    file = malloc(sizeof(*file));\r
+    file = calloc(1, sizeof(*file));\r
     if (file == NULL) goto cso_failed;\r
     file->file  = f;\r
     file->param = cso;\r
     file->size  = cso->header.total_bytes;\r
     file->type  = PMT_CSO;\r
     if (file == NULL) goto cso_failed;\r
     file->file  = f;\r
     file->param = cso;\r
     file->size  = cso->header.total_bytes;\r
     file->type  = PMT_CSO;\r
+    strncpy(file->ext, ext, sizeof(file->ext) - 1);\r
     return file;\r
 \r
 cso_failed:\r
     return file;\r
 \r
 cso_failed:\r
@@ -189,12 +248,56 @@ cso_failed:
     if (f != NULL) fclose(f);\r
     return NULL;\r
   }\r
     if (f != NULL) fclose(f);\r
     return NULL;\r
   }\r
+#if defined(USE_LIBCHDR)\r
+  else if (strcasecmp(ext, "chd") == 0)\r
+  {\r
+    struct chd_struct *chd = NULL;\r
+    chd_file *cf = NULL;\r
+    const chd_header *head;\r
+\r
+    if (chd_open(path, CHD_OPEN_READ, NULL, &cf) != CHDERR_NONE)\r
+      goto chd_failed;\r
+\r
+    // sanity check\r
+    head = chd_get_header(cf);\r
+    if ((head->hunkbytes == 0) || (head->hunkbytes % CD_FRAME_SIZE))\r
+      goto chd_failed;\r
+\r
+    chd = calloc(1, sizeof(*chd));\r
+    if (chd == NULL)\r
+      goto chd_failed;\r
+    chd->hunk = (u8 *)malloc(head->hunkbytes);\r
+    if (!chd->hunk)\r
+      goto chd_failed;\r
+\r
+    chd->chd = cf;\r
+    chd->unitbytes = head->unitbytes;\r
+    chd->hunkunits = head->hunkbytes / head->unitbytes;\r
+    chd->sectorsize = CD_MAX_SECTOR_DATA; // default to RAW mode\r
+\r
+    chd->fpos = 0;\r
+    chd->hunknum = -1;\r
+\r
+    chd->file.file = chd;\r
+    chd->file.type = PMT_CHD;\r
+    // subchannel data is skipped, remove it from total size\r
+    chd->file.size = head->logicalbytes / CD_FRAME_SIZE * CD_MAX_SECTOR_DATA;\r
+    strncpy(chd->file.ext, ext, sizeof(chd->file.ext) - 1);\r
+    return &chd->file;\r
+\r
+chd_failed:\r
+    /* invalid CHD file */\r
+    if (chd != NULL) free(chd);\r
+    if (cf != NULL) chd_close(cf);\r
+    return NULL;\r
+  }\r
+#endif\r
 \r
   /* not a zip, treat as uncompressed file */\r
   f = fopen(path, "rb");\r
   if (f == NULL) return NULL;\r
 \r
 \r
   /* not a zip, treat as uncompressed file */\r
   f = fopen(path, "rb");\r
   if (f == NULL) return NULL;\r
 \r
-  file = malloc(sizeof(*file));\r
+  file = calloc(1, sizeof(*file));\r
   if (file == NULL) {\r
     fclose(f);\r
     return NULL;\r
   if (file == NULL) {\r
     fclose(f);\r
     return NULL;\r
@@ -204,9 +307,10 @@ cso_failed:
   file->param = NULL;\r
   file->size  = ftell(f);\r
   file->type  = PMT_UNCOMPRESSED;\r
   file->param = NULL;\r
   file->size  = ftell(f);\r
   file->type  = PMT_UNCOMPRESSED;\r
+  strncpy(file->ext, ext, sizeof(file->ext) - 1);\r
   fseek(f, 0, SEEK_SET);\r
 \r
   fseek(f, 0, SEEK_SET);\r
 \r
-#ifndef __EPOC32__ // makes things worse on Symbian\r
+#ifdef __GP2X__\r
   if (file->size > 0x400000)\r
     /* we use our own buffering */\r
     setvbuf(f, NULL, _IONBF, 0);\r
   if (file->size > 0x400000)\r
     /* we use our own buffering */\r
     setvbuf(f, NULL, _IONBF, 0);\r
@@ -215,23 +319,127 @@ cso_failed:
   return file;\r
 }\r
 \r
   return file;\r
 }\r
 \r
+void pm_sectorsize(int length, pm_file *stream)\r
+{\r
+  // CHD reading needs to know how much binary data is in one data sector(=unit)\r
+#if defined(USE_LIBCHDR)\r
+  if (stream->type == PMT_CHD) {\r
+    struct chd_struct *chd = stream->file;\r
+    chd->sectorsize = length;\r
+    if (chd->sectorsize > chd->unitbytes)\r
+      elprintf(EL_STATUS|EL_ANOMALY, "cd: sector size %d too large for unit %d", chd->sectorsize, chd->unitbytes);\r
+  }\r
+#endif\r
+}\r
+\r
+#if defined(USE_LIBCHDR)\r
+static size_t _pm_read_chd(void *ptr, size_t bytes, pm_file *stream, int is_audio)\r
+{\r
+  int ret = 0;\r
+\r
+  if (stream->type == PMT_CHD) {\r
+    struct chd_struct *chd = stream->file;\r
+    // calculate sector and offset in sector\r
+    int sectsz = is_audio ? CD_MAX_SECTOR_DATA : chd->sectorsize;\r
+    int sector = chd->fpos / sectsz;\r
+    int offset = chd->fpos - (sector * sectsz);\r
+    // calculate hunk and sector offset in hunk\r
+    int hunknum = sector / chd->hunkunits;\r
+    int hunksec = sector - (hunknum * chd->hunkunits);\r
+    int hunkofs = hunksec * chd->unitbytes;\r
+\r
+    while (bytes != 0) {\r
+      // data left in current sector\r
+      int len = sectsz - offset;\r
+\r
+      // update hunk cache if needed\r
+      if (hunknum != chd->hunknum) {\r
+        chd_read(chd->chd, hunknum, chd->hunk);\r
+        chd->hunknum = hunknum;\r
+      }\r
+      if (len > bytes)\r
+        len = bytes;\r
+\r
+#if CPU_IS_LE\r
+      if (is_audio) {\r
+        // convert big endian audio samples\r
+        u16 *dst = ptr, v;\r
+        u8 *src = chd->hunk + hunkofs + offset;\r
+        int i;\r
+\r
+        for (i = 0; i < len; i += 4) {\r
+          v = *src++ << 8; *dst++ = v | *src++;\r
+          v = *src++ << 8; *dst++ = v | *src++;\r
+        }\r
+      } else\r
+#endif\r
+        memcpy(ptr, chd->hunk + hunkofs + offset, len);\r
+\r
+      // house keeping\r
+      ret += len;\r
+      chd->fpos += len;\r
+      bytes -= len;\r
+\r
+      // no need to advance internals if there's no more data to read\r
+      if (bytes) {\r
+        ptr += len;\r
+        offset = 0;\r
+\r
+        sector ++;\r
+        hunksec ++;\r
+        hunkofs += chd->unitbytes;\r
+        if (hunksec >= chd->hunkunits) {\r
+          hunksec = 0;\r
+          hunkofs = 0;\r
+          hunknum ++;\r
+        }\r
+      }\r
+    }\r
+  }\r
+\r
+  return ret;\r
+}\r
+#endif\r
+\r
 size_t pm_read(void *ptr, size_t bytes, pm_file *stream)\r
 {\r
   int ret;\r
 \r
 size_t pm_read(void *ptr, size_t bytes, pm_file *stream)\r
 {\r
   int ret;\r
 \r
-  if (stream->type == PMT_UNCOMPRESSED)\r
+  if (stream == NULL)\r
+    return -1;\r
+  else if (stream->type == PMT_UNCOMPRESSED)\r
   {\r
     ret = fread(ptr, 1, bytes, stream->file);\r
   }\r
   else if (stream->type == PMT_ZIP)\r
   {\r
   {\r
     ret = fread(ptr, 1, bytes, stream->file);\r
   }\r
   else if (stream->type == PMT_ZIP)\r
   {\r
-    gzFile gf = stream->param;\r
-    int err;\r
-    ret = gzread(gf, ptr, bytes);\r
-    err = gzerror2(gf);\r
-    if (ret > 0 && (err == Z_DATA_ERROR || err == Z_STREAM_END))\r
-      /* we must reset stream pointer or else next seek/read fails */\r
-      gzrewind(gf);\r
+    struct zip_file *z = stream->file;\r
+\r
+    if (z->entry->compression_method == 0) {\r
+      int ret = fread(ptr, 1, bytes, z->zip->fp);\r
+      z->pos += ret;\r
+      return ret;\r
+    }\r
+\r
+    z->stream.next_out = ptr;\r
+    z->stream.avail_out = bytes;\r
+    while (z->stream.avail_out != 0) {\r
+      if (z->stream.avail_in == 0) {\r
+        z->stream.avail_in = fread(z->inbuf, 1, sizeof(z->inbuf), z->zip->fp);\r
+        if (z->stream.avail_in == 0)\r
+          break;\r
+        z->stream.next_in = z->inbuf;\r
+      }\r
+      ret = inflate(&z->stream, Z_NO_FLUSH);\r
+      if (ret == Z_STREAM_END)\r
+        break;\r
+      if (ret != Z_OK) {\r
+        elprintf(EL_STATUS, "zip: inflate: %d", ret);\r
+        return 0;\r
+      }\r
+    }\r
+    z->pos += bytes - z->stream.avail_out;\r
+    return bytes - z->stream.avail_out;\r
   }\r
   else if (stream->type == PMT_CSO)\r
   {\r
   }\r
   else if (stream->type == PMT_CSO)\r
   {\r
@@ -272,7 +480,7 @@ size_t pm_read(void *ptr, size_t bytes, pm_file *stream)
           }\r
           cso->block_in_buff = block;\r
         }\r
           }\r
           cso->block_in_buff = block;\r
         }\r
-        rret = uncompress2(tmp_dst, 2048, cso->in_buff, read_len);\r
+        rret = uncompress_buf(tmp_dst, 2048, cso->in_buff, read_len);\r
         if (rret != 0) {\r
           elprintf(EL_STATUS, "cso: uncompress failed @ %08x with %i", read_pos, rret);\r
           break;\r
         if (rret != 0) {\r
           elprintf(EL_STATUS, "cso: uncompress failed @ %08x with %i", read_pos, rret);\r
           break;\r
@@ -295,27 +503,98 @@ size_t pm_read(void *ptr, size_t bytes, pm_file *stream)
       index_end = cso->index[block+1];\r
     }\r
   }\r
       index_end = cso->index[block+1];\r
     }\r
   }\r
+#if defined(USE_LIBCHDR)\r
+  else if (stream->type == PMT_CHD)\r
+  {\r
+    ret = _pm_read_chd(ptr, bytes, stream, 0);\r
+  }\r
+#endif\r
   else\r
     ret = 0;\r
 \r
   return ret;\r
 }\r
 \r
   else\r
     ret = 0;\r
 \r
   return ret;\r
 }\r
 \r
+size_t pm_read_audio(void *ptr, size_t bytes, pm_file *stream)\r
+{\r
+  if (stream == NULL)\r
+    return -1;\r
+#if !(CPU_IS_LE)\r
+  else if (stream->type == PMT_UNCOMPRESSED)\r
+  {\r
+    // convert little endian audio samples from WAV file\r
+    int ret = pm_read(ptr, bytes, stream);\r
+    u16 *dst = ptr, v;\r
+    u8 *src = ptr;\r
+    int i;\r
+\r
+    for (i = 0; i < ret; i += 4) {\r
+      v = *src++; *dst++ = v | (*src++ << 8);\r
+      v = *src++; *dst++ = v | (*src++ << 8);\r
+    }\r
+    return ret;\r
+  }\r
+  else\r
+#endif\r
+#if defined(USE_LIBCHDR)\r
+  if (stream->type == PMT_CHD)\r
+  {\r
+    return _pm_read_chd(ptr, bytes, stream, 1);\r
+  }\r
+#endif\r
+  return pm_read(ptr, bytes, stream);\r
+}\r
+\r
 int pm_seek(pm_file *stream, long offset, int whence)\r
 {\r
 int pm_seek(pm_file *stream, long offset, int whence)\r
 {\r
-  if (stream->type == PMT_UNCOMPRESSED)\r
+  if (stream == NULL)\r
+    return -1;\r
+  else if (stream->type == PMT_UNCOMPRESSED)\r
   {\r
     fseek(stream->file, offset, whence);\r
     return ftell(stream->file);\r
   }\r
   else if (stream->type == PMT_ZIP)\r
   {\r
   {\r
     fseek(stream->file, offset, whence);\r
     return ftell(stream->file);\r
   }\r
   else if (stream->type == PMT_ZIP)\r
   {\r
-    if (PicoMessage != NULL && offset > 6*1024*1024) {\r
-      long pos = gztell((gzFile) stream->param);\r
-      if (offset < pos || offset - pos > 6*1024*1024)\r
-        PicoMessage("Decompressing data...");\r
+    struct zip_file *z = stream->file;\r
+    unsigned int pos = z->pos;\r
+    int ret;\r
+\r
+    switch (whence)\r
+    {\r
+      case SEEK_CUR: pos += offset; break;\r
+      case SEEK_SET: pos  = offset; break;\r
+      case SEEK_END: pos  = stream->size - offset; break;\r
+    }\r
+    if (z->entry->compression_method == 0) {\r
+      ret = fseek(z->zip->fp, z->start + pos, SEEK_SET);\r
+      if (ret == 0)\r
+        return (z->pos = pos);\r
+      return -1;\r
+    }\r
+    offset = pos - z->pos;\r
+    if (pos < z->pos) {\r
+      // full decompress from the start\r
+      fseek(z->zip->fp, z->start, SEEK_SET);\r
+      z->stream.avail_in = 0;\r
+      z->stream.next_in = z->inbuf;\r
+      inflateReset(&z->stream);\r
+      z->pos = 0;\r
+      offset = pos;\r
     }\r
     }\r
-    return gzseek((gzFile) stream->param, offset, whence);\r
+\r
+    if (PicoIn.osdMessage != NULL && offset > 4 * 1024 * 1024)\r
+      PicoIn.osdMessage("Decompressing data...");\r
+\r
+    while (offset > 0) {\r
+      char buf[16 * 1024];\r
+      size_t l = offset > sizeof(buf) ? sizeof(buf) : offset;\r
+      ret = pm_read(buf, l, stream);\r
+      if (ret != l)\r
+        break;\r
+      offset -= l;\r
+    }\r
+    return z->pos;\r
   }\r
   else if (stream->type == PMT_CSO)\r
   {\r
   }\r
   else if (stream->type == PMT_CSO)\r
   {\r
@@ -328,6 +607,19 @@ int pm_seek(pm_file *stream, long offset, int whence)
     }\r
     return cso->fpos_out;\r
   }\r
     }\r
     return cso->fpos_out;\r
   }\r
+#if defined(USE_LIBCHDR)\r
+  else if (stream->type == PMT_CHD)\r
+  {\r
+    struct chd_struct *chd = stream->file;\r
+    switch (whence)\r
+    {\r
+      case SEEK_CUR: chd->fpos += offset; break;\r
+      case SEEK_SET: chd->fpos  = offset; break;\r
+      case SEEK_END: chd->fpos  = stream->size - offset; break;\r
+    }\r
+    return chd->fpos;\r
+  }\r
+#endif\r
   else\r
     return -1;\r
 }\r
   else\r
     return -1;\r
 }\r
@@ -344,16 +636,24 @@ int pm_close(pm_file *fp)
   }\r
   else if (fp->type == PMT_ZIP)\r
   {\r
   }\r
   else if (fp->type == PMT_ZIP)\r
   {\r
-    ZIP *zipfile = fp->file;\r
-    gzclose((gzFile) fp->param);\r
-    zipfile->fp = NULL; // gzclose() closed it\r
-    closezip(zipfile);\r
+    struct zip_file *z = fp->file;\r
+    inflateEnd(&z->stream);\r
+    closezip(z->zip);\r
   }\r
   else if (fp->type == PMT_CSO)\r
   {\r
     free(fp->param);\r
     fclose(fp->file);\r
   }\r
   }\r
   else if (fp->type == PMT_CSO)\r
   {\r
     free(fp->param);\r
     fclose(fp->file);\r
   }\r
+#if defined(USE_LIBCHDR)\r
+  else if (fp->type == PMT_CHD)\r
+  {\r
+    struct chd_struct *chd = fp->file;\r
+    chd_close(chd->chd);\r
+    if (chd->hunk)\r
+      free(chd->hunk);\r
+  }\r
+#endif\r
   else\r
     ret = EOF;\r
 \r
   else\r
     ret = EOF;\r
 \r
@@ -361,31 +661,31 @@ int pm_close(pm_file *fp)
   return ret;\r
 }\r
 \r
   return ret;\r
 }\r
 \r
-\r
-void Byteswap(unsigned char *data,int len)\r
+// byteswap, data needs to be int aligned, src can match dst\r
+void Byteswap(void *dst, const void *src, int len)\r
 {\r
 {\r
-  int i=0;\r
-\r
-  if (len<2) return; // Too short\r
-\r
-  do\r
-  {\r
-    unsigned short *pd=(unsigned short *)(data+i);\r
-    int value=*pd; // Get 2 bytes\r
-\r
-    value=(value<<8)|(value>>8); // Byteswap it\r
-    *pd=(unsigned short)value; // Put 2b ytes\r
-    i+=2;\r
+#if CPU_IS_LE\r
+  const unsigned int *ps = src;\r
+  unsigned int *pd = dst;\r
+  int i, m;\r
+\r
+  if (len < 2)\r
+    return;\r
+\r
+  m = 0x00ff00ff;\r
+  for (i = 0; i < len / 4; i++) {\r
+    unsigned int t = ps[i];\r
+    pd[i] = ((t & m) << 8) | ((t & ~m) >> 8);\r
   }\r
   }\r
-  while (i+2<=len);\r
+#endif\r
 }\r
 \r
 // Interleve a 16k block and byteswap\r
 static int InterleveBlock(unsigned char *dest,unsigned char *src)\r
 {\r
   int i=0;\r
 }\r
 \r
 // Interleve a 16k block and byteswap\r
 static int InterleveBlock(unsigned char *dest,unsigned char *src)\r
 {\r
   int i=0;\r
-  for (i=0;i<0x2000;i++) dest[(i<<1)  ]=src[       i]; // Odd\r
-  for (i=0;i<0x2000;i++) dest[(i<<1)+1]=src[0x2000+i]; // Even\r
+  for (i=0;i<0x2000;i++) dest[(i<<1)+MEM_BE2(1)]=src[       i]; // Odd\r
+  for (i=0;i<0x2000;i++) dest[(i<<1)+MEM_BE2(0)]=src[0x2000+i]; // Even\r
   return 0;\r
 }\r
 \r
   return 0;\r
 }\r
 \r
@@ -410,323 +710,689 @@ static int DecodeSmd(unsigned char *data,int len)
   return 0;\r
 }\r
 \r
   return 0;\r
 }\r
 \r
-static unsigned char *cd_realloc(void *old, int filesize)\r
+static unsigned char *PicoCartAlloc(int filesize, int is_sms)\r
 {\r
   unsigned char *rom;\r
 {\r
   unsigned char *rom;\r
-  rom=realloc(old, sizeof(mcd_state));\r
-  if (rom) memset(rom+0x20000, 0, sizeof(mcd_state)-0x20000);\r
-  return rom;\r
-}\r
 \r
 \r
-static unsigned char *PicoCartAlloc(int filesize)\r
-{\r
-  int alloc_size;\r
-  unsigned char *rom;\r
-\r
-  if (PicoAHW & PAHW_MCD) return cd_realloc(NULL, filesize);\r
+  // make size power of 2 for easier banking handling\r
+  int s = 0, tmp = filesize;\r
+  while ((tmp >>= 1) != 0)\r
+    s++;\r
+  if (filesize > (1 << s))\r
+    s++;\r
+  rom_alloc_size = 1 << s;\r
+\r
+  if (is_sms) {\r
+    // be sure we can cover all address space\r
+    if (rom_alloc_size < 0x10000)\r
+      rom_alloc_size = 0x10000;\r
+  }\r
+  else {\r
+    // align to 512K for memhandlers\r
+    rom_alloc_size = (rom_alloc_size + 0x7ffff) & ~0x7ffff;\r
+  }\r
 \r
 \r
-  alloc_size=filesize+0x7ffff;\r
-  if((filesize&0x3fff)==0x200) alloc_size-=0x200;\r
-  alloc_size&=~0x7ffff; // use alloc size of multiples of 512K, so that memhandlers could be set up more efficiently\r
-  if((filesize&0x3fff)==0x200) alloc_size+=0x200;\r
-  else if(alloc_size-filesize < 4) alloc_size+=4; // padding for out-of-bound exec protection\r
+  if (rom_alloc_size - filesize < 4)\r
+    rom_alloc_size += 4; // padding for out-of-bound exec protection\r
 \r
   // Allocate space for the rom plus padding\r
 \r
   // Allocate space for the rom plus padding\r
-  rom=(unsigned char *)malloc(alloc_size);\r
-  if(rom) memset(rom+alloc_size-0x80000,0,0x80000);\r
+  // use special address for 32x dynarec\r
+  rom = plat_mmap(0x02000000, rom_alloc_size, 0, 0);\r
   return rom;\r
 }\r
 \r
   return rom;\r
 }\r
 \r
-int PicoCartLoad(pm_file *f,unsigned char **prom,unsigned int *psize)\r
+int PicoCartLoad(pm_file *f, const unsigned char *rom, unsigned int romsize,\r
+  unsigned char **prom, unsigned int *psize, int is_sms)\r
 {\r
 {\r
-  unsigned char *rom=NULL; int size, bytes_read;\r
-  if (f==NULL) return 1;\r
+  unsigned char *rom_data = NULL;\r
+  int size, bytes_read;\r
+\r
+  if (!f && !rom)\r
+    return 1;\r
+\r
+  if (!rom)\r
+    size = f->size;\r
+  else\r
+    size = romsize;\r
 \r
 \r
-  size=f->size;\r
   if (size <= 0) return 1;\r
   if (size <= 0) return 1;\r
-  size=(size+3)&~3; // Round up to a multiple of 4\r
+  size = (size+3)&~3; // Round up to a multiple of 4\r
 \r
   // Allocate space for the rom plus padding\r
 \r
   // Allocate space for the rom plus padding\r
-  rom=PicoCartAlloc(size);\r
-  if (rom==NULL) {\r
+  rom_data = PicoCartAlloc(size, is_sms);\r
+  if (rom_data == NULL) {\r
     elprintf(EL_STATUS, "out of memory (wanted %i)", size);\r
     return 2;\r
   }\r
 \r
     elprintf(EL_STATUS, "out of memory (wanted %i)", size);\r
     return 2;\r
   }\r
 \r
-  if (PicoCartLoadProgressCB != NULL)\r
-  {\r
-    // read ROM in blocks, just for fun\r
-    int ret;\r
-    unsigned char *p = rom;\r
-    bytes_read=0;\r
-    do\r
+  if (!rom) {\r
+    if (PicoCartLoadProgressCB != NULL)\r
     {\r
     {\r
-      int todo = size - bytes_read;\r
-      if (todo > 256*1024) todo = 256*1024;\r
-      ret = pm_read(p,todo,f);\r
-      bytes_read += ret;\r
-      p += ret;\r
-      PicoCartLoadProgressCB(bytes_read * 100 / size);\r
+      // read ROM in blocks, just for fun\r
+      int ret;\r
+      unsigned char *p = rom_data;\r
+      bytes_read=0;\r
+      do\r
+      {\r
+        int todo = size - bytes_read;\r
+        if (todo > 256*1024) todo = 256*1024;\r
+        ret = pm_read(p,todo,f);\r
+        bytes_read += ret;\r
+        p += ret;\r
+        PicoCartLoadProgressCB(bytes_read * 100LL / size);\r
+      }\r
+      while (ret > 0);\r
+    }\r
+    else\r
+      bytes_read = pm_read(rom_data,size,f); // Load up the rom\r
+\r
+    if (bytes_read <= 0) {\r
+      elprintf(EL_STATUS, "read failed");\r
+      plat_munmap(rom_data, rom_alloc_size);\r
+      return 3;\r
     }\r
     }\r
-    while (ret > 0);\r
   }\r
   else\r
   }\r
   else\r
-    bytes_read = pm_read(rom,size,f); // Load up the rom\r
-  if (bytes_read <= 0) {\r
-    elprintf(EL_STATUS, "read failed");\r
-    free(rom);\r
-    return 3;\r
-  }\r
+    memcpy(rom_data, rom, romsize);\r
 \r
 \r
-  // maybe we are loading MegaCD BIOS?\r
-  if (!(PicoAHW & PAHW_MCD) && size == 0x20000 && (!strncmp((char *)rom+0x124, "BOOT", 4) ||\r
-       !strncmp((char *)rom+0x128, "BOOT", 4))) {\r
-    PicoAHW |= PAHW_MCD;\r
-    rom = cd_realloc(rom, size);\r
-  }\r
+  if (!is_sms)\r
+  {\r
+    // maybe we are loading MegaCD BIOS?\r
+    if (!(PicoIn.AHW & PAHW_MCD) && size == 0x20000 && (!strncmp((char *)rom_data+0x124, "BOOT", 4) ||\r
+         !strncmp((char *)rom_data+0x128, "BOOT", 4))) {\r
+      PicoIn.AHW |= PAHW_MCD;\r
+    }\r
 \r
 \r
-  // Check for SMD:\r
-  if (size >= 0x4200 && (size&0x3fff)==0x200 &&\r
-      ((rom[0x2280] == 'S' && rom[0x280] == 'E') || (rom[0x280] == 'S' && rom[0x2281] == 'E'))) {\r
-    DecodeSmd(rom,size); size-=0x200; // Decode and byteswap SMD\r
+    // Check for SMD:\r
+    if (size >= 0x4200 && (size&0x3fff) == 0x200 &&\r
+        ((rom_data[0x2280] == 'S' && rom_data[0x280] == 'E') || (rom_data[0x280] == 'S' && rom_data[0x2281] == 'E'))) {\r
+      elprintf(EL_STATUS, "SMD format detected.");\r
+      DecodeSmd(rom_data,size); size-=0x200; // Decode and byteswap SMD\r
+    }\r
+    else Byteswap(rom_data, rom_data, size); // Just byteswap\r
+  }\r
+  else\r
+  {\r
+    if (size >= 0x4200 && (size&0x3fff) == 0x200) {\r
+      elprintf(EL_STATUS, "SMD format detected.");\r
+      // at least here it's not interleaved\r
+      size -= 0x200;\r
+      memmove(rom_data, rom_data + 0x200, size);\r
+    }\r
   }\r
   }\r
-  else Byteswap(rom,size); // Just byteswap\r
 \r
 \r
-  if (prom)  *prom=rom;\r
-  if (psize) *psize=size;\r
+  if (prom)  *prom = rom_data;\r
+  if (psize) *psize = size;\r
 \r
   return 0;\r
 }\r
 \r
 // Insert a cartridge:\r
 \r
   return 0;\r
 }\r
 \r
 // Insert a cartridge:\r
-int PicoCartInsert(unsigned char *rom,unsigned int romsize)\r
+int PicoCartInsert(unsigned char *rom, unsigned int romsize, const char *carthw_cfg)\r
 {\r
   // notaz: add a 68k "jump one op back" opcode to the end of ROM.\r
   // This will hang the emu, but will prevent nasty crashes.\r
   // note: 4 bytes are padded to every ROM\r
   if (rom != NULL)\r
 {\r
   // notaz: add a 68k "jump one op back" opcode to the end of ROM.\r
   // This will hang the emu, but will prevent nasty crashes.\r
   // note: 4 bytes are padded to every ROM\r
   if (rom != NULL)\r
-    *(unsigned long *)(rom+romsize) = 0xFFFE4EFA; // 4EFA FFFE byteswapped\r
+    *(u32 *)(rom+romsize) = CPU_BE2(0x4EFAFFFE);\r
 \r
   Pico.rom=rom;\r
   Pico.romsize=romsize;\r
 \r
 \r
   Pico.rom=rom;\r
   Pico.romsize=romsize;\r
 \r
-  if (SRam.data) {\r
-    free(SRam.data);\r
-    SRam.data = NULL;\r
+  if (Pico.sv.data) {\r
+    free(Pico.sv.data);\r
+    Pico.sv.data = NULL;\r
   }\r
 \r
   if (PicoCartUnloadHook != NULL) {\r
     PicoCartUnloadHook();\r
     PicoCartUnloadHook = NULL;\r
   }\r
   }\r
 \r
   if (PicoCartUnloadHook != NULL) {\r
     PicoCartUnloadHook();\r
     PicoCartUnloadHook = NULL;\r
   }\r
+  pdb_cleanup();\r
 \r
 \r
-  PicoAHW &= PAHW_MCD;\r
+  PicoIn.AHW &= ~(PAHW_32X|PAHW_SVP);\r
 \r
 \r
-  PicoMemResetHooks();\r
+  PicoCartMemSetup = NULL;\r
   PicoDmaHook = NULL;\r
   PicoResetHook = NULL;\r
   PicoLineHook = NULL;\r
   PicoLoadStateHook = NULL;\r
   carthw_chunks = NULL;\r
 \r
   PicoDmaHook = NULL;\r
   PicoResetHook = NULL;\r
   PicoLineHook = NULL;\r
   PicoLoadStateHook = NULL;\r
   carthw_chunks = NULL;\r
 \r
-  PicoMemReset();\r
-\r
-  if (!(PicoAHW & PAHW_MCD))\r
-    PicoCartDetect();\r
+  if (!(PicoIn.AHW & (PAHW_MCD|PAHW_SMS|PAHW_PICO)))\r
+    PicoCartDetect(carthw_cfg);\r
+  if (PicoIn.AHW & PAHW_SMS)\r
+    PicoCartDetectMS();\r
+  if (PicoIn.AHW & PAHW_SVP)\r
+    PicoSVPStartup();\r
+  if (PicoIn.AHW & PAHW_PICO)\r
+    PicoInitPico();\r
 \r
   // setup correct memory map for loaded ROM\r
 \r
   // setup correct memory map for loaded ROM\r
-  // call PicoMemReset again due to possible memmap change\r
-  switch (PicoAHW) {\r
+  switch (PicoIn.AHW & ~(PAHW_GG|PAHW_SG|PAHW_SC)) {\r
     default:\r
     default:\r
-      elprintf(EL_STATUS|EL_ANOMALY, "starting in unknown hw configuration: %x", PicoAHW);\r
+      elprintf(EL_STATUS|EL_ANOMALY, "starting in unknown hw configuration: %x", PicoIn.AHW);\r
     case 0:\r
     case PAHW_SVP:  PicoMemSetup(); break;\r
     case PAHW_MCD:  PicoMemSetupCD(); break;\r
     case PAHW_PICO: PicoMemSetupPico(); break;\r
     case 0:\r
     case PAHW_SVP:  PicoMemSetup(); break;\r
     case PAHW_MCD:  PicoMemSetupCD(); break;\r
     case PAHW_PICO: PicoMemSetupPico(); break;\r
+    case PAHW_SMS:  PicoMemSetupMS(); break;\r
   }\r
   }\r
-  PicoMemReset();\r
 \r
 \r
-  PicoPower();\r
+  if (PicoCartMemSetup != NULL)\r
+    PicoCartMemSetup();\r
+\r
+  if (PicoIn.AHW & PAHW_SMS)\r
+    PicoPowerMS();\r
+  else\r
+    PicoPower();\r
+\r
+  PicoGameLoaded = 1;\r
+  return 0;\r
+}\r
+\r
+int PicoCartResize(int newsize)\r
+{\r
+  void *tmp = plat_mremap(Pico.rom, rom_alloc_size, newsize);\r
+  if (tmp == NULL)\r
+    return -1;\r
+\r
+  Pico.rom = tmp;\r
+  rom_alloc_size = newsize;\r
   return 0;\r
 }\r
 \r
 void PicoCartUnload(void)\r
 {\r
   return 0;\r
 }\r
 \r
 void PicoCartUnload(void)\r
 {\r
+  if (PicoCartUnloadHook != NULL) {\r
+    PicoCartUnloadHook();\r
+    PicoCartUnloadHook = NULL;\r
+  }\r
+\r
+  PicoUnload32x();\r
+\r
   if (Pico.rom != NULL) {\r
     SekFinishIdleDet();\r
   if (Pico.rom != NULL) {\r
     SekFinishIdleDet();\r
-    free(Pico.rom);\r
-    Pico.rom=NULL;\r
+    plat_munmap(Pico.rom, rom_alloc_size);\r
+    Pico.rom = NULL;\r
   }\r
   }\r
+  PicoGameLoaded = 0;\r
+}\r
+\r
+static unsigned int rom_crc32(int size)\r
+{\r
+  unsigned int crc;\r
+  elprintf(EL_STATUS, "caclulating CRC32..");\r
+  if (size <= 0 || size > Pico.romsize) size = Pico.romsize;\r
+\r
+  // have to unbyteswap for calculation..\r
+  Byteswap(Pico.rom, Pico.rom, size);\r
+  crc = crc32(0, Pico.rom, size);\r
+  Byteswap(Pico.rom, Pico.rom, size);\r
+  return crc;\r
 }\r
 \r
 static int rom_strcmp(int rom_offset, const char *s1)\r
 {\r
   int i, len = strlen(s1);\r
 }\r
 \r
 static int rom_strcmp(int rom_offset, const char *s1)\r
 {\r
   int i, len = strlen(s1);\r
-  const char *s_rom = (const char *)Pico.rom + rom_offset;\r
+  const char *s_rom = (const char *)Pico.rom;\r
+  if (rom_offset + len > Pico.romsize)\r
+    return 0;\r
   for (i = 0; i < len; i++)\r
   for (i = 0; i < len; i++)\r
-    if (s1[i] != s_rom[i^1])\r
+    if (s1[i] != s_rom[MEM_BE2(i + rom_offset)])\r
       return 1;\r
   return 0;\r
 }\r
 \r
       return 1;\r
   return 0;\r
 }\r
 \r
-static int name_cmp(const char *name)\r
+static unsigned int rom_read32(int addr)\r
 {\r
 {\r
-  return rom_strcmp(0x150, name);\r
+  unsigned short *m = (unsigned short *)(Pico.rom + addr);\r
+  return (m[0] << 16) | m[1];\r
+}\r
+\r
+static char *sskip(char *s)\r
+{\r
+  while (*s && isspace_(*s))\r
+    s++;\r
+  return s;\r
+}\r
+\r
+static void rstrip(char *s)\r
+{\r
+  char *p;\r
+  for (p = s + strlen(s) - 1; p >= s; p--)\r
+    if (isspace_(*p))\r
+      *p = 0;\r
+}\r
+\r
+static int parse_3_vals(char *p, int *val0, int *val1, int *val2)\r
+{\r
+  char *r;\r
+  *val0 = strtoul(p, &r, 0);\r
+  if (r == p)\r
+    goto bad;\r
+  p = sskip(r);\r
+  if (*p++ != ',')\r
+    goto bad;\r
+  *val1 = strtoul(p, &r, 0);\r
+  if (r == p)\r
+    goto bad;\r
+  p = sskip(r);\r
+  if (*p++ != ',')\r
+    goto bad;\r
+  *val2 = strtoul(p, &r, 0);\r
+  if (r == p)\r
+    goto bad;\r
+\r
+  return 1;\r
+bad:\r
+  return 0;\r
+}\r
+\r
+static int is_expr(const char *expr, char **pr)\r
+{\r
+  int len = strlen(expr);\r
+  char *p = *pr;\r
+\r
+  if (strncmp(expr, p, len) != 0)\r
+    return 0;\r
+  p = sskip(p + len);\r
+  if (*p != '=')\r
+    return 0; // wrong or malformed\r
+\r
+  *pr = sskip(p + 1);\r
+  return 1;\r
+}\r
+\r
+#include "carthw_cfg.c"\r
+\r
+static void parse_carthw(const char *carthw_cfg, int *fill_sram,\r
+  int *hw_detected)\r
+{\r
+  int line = 0, any_checks_passed = 0, skip_sect = 0;\r
+  const char *s, *builtin = builtin_carthw_cfg;\r
+  int tmp, rom_crc = 0;\r
+  char buff[256], *p, *r;\r
+  FILE *f;\r
+\r
+  f = fopen(carthw_cfg, "r");\r
+  if (f == NULL)\r
+    f = fopen("pico/carthw.cfg", "r");\r
+  if (f == NULL)\r
+    elprintf(EL_STATUS, "couldn't open carthw.cfg!");\r
+\r
+  for (;;)\r
+  {\r
+    if (f != NULL) {\r
+      p = fgets(buff, sizeof(buff), f);\r
+      if (p == NULL)\r
+        break;\r
+    }\r
+    else {\r
+      if (*builtin == 0)\r
+        break;\r
+      for (s = builtin; *s != 0 && *s != '\n'; s++)\r
+        ;\r
+      while (*s == '\n')\r
+        s++;\r
+      tmp = s - builtin;\r
+      if (tmp > sizeof(buff) - 1)\r
+        tmp = sizeof(buff) - 1;\r
+      memcpy(buff, builtin, tmp);\r
+      buff[tmp] = 0;\r
+      p = buff;\r
+      builtin = s;\r
+    }\r
+\r
+    line++;\r
+    p = sskip(p);\r
+    if (*p == 0 || *p == '#')\r
+      continue;\r
+\r
+    if (*p == '[') {\r
+      any_checks_passed = 0;\r
+      skip_sect = 0;\r
+      continue;\r
+    }\r
+    \r
+    if (skip_sect)\r
+      continue;\r
+\r
+    /* look for checks */\r
+    if (is_expr("check_str", &p))\r
+    {\r
+      int offs;\r
+      offs = strtoul(p, &r, 0);\r
+      if (offs < 0 || offs > Pico.romsize) {\r
+        elprintf(EL_STATUS, "carthw:%d: check_str offs out of range: %d\n", line, offs);\r
+       goto bad;\r
+      }\r
+      p = sskip(r);\r
+      if (*p != ',')\r
+        goto bad;\r
+      p = sskip(p + 1);\r
+      if (*p != '"')\r
+        goto bad;\r
+      p++;\r
+      r = strchr(p, '"');\r
+      if (r == NULL)\r
+        goto bad;\r
+      *r = 0;\r
+\r
+      if (rom_strcmp(offs, p) == 0)\r
+        any_checks_passed = 1;\r
+      else\r
+        skip_sect = 1;\r
+      continue;\r
+    }\r
+    else if (is_expr("check_size_gt", &p))\r
+    {\r
+      int size;\r
+      size = strtoul(p, &r, 0);\r
+      if (r == p || size < 0)\r
+        goto bad;\r
+\r
+      if (Pico.romsize > size)\r
+        any_checks_passed = 1;\r
+      else\r
+        skip_sect = 1;\r
+      continue;\r
+    }\r
+    else if (is_expr("check_csum", &p))\r
+    {\r
+      int csum;\r
+      csum = strtoul(p, &r, 0);\r
+      if (r == p || (csum & 0xffff0000))\r
+        goto bad;\r
+\r
+      if (csum == (rom_read32(0x18c) & 0xffff))\r
+        any_checks_passed = 1;\r
+      else\r
+        skip_sect = 1;\r
+      continue;\r
+    }\r
+    else if (is_expr("check_crc32", &p))\r
+    {\r
+      unsigned int crc;\r
+      crc = strtoul(p, &r, 0);\r
+      if (r == p)\r
+        goto bad;\r
+\r
+      if (rom_crc == 0)\r
+        rom_crc = rom_crc32(64*1024);\r
+      if (crc == rom_crc)\r
+        any_checks_passed = 1;\r
+      else\r
+        skip_sect = 1;\r
+      continue;\r
+    }\r
+\r
+    /* now time for actions */\r
+    if (is_expr("hw", &p)) {\r
+      if (!any_checks_passed)\r
+        goto no_checks;\r
+      *hw_detected = 1;\r
+      rstrip(p);\r
+\r
+      if      (strcmp(p, "svp") == 0)\r
+        PicoIn.AHW = PAHW_SVP;\r
+      else if (strcmp(p, "pico") == 0)\r
+        PicoIn.AHW = PAHW_PICO;\r
+      else if (strcmp(p, "prot") == 0)\r
+        carthw_sprot_startup();\r
+      else if (strcmp(p, "ssf2_mapper") == 0)\r
+        carthw_ssf2_startup();\r
+      else if (strcmp(p, "x_in_1_mapper") == 0)\r
+        carthw_Xin1_startup();\r
+      else if (strcmp(p, "realtec_mapper") == 0)\r
+        carthw_realtec_startup();\r
+      else if (strcmp(p, "radica_mapper") == 0)\r
+        carthw_radica_startup();\r
+      else if (strcmp(p, "piersolar_mapper") == 0)\r
+        carthw_pier_startup();\r
+      else if (strcmp(p, "sf001_mapper") == 0)\r
+        carthw_sf001_startup();\r
+      else if (strcmp(p, "sf002_mapper") == 0)\r
+        carthw_sf002_startup();\r
+      else if (strcmp(p, "sf004_mapper") == 0)\r
+        carthw_sf004_startup();\r
+      else if (strcmp(p, "lk3_mapper") == 0)\r
+        carthw_lk3_startup();\r
+      else if (strcmp(p, "smw64_mapper") == 0)\r
+        carthw_smw64_startup();\r
+      else {\r
+        elprintf(EL_STATUS, "carthw:%d: unsupported mapper: %s", line, p);\r
+        skip_sect = 1;\r
+        *hw_detected = 0;\r
+      }\r
+      continue;\r
+    }\r
+    if (is_expr("sram_range", &p)) {\r
+      int start, end;\r
+\r
+      if (!any_checks_passed)\r
+        goto no_checks;\r
+      rstrip(p);\r
+\r
+      start = strtoul(p, &r, 0);\r
+      if (r == p)\r
+        goto bad;\r
+      p = sskip(r);\r
+      if (*p != ',')\r
+        goto bad;\r
+      p = sskip(p + 1);\r
+      end = strtoul(p, &r, 0);\r
+      if (r == p)\r
+        goto bad;\r
+      if (((start | end) & 0xff000000) || start > end) {\r
+        elprintf(EL_STATUS, "carthw:%d: bad sram_range: %08x - %08x", line, start, end);\r
+        goto bad_nomsg;\r
+      }\r
+      Pico.sv.start = start;\r
+      Pico.sv.end = end;\r
+      continue;\r
+    }\r
+    else if (is_expr("prop", &p)) {\r
+      if (!any_checks_passed)\r
+        goto no_checks;\r
+      rstrip(p);\r
+\r
+      if      (strcmp(p, "no_sram") == 0)\r
+        Pico.sv.flags &= ~SRF_ENABLED;\r
+      else if (strcmp(p, "no_eeprom") == 0)\r
+        Pico.sv.flags &= ~SRF_EEPROM;\r
+      else if (strcmp(p, "filled_sram") == 0)\r
+        *fill_sram = 1;\r
+      else if (strcmp(p, "wwfraw_hack") == 0)\r
+        PicoIn.quirks |= PQUIRK_WWFRAW_HACK;\r
+      else if (strcmp(p, "blackthorne_hack") == 0)\r
+        PicoIn.quirks |= PQUIRK_BLACKTHORNE_HACK;\r
+      else if (strcmp(p, "marscheck_hack") == 0)\r
+        PicoIn.quirks |= PQUIRK_MARSCHECK_HACK;\r
+      else if (strcmp(p, "force_6btn") == 0)\r
+        PicoIn.quirks |= PQUIRK_FORCE_6BTN;\r
+      else if (strcmp(p, "no_z80_bus_lock") == 0)\r
+        PicoIn.quirks |= PQUIRK_NO_Z80_BUS_LOCK;\r
+      else {\r
+        elprintf(EL_STATUS, "carthw:%d: unsupported prop: %s", line, p);\r
+        goto bad_nomsg;\r
+      }\r
+      elprintf(EL_STATUS, "game prop: %s", p);\r
+      continue;\r
+    }\r
+    else if (is_expr("eeprom_type", &p)) {\r
+      int type;\r
+      if (!any_checks_passed)\r
+        goto no_checks;\r
+      rstrip(p);\r
+\r
+      type = strtoul(p, &r, 0);\r
+      if (r == p || type < 0)\r
+        goto bad;\r
+      Pico.sv.eeprom_type = type;\r
+      Pico.sv.flags |= SRF_EEPROM;\r
+      continue;\r
+    }\r
+    else if (is_expr("eeprom_lines", &p)) {\r
+      int scl, sda_in, sda_out;\r
+      if (!any_checks_passed)\r
+        goto no_checks;\r
+      rstrip(p);\r
+\r
+      if (!parse_3_vals(p, &scl, &sda_in, &sda_out))\r
+        goto bad;\r
+      if (scl < 0 || scl > 15 || sda_in < 0 || sda_in > 15 ||\r
+          sda_out < 0 || sda_out > 15)\r
+        goto bad;\r
+\r
+      Pico.sv.eeprom_bit_cl = scl;\r
+      Pico.sv.eeprom_bit_in = sda_in;\r
+      Pico.sv.eeprom_bit_out= sda_out;\r
+      continue;\r
+    }\r
+    else if ((tmp = is_expr("prot_ro_value16", &p)) || is_expr("prot_rw_value16", &p)) {\r
+      int addr, mask, val;\r
+      if (!any_checks_passed)\r
+        goto no_checks;\r
+      rstrip(p);\r
+\r
+      if (!parse_3_vals(p, &addr, &mask, &val))\r
+        goto bad;\r
+\r
+      carthw_sprot_new_location(addr, mask, val, tmp ? 1 : 0);\r
+      continue;\r
+    }\r
+\r
+\r
+bad:\r
+    elprintf(EL_STATUS, "carthw:%d: unrecognized expression: %s", line, buff);\r
+bad_nomsg:\r
+    skip_sect = 1;\r
+    continue;\r
+\r
+no_checks:\r
+    elprintf(EL_STATUS, "carthw:%d: command without any checks before it: %s", line, buff);\r
+    skip_sect = 1;\r
+    continue;\r
+  }\r
+\r
+  if (f != NULL)\r
+    fclose(f);\r
 }\r
 \r
 /*\r
  * various cart-specific things, which can't be handled by generic code\r
 }\r
 \r
 /*\r
  * various cart-specific things, which can't be handled by generic code\r
- * (maybe I should start using CRC for this stuff?)\r
  */\r
  */\r
-static void PicoCartDetect(void)\r
+static void PicoCartDetect(const char *carthw_cfg)\r
 {\r
 {\r
-  int sram_size = 0, csum;\r
-  Pico.m.sram_reg = 0;\r
-\r
-  csum = PicoRead32(0x18c) & 0xffff;\r
+  int carthw_detected = 0;\r
+  int fill_sram = 0;\r
 \r
 \r
-  if (Pico.rom[0x1B1] == 'R' && Pico.rom[0x1B0] == 'A')\r
+  memset(&Pico.sv, 0, sizeof(Pico.sv));\r
+  if (Pico.rom[MEM_BE2(0x1B0)] == 'R' && Pico.rom[MEM_BE2(0x1B1)] == 'A')\r
   {\r
   {\r
-    if (Pico.rom[0x1B2] & 0x40)\r
-    {\r
+    Pico.sv.start =  rom_read32(0x1B4) & ~0xff000001; // align\r
+    Pico.sv.end   = (rom_read32(0x1B8) & ~0xff000000) | 1;\r
+    if (Pico.rom[MEM_BE2(0x1B3)] & 0x40)\r
       // EEPROM\r
       // EEPROM\r
-      SRam.start = PicoRead32(0x1B4) & ~1; // zero address is used for clock by some games\r
-      SRam.end   = PicoRead32(0x1B8);\r
-      sram_size  = 0x2000;\r
-      Pico.m.sram_reg |= 4;\r
-    } else {\r
-      // normal SRAM\r
-      SRam.start = PicoRead32(0x1B4) & ~0xff;\r
-      SRam.end   = PicoRead32(0x1B8) | 1;\r
-      sram_size  = SRam.end - SRam.start + 1;\r
-    }\r
-    SRam.start &= ~0xff000000;\r
-    SRam.end   &= ~0xff000000;\r
-    Pico.m.sram_reg |= 0x10; // SRAM was detected\r
-  }\r
-  if (sram_size <= 0)\r
+      Pico.sv.flags |= SRF_EEPROM;\r
+    Pico.sv.flags |= SRF_ENABLED;\r
+  }\r
+  if (Pico.sv.end == 0 || Pico.sv.start > Pico.sv.end)\r
   {\r
     // some games may have bad headers, like S&K and Sonic3\r
     // note: majority games use 0x200000 as starting address, but there are some which\r
     // use something else (0x300000 by HardBall '95). Luckily they have good headers.\r
   {\r
     // some games may have bad headers, like S&K and Sonic3\r
     // note: majority games use 0x200000 as starting address, but there are some which\r
     // use something else (0x300000 by HardBall '95). Luckily they have good headers.\r
-    SRam.start = 0x200000;\r
-    SRam.end   = 0x203FFF;\r
-    sram_size  = 0x004000;\r
+    Pico.sv.start = 0x200000;\r
+    Pico.sv.end   = 0x203FFF;\r
+    Pico.sv.flags |= SRF_ENABLED;\r
   }\r
 \r
   }\r
 \r
-  // this game actually doesn't have SRAM, but some weird protection\r
-  if (rom_strcmp(0x120, "PUGGSY") == 0)\r
-  {\r
-    SRam.start = SRam.end = sram_size = 0;\r
-  }\r
+  // set EEPROM defaults, in case it gets detected\r
+  Pico.sv.eeprom_type   = 0; // 7bit (24C01)\r
+  Pico.sv.eeprom_bit_cl = 1;\r
+  Pico.sv.eeprom_bit_in = 0;\r
+  Pico.sv.eeprom_bit_out= 0;\r
 \r
 \r
-  if (sram_size)\r
-  {\r
-    SRam.data = (unsigned char *) calloc(sram_size, 1);\r
-    if (SRam.data == NULL) return;\r
-  }\r
-  SRam.changed = 0;\r
+  if (carthw_cfg != NULL)\r
+    parse_carthw(carthw_cfg, &fill_sram, &carthw_detected);\r
 \r
 \r
-  // set EEPROM defaults, in case it gets detected\r
-  SRam.eeprom_type   = 0; // 7bit (24C01)\r
-  SRam.eeprom_abits  = 3; // eeprom access must be odd addr for: bit0 ~ cl, bit1 ~ in\r
-  SRam.eeprom_bit_cl = 1;\r
-  SRam.eeprom_bit_in = 0;\r
-  SRam.eeprom_bit_out= 0;\r
-\r
-  // some known EEPROM data (thanks to EkeEke)\r
-  if (name_cmp("COLLEGE SLAM") == 0 ||\r
-      name_cmp("FRANK THOMAS BIGHURT BASEBAL") == 0)\r
-  {\r
-    SRam.eeprom_type = 3;\r
-    SRam.eeprom_abits = 2;\r
-    SRam.eeprom_bit_cl = 0;\r
-  }\r
-  else if (name_cmp("NBA JAM TOURNAMENT EDITION") == 0 ||\r
-           name_cmp("NFL QUARTERBACK CLUB") == 0)\r
-  {\r
-    SRam.eeprom_type = 2;\r
-    SRam.eeprom_abits = 2;\r
-    SRam.eeprom_bit_cl = 0;\r
-  }\r
-  else if (name_cmp("NBA JAM") == 0)\r
-  {\r
-    SRam.eeprom_type = 2;\r
-    SRam.eeprom_bit_out = 1;\r
-    SRam.eeprom_abits = 0;\r
-  }\r
-  else if (name_cmp("NHLPA HOCKEY '93") == 0 ||\r
-           name_cmp("NHLPA Hockey '93") == 0 ||\r
-           name_cmp("RINGS OF POWER") == 0)\r
-  {\r
-    SRam.start = SRam.end = 0x200000;\r
-    Pico.m.sram_reg = 0x14;\r
-    SRam.eeprom_abits = 0;\r
-    SRam.eeprom_bit_cl = 6;\r
-    SRam.eeprom_bit_in = 7;\r
-    SRam.eeprom_bit_out= 7;\r
-  }\r
-  else if ( name_cmp("MICRO MACHINES II") == 0 ||\r
-           (name_cmp("        ") == 0 && // Micro Machines {Turbo Tournament '96, Military - It's a Blast!}\r
-           (csum == 0x165e || csum == 0x168b || csum == 0xCEE0 || csum == 0x2C41)))\r
-  {\r
-    SRam.start = 0x300000;\r
-    SRam.end   = 0x380001;\r
-    Pico.m.sram_reg = 0x14;\r
-    SRam.eeprom_type = 2;\r
-    SRam.eeprom_abits = 0;\r
-    SRam.eeprom_bit_cl = 1;\r
-    SRam.eeprom_bit_in = 0;\r
-    SRam.eeprom_bit_out= 7;\r
-  }\r
-\r
-  // SVP detection\r
-  else if (name_cmp("Virtua Racing") == 0 ||\r
-           name_cmp("VIRTUA RACING") == 0)\r
-  {\r
-    PicoSVPStartup();\r
-  }\r
+  // assume the standard mapper for large roms\r
+  if (!carthw_detected && Pico.romsize > 0x400000)\r
+    carthw_ssf2_startup();\r
 \r
 \r
-  // Pico\r
-  else if (rom_strcmp(0x100, "SEGA PICO") == 0 ||\r
-           rom_strcmp(0x100, "IMA IKUNOUJYUKU") == 0) // what is that supposed to mean?\r
+  if (Pico.sv.flags & SRF_ENABLED)\r
   {\r
   {\r
-    PicoInitPico();\r
-  }\r
+    if (Pico.sv.flags & SRF_EEPROM)\r
+      Pico.sv.size = 0x2000;\r
+    else\r
+      Pico.sv.size = Pico.sv.end - Pico.sv.start + 1;\r
 \r
 \r
-  // Detect 12-in-1 mapper\r
-  else if ((name_cmp("ROBOCOP 3") == 0 && Pico.romsize == 0x200000) ||\r
-    (rom_strcmp(0x160, "FLICKY") == 0 && Pico.romsize >= 0x200000)  ||\r
-    (name_cmp(" SHOVE IT!") == 0 && Pico.romsize >= 0x200000) ||\r
-    (name_cmp("MS PACMAN") == 0 && Pico.romsize >= 0x200000)) // bad dump?\r
-  {\r
-    carthw_12in1_startup();\r
-  }\r
+    Pico.sv.data = calloc(Pico.sv.size, 1);\r
+    if (Pico.sv.data == NULL)\r
+      Pico.sv.flags &= ~SRF_ENABLED;\r
 \r
 \r
-  // Realtec mapper\r
-  else if (Pico.romsize == 512*1024 && (\r
-    rom_strcmp(0x94, "THE EARTH DEFEND") == 0 ||\r
-    rom_strcmp(0xfe, "WISEGAME 11-03-1993") == 0 || // Funny World\r
-    rom_strcmp(0x95, "MALLET LEGEND ") == 0)) // Whac-A-Critter\r
-  {\r
-    carthw_realtec_startup();\r
+    if (Pico.sv.eeprom_type == 1)      // 1 == 0 in PD EEPROM code\r
+      Pico.sv.eeprom_type = 0;\r
   }\r
 \r
   }\r
 \r
-  // Radica mapper\r
-  else if (name_cmp("KID CHAMELEON") == 0 && Pico.romsize > 0x100000)\r
+  if ((Pico.sv.flags & SRF_ENABLED) && fill_sram)\r
   {\r
   {\r
-    carthw_radica_startup();\r
+    elprintf(EL_STATUS, "SRAM fill");\r
+    memset(Pico.sv.data, 0xff, Pico.sv.size);\r
   }\r
 \r
   }\r
 \r
-  // Some games malfunction if SRAM is not filled with 0xff\r
-  if (name_cmp("DINO DINI'S SOCCER") == 0 ||\r
-      name_cmp("MICRO MACHINES II") == 0)\r
-  {\r
-    memset(SRam.data, 0xff, sram_size);\r
+  // tweak for Blackthorne: master SH2 overwrites stack of slave SH2 being in PWM\r
+  // interrupt. On real hardware, nothing happens since slave fetches the values\r
+  // it has written from its cache, but picodrive doesn't emulate caching.\r
+  // move master memory area down by 0x100 bytes.\r
+  // XXX replace this abominable hack. It might cause other problems in the game!\r
+  if (PicoIn.quirks & PQUIRK_BLACKTHORNE_HACK) {\r
+    int i;\r
+    unsigned a = 0;\r
+    for (i = 0; i < Pico.romsize; i += 4) {\r
+      unsigned v = CPU_BE2(*(u32 *) (Pico.rom + i));\r
+      if (a && v == a + 0x400) { // patch if 2 pointers with offset 0x400 are found\r
+        elprintf(EL_STATUS, "auto-patching @%06x: %08x->%08x\n", i, v, v - 0x100);\r
+        *(u32 *) (Pico.rom + i) = CPU_BE2(v - 0x100);\r
+      }\r
+      // detect a pointer into the incriminating area\r
+      a = 0;\r
+      if (v >> 12 == 0x0603f000 >> 12 && !(v & 3))\r
+        a = v;\r
+    }\r
   }\r
 \r
   }\r
 \r
-  // Unusual region 'code'\r
-  if (rom_strcmp(0x1f0, "EUROPE") == 0 || rom_strcmp(0x1f0, "Europe") == 0)\r
-    *(int *) (Pico.rom+0x1f0) = 0x20204520;\r
+  // tweak for Mars Check Program: copies 32K longwords (128KB) from a 64KB buffer\r
+  // in ROM or DRAM to SDRAM with DMA in 4-longword mode, overwriting an SDRAM comm\r
+  // area in turn. This crashes the test on emulators without CPU cache emulation.\r
+  // This may be a bug in Mars Check, since it's only checking for the 64KB result.\r
+  // Patch the DMA transfers so that they transfer only 64KB.\r
+  if (PicoIn.quirks & PQUIRK_MARSCHECK_HACK) {\r
+    int i;\r
+    unsigned a = 0;\r
+    for (i = 0; i < Pico.romsize; i += 4) {\r
+      unsigned v = CPU_BE2(*(u32 *) (Pico.rom + i));\r
+      if (a == 0xffffff8c && v == 0x5ee1) { // patch if 4-long xfer written to CHCR\r
+        elprintf(EL_STATUS, "auto-patching @%06x: %08x->%08x\n", i, v, v & ~0x800);\r
+        *(u32 *) (Pico.rom + i) = CPU_BE2(v & ~0x800); // change to half-sized xfer\r
+      }\r
+      a = v;\r
+    }\r
+  }\r
 }\r
 \r
 }\r
 \r
+static void PicoCartDetectMS(void)\r
+{\r
+  memset(&Pico.sv, 0, sizeof(Pico.sv));\r
+\r
+  // Always map SRAM, since there's no indicator in ROM if it's needed or not\r
+  // TODO: this should somehow be coming from a cart database!\r
+\r
+  Pico.sv.size  = 0x8000; // Sega mapper, 2 banks of 16 KB each\r
+  Pico.sv.flags |= SRF_ENABLED;\r
+  Pico.sv.data = calloc(Pico.sv.size, 1);\r
+  if (Pico.sv.data == NULL)\r
+    Pico.sv.flags &= ~SRF_ENABLED;\r
+}\r
+// vim:shiftwidth=2:expandtab\r