git.sesse.net Git - pistorm/blob - platforms/amiga/pistorm-dev/pistorm-dev.c

   1 // SPDX-License-Identifier: MIT
   2
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6
   7 #include "pistorm-dev.h"
   8 #include "pistorm-dev-enums.h"
   9 #include "platforms/platforms.h"
  10 #include "gpio/ps_protocol.h"
  11 #include "platforms/amiga/rtg/rtg.h"
  12 #include "platforms/amiga/piscsi/piscsi.h"
  13 #include "platforms/amiga/net/pi-net.h"
  14
  15 #define DEBUG_PISTORM_DEVICE
  16
  17 #ifdef DEBUG_PISTORM_DEVICE
  18 #define DEBUG printf
  19
  20 #define PIDEV_SWREV 0x0105
  21
  22 static const char *op_type_names[4] = {
  23     "BYTE",
  24     "WORD",
  25     "LONGWORD",
  26     "MEM",
  27 };
  28 #else
  29 #define DEBUG(...)
  30 #endif
  31
  32 extern uint32_t pistorm_dev_base;
  33 extern uint32_t do_reset;
  34
  35 extern void adjust_ranges_amiga(struct emulator_config *cfg);
  36 extern uint8_t rtg_enabled, rtg_on, pinet_enabled, piscsi_enabled, load_new_config;
  37 extern struct emulator_config *cfg;
  38
  39 char cfg_filename[256] = "default.cfg";
  40 char tmp_string[256];
  41
  42 static uint8_t pi_byte[8];
  43 static uint16_t pi_word[4];
  44 static uint32_t pi_longword[4];
  45 static uint32_t pi_string[4];
  46
  47 static uint32_t pi_dbg_val[4];
  48 static uint32_t pi_dbg_string[4];
  49
  50 static uint32_t pi_cmd_result = 0;
  51
  52 int32_t grab_amiga_string(uint32_t addr, uint8_t *dest, uint32_t str_max_len) {
  53     int32_t r = get_mapped_item_by_address(cfg, addr);
  54     uint32_t index = 0;
  55
  56     if (r == -1) {
  57         DEBUG("[GRAB_AMIGA_STRING] No mapped range found for address $%.8X. Grabbing string data over the bus.\n", addr);
  58         do {
  59             dest[index] = read8(addr + index);
  60             index++;
  61         } while (dest[index - 1] != 0x00 && index < str_max_len);
  62     }
  63     else {
  64         uint8_t *src = cfg->map_data[r] + (addr - cfg->map_offset[r]);
  65         do {
  66             dest[index] = src[index];
  67             index++;
  68         } while (dest[index - 1] != 0x00 && index < str_max_len);
  69     }
  70     if (index == str_max_len) {
  71         memset(dest, 0x00, str_max_len + 1);
  72         return -1;
  73     }
  74     DEBUG("[GRAB_AMIGA_STRING] Grabbed string: %s\n", dest);
  75     return (int32_t)strlen((const char*)dest);
  76 }
  77
  78 char *get_pistorm_devcfg_filename() {
  79     return cfg_filename;
  80 }
  81
  82 void set_pistorm_devcfg_filename(char *filename) {
  83     strcpy(cfg_filename, filename);
  84 }
  85
  86 void handle_pistorm_dev_write(uint32_t addr_, uint32_t val, uint8_t type) {
  87     uint32_t addr = (addr_ & 0xFFFF);
  88
  89     switch((addr)) {
  90         case PI_DBG_MSG:
  91             // Output debug message based on value written and data in val/str registers.
  92             break;
  93         case PI_DBG_VAL1: case PI_DBG_VAL2: case PI_DBG_VAL3: case PI_DBG_VAL4:
  94         case PI_DBG_VAL5: case PI_DBG_VAL6: case PI_DBG_VAL7: case PI_DBG_VAL8:
  95             DEBUG("[PISTORM-DEV] Set DEBUG VALUE %d to %d ($%.8X)\n", (addr - PI_DBG_VAL1) / 4, val, val);
  96             pi_dbg_val[(addr - PI_DBG_VAL1) / 4] = val;
  97             break;
  98         case PI_DBG_STR1: case PI_DBG_STR2: case PI_DBG_STR3: case PI_DBG_STR4:
  99             DEBUG("[PISTORM-DEV] Set DEBUG STRING POINTER %d to $%.8X\n", (addr - PI_DBG_STR1) / 4, val);
 100             pi_dbg_string[(addr - PI_DBG_STR1) / 4] = val;
 101             break;
 102
 103         case PI_BYTE1: case PI_BYTE2: case PI_BYTE3: case PI_BYTE4:
 104         case PI_BYTE5: case PI_BYTE6: case PI_BYTE7: case PI_BYTE8:
 105             DEBUG("[PISTORM-DEV] Set BYTE %d to %d ($%.2X)\n", addr - PI_BYTE1, (val & 0xFF), (val & 0xFF));
 106             pi_byte[addr - PI_BYTE1] = (val & 0xFF);
 107             break;
 108         case PI_WORD1: case PI_WORD2: case PI_WORD3: case PI_WORD4:
 109             DEBUG("[PISTORM-DEV] Set WORD %d to %d ($%.4X)\n", (addr - PI_WORD1) / 2, (val & 0xFFFF), (val & 0xFFFF));
 110             pi_word[(addr - PI_WORD1) / 2] = (val & 0xFFFF);
 111             break;
 112         case PI_LONGWORD1: case PI_LONGWORD2: case PI_LONGWORD3: case PI_LONGWORD4:
 113             DEBUG("[PISTORM-DEV] Set LONGWORD %d to %d ($%.8X)\n", (addr - PI_LONGWORD1) / 4, val, val);
 114             pi_longword[(addr - PI_LONGWORD1) / 4] = val;
 115             break;
 116         case PI_STR1: case PI_STR2: case PI_STR3: case PI_STR4:
 117             DEBUG("[PISTORM-DEV] Set STRING POINTER %d to $%.8X\n", (addr - PI_STR1) / 4, val);
 118             pi_string[(addr - PI_STR1) / 4] = val;
 119             break;
 120
 121         case PI_CMD_RTGSTATUS:
 122             DEBUG("[PISTORM-DEV] Write to RTGSTATUS: %d\n", val);
 123             if (val == 1 && !rtg_enabled) {
 124                 init_rtg_data();
 125                 rtg_enabled = 1;
 126                 pi_cmd_result = PI_RES_OK;
 127             } else if (val == 0 && rtg_enabled) {
 128                 if (!rtg_on) {
 129                     shutdown_rtg();
 130                     rtg_enabled = 0;
 131                     pi_cmd_result = PI_RES_OK;
 132                 } else {
 133                     // Refuse to disable RTG if it's currently in use.
 134                     pi_cmd_result = PI_RES_FAILED;
 135                 }
 136             } else {
 137                 pi_cmd_result = PI_RES_NOCHANGE;
 138             }
 139             adjust_ranges_amiga(cfg);
 140             break;
 141         case PI_CMD_NETSTATUS:
 142             DEBUG("[PISTORM-DEV] Write to NETSTATUS: %d\n", val);
 143             if (val == 1 && !pinet_enabled) {
 144                 pinet_init(NULL);
 145                 pinet_enabled = 1;
 146                 pi_cmd_result = PI_RES_OK;
 147             } else if (val == 0 && pinet_enabled) {
 148                 pinet_shutdown();
 149                 pinet_enabled = 0;
 150                 pi_cmd_result = PI_RES_OK;
 151             } else {
 152                 pi_cmd_result = PI_RES_NOCHANGE;
 153             }
 154             adjust_ranges_amiga(cfg);
 155             break;
 156         case PI_CMD_PISCSI_CTRL:
 157             DEBUG("[PISTORM-DEV] Write to PISCSI_CTRL: ");
 158             switch(val) {
 159                 case PISCSI_CTRL_DISABLE:
 160                     DEBUG("DISABLE\n");
 161                     if (piscsi_enabled) {
 162                         piscsi_shutdown();
 163                         piscsi_enabled = 0;
 164                         // Probably not OK... depends on if you booted from floppy, I guess.
 165                         pi_cmd_result = PI_RES_OK;
 166                     } else {
 167                         pi_cmd_result = PI_RES_NOCHANGE;
 168                     }
 169                     break;
 170                 case PISCSI_CTRL_ENABLE:
 171                     DEBUG("ENABLE\n");
 172                     if (!piscsi_enabled) {
 173                         piscsi_init();
 174                         piscsi_enabled = 1;
 175                         piscsi_refresh_drives();
 176                         pi_cmd_result = PI_RES_OK;
 177                     } else {
 178                         pi_cmd_result = PI_RES_NOCHANGE;
 179                     }
 180                     break;
 181                 case PISCSI_CTRL_MAP:
 182                     DEBUG("MAP\n");
 183                     if (pi_string[0] == 0 || grab_amiga_string(pi_string[0], (uint8_t *)tmp_string, 255) == -1)  {
 184                         printf("[PISTORM-DEV] Failed to grab string for PISCSI drive filename. Aborting.\n");
 185                         pi_cmd_result = PI_RES_FAILED;
 186                     } else {
 187                         FILE *tmp = fopen(tmp_string, "rb");
 188                         if (tmp == NULL) {
 189                             printf("[PISTORM-DEV] Failed to open file %s for PISCSI drive mapping. Aborting.\n", cfg_filename);
 190                             pi_cmd_result = PI_RES_FILENOTFOUND;
 191                         } else {
 192                             fclose(tmp);
 193                             printf("[PISTORM-DEV] Attempting to map file %s as PISCSI drive %d...\n", cfg_filename, pi_word[0]);
 194                             piscsi_unmap_drive(pi_word[0]);
 195                             piscsi_map_drive(tmp_string, pi_word[0]);
 196                             pi_cmd_result = PI_RES_OK;
 197                         }
 198                     }
 199                     pi_string[0] = 0;
 200                     break;
 201                 case PISCSI_CTRL_UNMAP:
 202                     DEBUG("UNMAP\n");
 203                     if (pi_word[0] > 7) {
 204                         printf("[PISTORM-DEV] Invalid drive ID %d for PISCSI unmap command.", pi_word[0]);
 205                         pi_cmd_result = PI_RES_INVALIDVALUE;
 206                     } else {
 207                         if (piscsi_get_dev(pi_word[0])->fd != -1) {
 208                             piscsi_unmap_drive(pi_word[0]);
 209                             pi_cmd_result = PI_RES_OK;
 210                         } else {
 211                             pi_cmd_result = PI_RES_NOCHANGE;
 212                         }
 213                     }
 214                     break;
 215                 case PISCSI_CTRL_EJECT:
 216                     DEBUG("EJECT (NYI)\n");
 217                     pi_cmd_result = PI_RES_NOCHANGE;
 218                     break;
 219                 case PISCSI_CTRL_INSERT:
 220                     DEBUG("INSERT (NYI)\n");
 221                     pi_cmd_result = PI_RES_NOCHANGE;
 222                     break;
 223                 default:
 224                     DEBUG("UNKNOWN/UNHANDLED. Aborting.\n");
 225                     pi_cmd_result = PI_RES_INVALIDVALUE;
 226                     break;
 227             }
 228             adjust_ranges_amiga(cfg);
 229             break;
 230
 231         case PI_CMD_KICKROM:
 232             DEBUG("[PISTORM-DEV] Write to KICKROM.\n");
 233             if (pi_string[0] == 0 || grab_amiga_string(pi_string[0], (uint8_t *)tmp_string, 255) == -1)  {
 234                 printf("[PISTORM-DEV] Failed to grab string KICKROM filename. Aborting.\n");
 235                 pi_cmd_result = PI_RES_FAILED;
 236             } else {
 237                 FILE *tmp = fopen(tmp_string, "rb");
 238                 if (tmp == NULL) {
 239                     printf("[PISTORM-DEV] Failed to open file %s for KICKROM mapping. Aborting.\n", cfg_filename);
 240                     pi_cmd_result = PI_RES_FILENOTFOUND;
 241                 } else {
 242                     fclose(tmp);
 243                     if (get_named_mapped_item(cfg, "kickstart") != -1) {
 244                         uint32_t index = get_named_mapped_item(cfg, "kickstart");
 245                         free(cfg->map_data[index]);
 246                         free(cfg->map_id[index]);
 247                         cfg->map_type[index] = MAPTYPE_NONE;
 248                         // Dirty hack, I am sleepy and lazy.
 249                         add_mapping(cfg, MAPTYPE_ROM, cfg->map_offset[index], cfg->map_size[index], 0, tmp_string, "kickstart");
 250                         pi_cmd_result = PI_RES_OK;
 251                         do_reset = 1;
 252                     } else {
 253                         printf ("[PISTORM-DEV] Could not find mapped range 'kickstart', cannot remap KICKROM.\n");
 254                         pi_cmd_result = PI_RES_FAILED;
 255                     }
 256                 }
 257             }
 258             adjust_ranges_amiga(cfg);
 259             pi_string[0] = 0;
 260             break;
 261         case PI_CMD_EXTROM:
 262             DEBUG("[PISTORM-DEV] Write to EXTROM.\n");
 263             if (pi_string[0] == 0 || grab_amiga_string(pi_string[0], (uint8_t *)tmp_string, 255) == -1)  {
 264                 printf("[PISTORM-DEV] Failed to grab string EXTROM filename. Aborting.\n");
 265                 pi_cmd_result = PI_RES_FAILED;
 266             } else {
 267                 FILE *tmp = fopen(tmp_string, "rb");
 268                 if (tmp == NULL) {
 269                     printf("[PISTORM-DEV] Failed to open file %s for EXTROM mapping. Aborting.\n", cfg_filename);
 270                     pi_cmd_result = PI_RES_FILENOTFOUND;
 271                 } else {
 272                     fclose(tmp);
 273                     if (get_named_mapped_item(cfg, "extended") != -1) {
 274                         uint32_t index = get_named_mapped_item(cfg, "extended");
 275                         free(cfg->map_data[index]);
 276                         free(cfg->map_id[index]);
 277                         cfg->map_type[index] = MAPTYPE_NONE;
 278                         // Dirty hack, I am tired and lazy.
 279                         add_mapping(cfg, MAPTYPE_ROM, cfg->map_offset[index], cfg->map_size[index], 0, tmp_string, "extended");
 280                         pi_cmd_result = PI_RES_OK;
 281                         do_reset = 1;
 282                     } else {
 283                         printf ("[PISTORM-DEV] Could not find mapped range 'extrom', cannot remap EXTROM.\n");
 284                         pi_cmd_result = PI_RES_FAILED;
 285                     }
 286                 }
 287             }
 288             adjust_ranges_amiga(cfg);
 289             pi_string[0] = 0;
 290             break;
 291
 292         case PI_CMD_RESET:
 293             DEBUG("[PISTORM-DEV] System reset called, code %d\n", (val & 0xFFFF));
 294             do_reset = 1;
 295             break;
 296         case PI_CMD_SWITCHCONFIG:
 297             DEBUG("[PISTORM-DEV] Config switch called, command: ");
 298             switch (val) {
 299                 case PICFG_LOAD:
 300                     DEBUG("LOAD\n");
 301                     if (pi_string[0] == 0 || grab_amiga_string(pi_string[0], (uint8_t *)cfg_filename, 255) == -1) {
 302                         printf("[PISTORM-DEV] Failed to grab string for CONFIG filename. Aborting.\n");
 303                         pi_cmd_result = PI_RES_FAILED;
 304                     } else {
 305                         FILE *tmp = fopen(cfg_filename, "rb");
 306                         if (tmp == NULL) {
 307                             printf("[PISTORM-DEV] Failed to open CONFIG file %s for reading. Aborting.\n", cfg_filename);
 308                             pi_cmd_result = PI_RES_FILENOTFOUND;
 309                         } else {
 310                             fclose(tmp);
 311                             printf("[PISTORM-DEV] Attempting to load config file %s...\n", cfg_filename);
 312                             load_new_config = val + 1;
 313                             pi_cmd_result = PI_RES_OK;
 314                         }
 315                     }
 316                     pi_string[0] = 0;
 317                     break;
 318                 case PICFG_RELOAD:
 319                     DEBUG("RELOAD\n");
 320                     printf("[PISTORM-DEV] Reloading current config file (%s)...\n", cfg_filename);
 321                     load_new_config = val + 1;
 322                     break;
 323                 case PICFG_DEFAULT:
 324                     DEBUG("DEFAULT\n");
 325                     printf("[PISTORM-DEV] Loading default.cfg...\n");
 326                     load_new_config = val + 1;
 327                     break;
 328                 default:
 329                     DEBUG("UNKNOWN/UNHANDLED. Command ignored.\n");
 330                     pi_cmd_result = PI_RES_INVALIDVALUE;
 331                     break;
 332             }
 333             break;
 334         default:
 335             DEBUG("[PISTORM-DEV] WARN: Unhandled %s register write to %.4X: %d\n", op_type_names[type], addr - pistorm_dev_base, val);
 336             pi_cmd_result = PI_RES_INVALIDCMD;
 337             break;
 338     }
 339 }
 340
 341 uint32_t handle_pistorm_dev_read(uint32_t addr_, uint8_t type) {
 342     uint32_t addr = (addr_ & 0xFFFF);
 343
 344     switch((addr)) {
 345         case PI_CMD_HWREV:
 346             // Probably replace this with some read from the CPLD to get a simple hardware revision.
 347             DEBUG("[PISTORM-DEV] %s Read from HWREV\n", op_type_names[type]);
 348             return 0x0101; // 1.1
 349             break;
 350         case PI_CMD_SWREV:
 351             DEBUG("[PISTORM-DEV] %s Read from SWREV\n", op_type_names[type]);
 352             return PIDEV_SWREV;
 353             break;
 354         case PI_CMD_RTGSTATUS:
 355             DEBUG("[PISTORM-DEV] %s Read from RTGSTATUS\n", op_type_names[type]);
 356             return (rtg_on << 1) | rtg_enabled;
 357             break;
 358         case PI_CMD_NETSTATUS:
 359             DEBUG("[PISTORM-DEV] %s Read from NETSTATUS\n", op_type_names[type]);
 360             return pinet_enabled;
 361             break;
 362         case PI_CMD_PISCSI_CTRL:
 363             DEBUG("[PISTORM-DEV] %s Read from PISCSI_CTRL\n", op_type_names[type]);
 364             return piscsi_enabled;
 365             break;
 366
 367         case PI_DBG_VAL1: case PI_DBG_VAL2: case PI_DBG_VAL3: case PI_DBG_VAL4:
 368         case PI_DBG_VAL5: case PI_DBG_VAL6: case PI_DBG_VAL7: case PI_DBG_VAL8:
 369             DEBUG("[PISTORM-DEV] Read DEBUG VALUE %d (%d / $%.8X)\n", (addr - PI_DBG_VAL1) / 4, pi_dbg_val[(addr - PI_DBG_VAL1) / 4], pi_dbg_val[(addr - PI_DBG_VAL1) / 4]);
 370             return pi_dbg_val[(addr - PI_DBG_VAL1) / 4];
 371             break;
 372
 373         case PI_BYTE1: case PI_BYTE2: case PI_BYTE3: case PI_BYTE4:
 374         case PI_BYTE5: case PI_BYTE6: case PI_BYTE7: case PI_BYTE8:
 375             DEBUG("[PISTORM-DEV] Read BYTE %d (%d / $%.2X)\n", addr - PI_BYTE1, pi_byte[addr - PI_BYTE1], pi_byte[addr - PI_BYTE1]);
 376             return pi_byte[addr - PI_BYTE1];
 377             break;
 378         case PI_WORD1: case PI_WORD2: case PI_WORD3: case PI_WORD4:
 379             DEBUG("[PISTORM-DEV] Read WORD %d (%d / $%.4X)\n", (addr - PI_WORD1) / 2, pi_word[(addr - PI_WORD1) / 2], pi_word[(addr - PI_WORD1) / 2]);
 380             return pi_word[(addr - PI_WORD1) / 2];
 381             break;
 382         case PI_LONGWORD1: case PI_LONGWORD2: case PI_LONGWORD3: case PI_LONGWORD4:
 383             DEBUG("[PISTORM-DEV] Read LONGWORD %d (%d / $%.8X)\n", (addr - PI_LONGWORD1) / 4, pi_longword[(addr - PI_LONGWORD1) / 4], pi_longword[(addr - PI_LONGWORD1) / 4]);
 384             return pi_longword[(addr - PI_LONGWORD1) / 4];
 385             break;
 386
 387         case PI_CMDRESULT:
 388             DEBUG("[PISTORM-DEV] %s Read from CMDRESULT\n", op_type_names[type]);
 389             return pi_cmd_result;
 390             break;
 391
 392         default:
 393             DEBUG("[PISTORM-DEV] WARN: Unhandled %s register read from %.4X\n", op_type_names[type], addr - pistorm_dev_base);
 394             break;
 395     }
 396     return 0;
 397 }