Add compat with 82 Advanced Edition Python roms.

The device_type enum doesn't directly map to a cert field anymore and
since it is stored in the asic state, we increment IMAGE_VERSION.

Note that 82AEP pre-A ≈ CE M+, but with working SPI reads.

Also display more info parsed from the cert.

Author: adriweb

core/asic.c

@@ -88,7 +88,7 @@ static void plug_devices(void) {
     gui_console_printf("[CEmu] Initialized Advanced Peripheral Bus...\n");
 }
 
-static asic_rev_t report_reset(asic_rev_t loaded_rev, bool* python) {
+static asic_rev_t report_reset(asic_rev_t loaded_rev, emu_device_t device, bool* python) {
     /* Parse boot code routines to determine version. */
     asic_rev_t default_rev = ASIC_REV_A;
     boot_ver_t boot_ver;
@@ -99,7 +99,7 @@ static asic_rev_t report_reset(asic_rev_t loaded_rev, bool* python) {
 
         /* Determine the newest ASIC revision that is compatible */
         for (int rev = ASIC_REV_A; rev <= ASIC_REV_M; rev++) {
-            if (bootver_check_rev(&boot_ver, (asic_rev_t)rev)) {
+            if (bootver_check_rev(&boot_ver, (asic_rev_t)rev, device)) {
                 default_rev = rev;
             }
         }
@@ -114,13 +114,14 @@ static asic_rev_t report_reset(asic_rev_t loaded_rev, bool* python) {
     }
     gui_console_printf("[CEmu] Default ASIC revision is Rev %c.\n", "AIM"[(int)default_rev - 1]);
 
-    loaded_rev = gui_handle_reset((gotVer ? &boot_ver : NULL), loaded_rev, default_rev, python);
+    loaded_rev = gui_handle_reset((gotVer ? &boot_ver : NULL), loaded_rev, default_rev, device, python);
     return (loaded_rev != ASIC_REV_AUTO) ? loaded_rev : default_rev;
 }
 
 static void set_features() {
     asic.im2 = (asic.revision < ASIC_REV_I);
     asic.serFlash = (asic.revision >= ASIC_REV_M);
+    asic.hasWorkingSPIReads = (asic.device == TI82AEP);
 }
 
 void asic_init(void) {
@@ -148,19 +149,19 @@ void asic_reset(void) {
     /* Update the Python state first, so it can be read by the reset handler if needed */
     static const uint16_t path[] = { 0x0330, 0x0430 };
     asic.python = !cert_field_find_path(mem.flash.block + 0x3B0001, SIZE_FLASH_SECTOR_64K, path, 2, NULL, NULL);
-    asic.revision = report_reset(ASIC_REV_AUTO, &asic.python);
+    asic.revision = report_reset(ASIC_REV_AUTO, asic.device, &asic.python);
     set_features();
 
     for (unsigned int i = 0; i < reset_proc_count; i++) {
         reset_procs[i]();
     }
 }
 
-void set_device_type(ti_device_t device) {
+void set_device_type(emu_device_t device) {
     asic.device = device;
 }
 
-ti_device_t EMSCRIPTEN_KEEPALIVE get_device_type(void) {
+emu_device_t EMSCRIPTEN_KEEPALIVE get_device_type(void) {
     return asic.device;
 }
 
@@ -203,7 +204,7 @@ bool asic_restore(FILE *image) {
      && fgetc(image) == EOF)
     {
         bool python = asic.python;
-        (void)report_reset(asic.revision, &python);
+        (void)report_reset(asic.revision, asic.device, &python);
         return true;
     }
     return false;

core/asic.h

@@ -9,10 +9,12 @@ extern "C" {
 #include <stdint.h>
 #include <stdio.h>
 
+/* Note that this does not map a cert field */
 typedef enum {
     TI84PCE = 0,
-    TI83PCE = 1
-} ti_device_t;
+    TI83PCE = 1,
+    TI82AEP = 2
+} emu_device_t;
 
 typedef enum {
     ASIC_REV_AUTO = 0, /* Used only with set_asic_revision() */
@@ -22,13 +24,14 @@ typedef enum {
 } asic_rev_t;
 
 typedef struct asic_state {
-    ti_device_t device;
+    emu_device_t device;
     /* Only updated on reset */
     asic_rev_t revision;
     bool python;
     /* Populated based on revision */
     bool im2;
     bool serFlash;
+    bool hasWorkingSPIReads;
 } asic_state_t;
 
 extern asic_state_t asic;
@@ -39,8 +42,8 @@ void asic_reset(void);
 bool asic_restore(FILE *image);
 bool asic_save(FILE *image);
 void set_cpu_clock(uint32_t new_rate);
-void set_device_type(ti_device_t device);
-ti_device_t get_device_type(void);
+void set_device_type(emu_device_t device);
+emu_device_t get_device_type(void);
 asic_rev_t get_asic_revision(void);
 bool get_asic_python(void);
 

core/bootver.c

@@ -1,16 +1,18 @@
 #include "bootver.h"
 
-static const boot_ver_t asic_min_ver[] = {
-    { 5, 0, 0, 0 }, /* Rev A */
-    { 5, 0, 0, 0 }, /* Rev I */
-    { 5, 3, 6, 0 }, /* Rev M */
-};
-
-static const boot_ver_t asic_max_ver[] = {
-    {   5,   3,   5, 65535 }, /* Rev A */
-    {   5,   3,   5, 65535 }, /* Rev I */
-    { 255, 255, 255, 65535 }, /* Rev M */
-};
+static const boot_ver_t minRevA_CE = {   5,   0,   0,     0 }; /* Rev A */
+static const boot_ver_t minRevI_CE = {   5,   0,   0,     0 }; /* Rev I */
+static const boot_ver_t minRevM_CE = {   5,   3,   6,     0 }; /* Rev M */
+static const boot_ver_t minRevM_82 = {   5,   6,   3,     0 }; /* Rev pre-A of 82AEP, but otherwise the same JB-007 ASIC as M on CE */
+static const boot_ver_t maxRevA_CE = {   5,   3,   5, 65535 }; /* Rev A */
+static const boot_ver_t maxRevI_CE = {   5,   3,   5, 65535 }; /* Rev I */
+static const boot_ver_t maxRev     = { 255, 255, 255, 65535 }; /* Rev M */
+
+/* NULL means unsupported */
+static const boot_ver_t* asic_min_ver_8384CE[] = { &minRevA_CE, &minRevI_CE, &minRevM_CE };
+static const boot_ver_t* asic_max_ver_8384CE[] = { &maxRevA_CE, &maxRevI_CE, &maxRev };
+static const boot_ver_t* asic_min_ver_82AEP[]  = { NULL,        NULL,        &minRevM_82 };
+static const boot_ver_t* asic_max_ver_82AEP[]  = { NULL,        NULL,        &maxRev };
 
 static bool parse_entry(const uint8_t* data, uint32_t entry, uint32_t* addr) {
     if (entry + 4 >= SIZE_BOOTCODE) {
@@ -98,6 +100,9 @@ bool bootver_parse(const uint8_t* data, boot_ver_t* boot_ver) {
 }
 
 bool bootver_check_ver(const boot_ver_t* ver, const boot_ver_t* check) {
+    if (!ver || !check) {
+        return false;
+    }
     if (ver->major != check->major) {
         return ver->major > check->major;
     }
@@ -110,16 +115,19 @@ bool bootver_check_ver(const boot_ver_t* ver, const boot_ver_t* check) {
     return ver->build >= check->build;
 }
 
-bool bootver_check_rev(const boot_ver_t* ver, asic_rev_t rev) {
+bool bootver_check_rev(const boot_ver_t* ver, asic_rev_t rev, emu_device_t device) {
     unsigned int index = (unsigned int)rev - 1;
-    if (index >= sizeof(asic_min_ver) / sizeof(boot_ver_t)) {
+    if (((device == TI83PCE || device == TI84PCE) && index >= sizeof(asic_min_ver_8384CE) / sizeof(boot_ver_t*)) ||
+        ((device == TI82AEP)                      && index >= sizeof(asic_min_ver_82AEP)  / sizeof(boot_ver_t*))) {
         return false;
     }
 
     if (!ver) {
         return true;
     }
 
-    return bootver_check_ver(ver, asic_min_ver + index)
-        && bootver_check_ver(asic_max_ver + index, ver);
+    const boot_ver_t** asic_min_ver = (device == TI83PCE || device == TI84PCE) ? asic_min_ver_8384CE : asic_min_ver_82AEP;
+    const boot_ver_t** asic_max_ver = (device == TI83PCE || device == TI84PCE) ? asic_max_ver_8384CE : asic_max_ver_82AEP;
+    return bootver_check_ver(ver, asic_min_ver[index])
+        && bootver_check_ver(asic_max_ver[index], ver);
 }

core/bootver.h

@@ -24,7 +24,7 @@ extern "C" {
 
     bool bootver_check_ver(const boot_ver_t* ver, const boot_ver_t* check);
 
-    bool bootver_check_rev(const boot_ver_t* ver, asic_rev_t rev);
+    bool bootver_check_rev(const boot_ver_t* ver, asic_rev_t rev, emu_device_t device);
 
 #ifdef __cplusplus
 }

core/control.c

@@ -29,7 +29,7 @@ static uint8_t control_read(const uint16_t pio, bool peek) {
             value = control.readBatteryStatus;
             break;
         case 0x03:
-            value = get_device_type() | asic.serFlash << 4;
+            value = (get_device_type() == TI84PCE ? 0 : 1) | asic.serFlash << 4;
             break;
         case 0x06:
             value = control.protectedPortsUnlocked;

core/emu.c

@@ -18,7 +18,7 @@
 #include <emscripten.h>
 #endif
 
-#define IMAGE_VERSION 0xCECE001A
+#define IMAGE_VERSION 0xCECE001B
 
 void EMSCRIPTEN_KEEPALIVE emu_exit(void) {
     cpu_set_signal(CPU_SIGNAL_EXIT);
@@ -100,7 +100,7 @@ emu_state_t emu_load(emu_data_t type, const char *path) {
         const uint8_t *data;
         uint32_t outer_field_size;
         uint32_t data_field_size;
-        ti_device_t device_type = TI84PCE;
+        emu_device_t device_type = TI84PCE;
         uint32_t offset;
         size_t size;
 
@@ -139,7 +139,8 @@ emu_state_t emu_load(emu_data_t type, const char *path) {
 
             /* Inner 0x801(0) field: calculator model */
             if (cert_field_get(outer, outer_field_size, &field_type, &data, &data_field_size)) break;
-            if (field_type != 0x8012 || data[0] != 0x13) break;
+            if (field_type != 0x8012 || (data[0] != 0x13 && data[0] != 0x15)) break;
+            const enum { MODEL_8384CE=0x13, MODEL_82AEP=0x15 } model_id = data[0];
 
             /* Inner 0x802(0) field: skip. */
             data_field_size = outer_field_size - (data + data_field_size - outer);
@@ -174,10 +175,24 @@ emu_state_t emu_load(emu_data_t type, const char *path) {
             if (field_type != 0x80C2) break;
 
             if (data[1] != 0 && data[1] != 1) break;
-            device_type = (ti_device_t)(data[1]);
-
-            /* If we come here, we've found something. */
-            gotType = true;
+            const enum { DEVICE_84PCE=0, DEVICE_83PCE=1 } device_id = data[1];
+
+            gui_console_printf("[CEmu] Info from cert: Device type = 0x%02X (%s). Model = 0x%02X (%s).\n",
+                               device_id, (device_id == DEVICE_84PCE) ? "84+CE-like" : "83PCE-like",
+                               model_id, (model_id == MODEL_8384CE) ? "CE" : "82AEP");
+
+            if (model_id == MODEL_82AEP && device_id == DEVICE_83PCE) {
+                device_type = TI82AEP;
+                gotType = true;
+            } else if (model_id == MODEL_8384CE && device_id == DEVICE_84PCE) {
+                device_type = TI84PCE;
+                gotType = true;
+            } else if (model_id == MODEL_8384CE && device_id == DEVICE_83PCE) {
+                device_type = TI83PCE;
+                gotType = true;
+            } else {
+                gui_console_err_printf("[CEmu] Got model<->device discrepency!?\n");
+            }
 
             gui_console_printf("[CEmu] Loaded ROM Image.\n");
             break;

core/emu.h

@@ -45,10 +45,11 @@ void gui_console_err_printf(const char *format, ...);     /* printf from the cor
  *   boot_ver: boot code version if found, else NULL
  *   loaded_rev: ASIC_REV_AUTO on reset, or loaded revision on state load
  *   default_rev: default revision to use when returning ASIC_REV_AUTO
+ *   device: which device we're actually emulating
  *   python: determined edition based on certificate, can be overridden by updating its value
  * returns:
  *   hardware revision to use; ignored when loading state */
-asic_rev_t gui_handle_reset(const boot_ver_t* boot_ver, asic_rev_t loaded_rev, asic_rev_t default_rev, bool* python);
+asic_rev_t gui_handle_reset(const boot_ver_t* boot_ver, asic_rev_t loaded_rev, asic_rev_t default_rev, emu_device_t device, bool* python);
 
 #ifdef DEBUG_SUPPORT
 void gui_debug_open(int reason, uint32_t data);           /* open the gui debugger */

core/spi.c

@@ -160,6 +160,7 @@ static void spi_update(void) {
 }
 
 /* Read from the SPI range of ports */
+/* TODO: something with asic.hasWorkingSPIReads probably */
 static uint8_t spi_read(uint16_t addr, bool peek) {
     static const uint16_t cr0_masks[16] = {
         0xF18C, 0xF8EF, 0xF0AC, 0xF3FC, 0xF18C, 0xF4C0, 0xF3AC, 0xF3AC,

gui/qt/emuthread.cpp

@@ -48,8 +48,8 @@ void gui_debug_close(void) {
     emu->debugDisable();
 }
 
-asic_rev_t gui_handle_reset(const boot_ver_t* boot_ver, asic_rev_t loaded_rev, asic_rev_t default_rev, bool* python) {
-    return emu->handleReset(boot_ver, loaded_rev, default_rev, python);
+asic_rev_t gui_handle_reset(const boot_ver_t* boot_ver, asic_rev_t loaded_rev, asic_rev_t default_rev, emu_device_t device, bool* python) {
+    return emu->handleReset(boot_ver, loaded_rev, default_rev, device, python);
 }
 
 namespace {
@@ -279,12 +279,12 @@ void EmuThread::unblock() {
     m_mutex.unlock();
 }
 
-asic_rev_t EmuThread::handleReset(const boot_ver_t* bootVer, asic_rev_t loadedRev, asic_rev_t defaultRev, bool* python) {
+asic_rev_t EmuThread::handleReset(const boot_ver_t* bootVer, asic_rev_t loadedRev, asic_rev_t defaultRev, emu_device_t device, bool* python) {
     // Build a list of supported revisions
     QList<int> supportedRevs;
     supportedRevs.reserve(ASIC_REV_M - ASIC_REV_A + 1);
     for (int rev = ASIC_REV_A; rev <= ASIC_REV_M; rev++) {
-        if (bootver_check_rev(bootVer, (asic_rev_t)rev)) {
+        if (bootver_check_rev(bootVer, (asic_rev_t)rev, device)) {
             supportedRevs.push_back(rev);
         }
     }

gui/qt/emuthread.h

@@ -38,7 +38,7 @@ class EmuThread : public QThread {
     void setAsicRev(int rev);
     void setAllowAnyRev(bool allow);
     void setForcePython(Qt::CheckState state);
-    asic_rev_t handleReset(const boot_ver_t* bootVer, asic_rev_t loadedRev, asic_rev_t defaultRev, bool* python);
+    asic_rev_t handleReset(const boot_ver_t* bootVer, asic_rev_t loadedRev, asic_rev_t defaultRev, emu_device_t device, bool* python);
     void writeConsole(int console, const char *format, va_list args);
     void debugOpen(int reason, uint32_t addr);
     void save(emu_data_t fileType, const QString &filePath);