pico6502 Guida per Sviluppatori

English

Panoramica

• M6502CPU.c / M6502CPU.h sostituiscono Z80CPU.c / Z80CPU.h come file principali di dispatch e framework driver.
• Il 6502 non ha uno spazio di indirizzamento I/O separato — non c'e un array ioPtr[] e nessuna sezione JSON iomap. Tutte le periferiche sono virtualizzate come blocchi tipo FUNC nella mappa di memoria da 64 KB.
• L'interfaccia bus PIO (M6502.pio) implementa il clock bifase PHI1/PHI2 anziche il modello a clock singolo dello Z80.
• La directory target di compilazione e BaseM6502 anziche BaseZ80.
• La chiave della sezione CPU JSON e "6502" anziche "z80".

Albero dei sorgenti

tzpuPico/
├── CMakeLists.txt                          File di compilazione di livello superiore
├── src/
│   ├── CMakeLists.txt                      File di compilazione a livello sorgente — aggiungere nuovi file driver qui
│   ├── M6502CPU.c                          *** FILE CHIAVE: dispatch 6502, framework driver, virtualFuncMap
│   ├── M6502CPU.h                          (legacy — incluso via include/)
│   ├── M6502.c                             Inizializzazione PIO e punti di ingresso cicli bus
│   ├── M6502.pio                           Programmi PIO: clock, addr, data, cycle, fetch, read, write, irq, nmi, so
│   ├── Z80CPU.c / Z80CPU.h                 Controparte Z80 (non usata per le compilazioni pico6502)
│   ├── FSPI.c / FSPI.h                     Interfaccia Flash SPI (condivisa)
│   ├── ESP.c / ESP.h                       Livello comunicazione ESP32 (condiviso)
│   ├── psram.c / psram.h                   Allocazione e gestione PSRAM (condivisa)
│   ├── cJSON.c / cJSON.h                   Parser JSON per config.json (condiviso)
│   ├── include/
│   │   ├── M6502CPU.h                      *** FILE CHIAVE: tutte le definizioni tipo e macro 6502
│   │   ├── M6502.h                         Definizioni helper PIO
│   │   └── drivers/
│   │       └── BBC/
│   │           └── ModelB.h               Header driver BBC Model B (segnaposto iniziale)
│   ├── drivers/
│   │   └── BBC/
│   │       └── ModelB.c                   *** DRIVER ESEMPIO/SEGNAPOSTO (persona BBC Model B)
│   └── model/
│       ├── BaseM6502/
│       │   ├── CMakeLists.txt             Target compilazione per modello
│       │   ├── main.c                     Punto di ingresso (lancio Core 0 + Core 1)
│       │   ├── main_memmap_partition_1.ld Script linker per Slot 1
│       │   └── main_memmap_partition_2.ld Script linker per Slot 2
│       └── Bootloader/
│           ├── CMakeLists.txt
│           └── main.c                     Bootloader condiviso (stesso del picoZ80)
└── esp32/
    ├── CMakeLists.txt
    └── main/
        └── ...                            Firmware ESP32 (condiviso con picoZ80)

Differenze chiave dal picoZ80

Nessuno spazio I/O separato

Struct t_6502PSRAM

// src/include/M6502CPU.h (semplificato)
typedef struct {
    uint8_t      RAM[MAX_MEMORY_BANKS * MEMORY_PAGE_SIZE]; // 64 banchi x 64 KB = 4 MB area RAM/ROM
    MemoryFunc   memPtr[MEMORY_PAGE_SIZE];                  // 64K reindirizzamento lettura per byte (tipo PTR)
    MemoryFunc   memioPtr[MEMORY_PAGE_SIZE];                // 64K array handler mappati memoria (tipo FUNC)
    // NOTA: nessun ioPtr[] — il 6502 non ha spazio I/O separato
} t_6502PSRAM;

Firma della funzione handler

// Handler chiamato per i blocchi MEMBANK_TYPE_FUNC ad ogni accesso
typedef uint8_t (*MemoryFunc)(M6502CPU *cpu, bool read, uint16_t addr, uint8_t data);

// Parametri:
//   cpu  — puntatore alla struct M6502CPU (accesso PSRAM, stato, code tramite questo)
//   read — true per ciclo lettura 6502 (RNW=1), false per ciclo scrittura (RNW=0)
//   addr — indirizzo 16 bit che ha attivato questo handler
//   data — byte scritto (significativo solo quando read=false)
// Ritorno:
//   byte da posizionare sul bus dati (significativo solo quando read=true)

Framework driver

Scrivere un nuovo driver

1. Creare un file header in src/include/drivers/<Family>/MyDriver.h
2. Creare un file di implementazione in src/drivers/<Family>/MyDriver.c
3. Aggiungere il file sorgente a src/CMakeLists.txt
4. Includere il driver in M6502CPU.c sotto una guardia #ifdef INCLUDE_<FAMILY>_DRIVERS
5. Registrare il driver in virtualFuncMap[] in M6502CPU.c
6. Aggiungere una voce driver JSON in config.json

Template driver minimo

// src/include/drivers/BBC/VIA6522.h
#ifndef VIA6522_H
#define VIA6522_H

#include "M6502CPU.h"

int VIA6522_Init(M6502CPU *cpu, t_drvConfig *drvConfig, int pass);

#endif

// src/drivers/BBC/VIA6522.c
#include "../../include/M6502CPU.h"
#include "../../include/drivers/BBC/VIA6522.h"

// --- Stato interno ---
typedef struct {
    uint8_t  regs[16];      // Registri interni VIA (ORB, ORA, DDRB, DDRA, T1CL, T1CH, ...)
    bool     irqPending;
} t_VIA6522State;

static t_VIA6522State ViaState = { .irqPending = false };

// --- Handler memoria (chiamato per ogni accesso a 0xC000–0xC00F) ---
static uint8_t VIA6522_Handler(M6502CPU *cpu, bool read, uint16_t addr, uint8_t data)
{
    uint8_t reg = addr & 0x0F;

    if(read)
    {
        return ViaState.regs[reg];
    }
    else
    {
        ViaState.regs[reg] = data;
        return 0;
    }
}

// --- Handler reset ---
static uint8_t VIA6522_Reset(M6502CPU *cpu)
{
    memset(&ViaState.regs, 0, sizeof(ViaState.regs));
    ViaState.irqPending = false;
    return 0;
}

// --- Funzione init ---
int VIA6522_Init(M6502CPU *cpu, t_drvConfig *drvConfig, int pass)
{
    if(pass == 0)
    {
        return (strcasecmp(drvConfig->name, "via6522") == 0) ? 1 : 0;
    }

    for(uint16_t addr = 0xC000; addr <= 0xC00F; addr++)
    {
        cpu->_6502PSRAM->memioPtr[addr] = VIA6522_Handler;
    }

    cpu->reset_ptr = VIA6522_Reset;

    debugf("VIA6522: Inizializzato a 0xC000–0xC00F\n");
    return 1;
}

Pattern hook memoria

Errori comuni

Siti di riferimento

Avviso normativo wireless