path: root/cart.c

/* CART header support library */

#include <string.h>
#include <stdio.h>
#include "cart.h"

/* 20071227 bkw:
	cart_types list was made from atari800-2.0.3/DOC/cart.txt
	I didn't use any code from atari800, since it's GPL and this code
	is WTFPL.

	Format of CART header (from atari800 cart.txt):

 first 4 bytes containing 'C' 'A' 'R' 'T'.
 next 4 bytes containing cartridge type in MSB format (see the table below).
 next 4 bytes containing cartridge checksum in MSB format (ROM only).
 next 4 bytes are currently unused (zero).
 followed immediately with the ROM data: 4, 8, 16, 32, 40, 64, 128, 256, 512
 or 1024 kilobytes.
*/

/* 20071227 bkw: this list is complete as of Atari800 2.0.3 */
/* 20220827 bkw: list now complete as of Atari800 5.0.0 */
/* 20240421 bkw: list now complete as of Atari800 5.2.0.
   The cart type numbers now have a gap in them: type 160 is
	valid, but types 104 to 159 are not. */
cart_t cart_types[] = {
	/* Id */ /* Machine,   Size,  Name */
	/*  0 */  { M_INVALID,    0,  0 },   /* 0 is invalid type */
	/*  1 */  { M_ATARI8,     8,  "Standard 8 KB" },
	/*  2 */  { M_ATARI8,    16,  "Standard 16 KB" },
	/*  3 */  { M_ATARI8,    16,  "OSS two chip 16 KB cartridge (034M)" },
	/*  4 */  { M_5200,      32,  "Standard 32 KB 5200" },
	/*  5 */  { M_ATARI8,    32,  "DB 32 KB" },
	/*  6 */  { M_5200,      16,  "Two chip 16 KB 5200" },
	/*  7 */  { M_5200,      40,  "Bounty Bob Strikes Back 40 KB 5200" },
	/*  8 */  { M_ATARI8,    64,  "64 KB Williams" },
	/*  9 */  { M_ATARI8,    64,  "Express 64 KB" },
	/* 10 */  { M_ATARI8,    64,  "Diamond 64 KB" },
	/* 11 */  { M_ATARI8,    64,  "SpartaDos X 64 KB" },
	/* 12 */  { M_ATARI8,    32,  "XEGS 32 KB" },
	/* 13 */  { M_ATARI8,    64,  "XEGS 64 KB (banks 0-7)" },
	/* 14 */  { M_ATARI8,   128,  "XEGS 128 KB" },
	/* 15 */  { M_ATARI8,    16,  "OSS one chip 16 KB" },
	/* 16 */  { M_5200,      16,  "One chip 16 KB 5200" },
	/* 17 */  { M_ATARI8,   128,  "Decoded Atrax 128 KB" },
	/* 18 */  { M_ATARI8,    40,  "Bounty Bob Strikes Back 40 KB" },
	/* 19 */  { M_5200,       8,  "Standard 8 KB 5200" },
	/* 20 */  { M_5200,       4,  "Standard 4 KB 5200" },
	/* 21 */  { M_ATARI8,     8,  "Right slot 8 KB" },
	/* 22 */  { M_ATARI8,    32,  "32 KB Williams" },
	/* 23 */  { M_ATARI8,   256,  "XEGS 256 KB" },
	/* 24 */  { M_ATARI8,   512,  "XEGS 512 KB" },
	/* 25 */  { M_ATARI8,  1024,  "XEGS 1 MB" },
	/* 26 */  { M_ATARI8,    16,  "MegaCart 16 KB" },
	/* 27 */  { M_ATARI8,    32,  "MegaCart 32 KB" },
	/* 28 */  { M_ATARI8,    64,  "MegaCart 64 KB" },
	/* 29 */  { M_ATARI8,   128,  "MegaCart 128 KB" },
	/* 30 */  { M_ATARI8,   256,  "MegaCart 256 KB" },
	/* 31 */  { M_ATARI8,   512,  "MegaCart 512 KB" },
	/* 32 */  { M_ATARI8,  1024,  "MegaCart 1 MB" },
	/* 33 */  { M_ATARI8,    32,  "Switchable XEGS 32 KB" },
	/* 34 */  { M_ATARI8,    64,  "Switchable XEGS 64 KB" },
	/* 35 */  { M_ATARI8,   128,  "Switchable XEGS 128 KB" },
	/* 36 */  { M_ATARI8,   256,  "Switchable XEGS 256 KB" },
	/* 37 */  { M_ATARI8,   512,  "Switchable XEGS 512 KB" },
	/* 38 */  { M_ATARI8,  1024,  "Switchable XEGS 1 MB" },
	/* 39 */  { M_ATARI8,     8,  "Phoenix 8 KB" },
	/* 40 */  { M_ATARI8,    16,  "Blizzard 16 KB" },
	/* 41 */  { M_ATARI8,   128,  "Atarimax 128 KB Flash" },
	/* 42 */  { M_ATARI8,  1024,  "Atarimax 1 MB Flash (old)" },
	/* 43 */  { M_ATARI8,   128,  "SpartaDos X 128 KB" },
	/* 44 */  { M_ATARI8,     8,  "OSS 8 KB" },
	/* 45 */  { M_ATARI8,    16,  "OSS two chip 16 KB (043M)" },
	/* 46 */  { M_ATARI8,     4,  "Blizzard 4 KB" },
	/* 47 */  { M_ATARI8,    32,  "AST 32 KB" },
	/* 48 */  { M_ATARI8,    64,  "Atrax SDX 64 KB" },
	/* 49 */  { M_ATARI8,   128,  "Atrax SDX 128 KB" },
	/* 50 */  { M_ATARI8,    64,  "Turbosoft 64 KB" },
	/* 51 */  { M_ATARI8,   128,  "Turbosoft 128 KB" },
	/* 52 */  { M_ATARI8,    32,  "Ultracart 32 KB" },
	/* 53 */  { M_ATARI8,     8,  "Low bank 8 KB" },
	/* 54 */  { M_ATARI8,   128,  "SIC! 128 KB" },
	/* 55 */  { M_ATARI8,   256,  "SIC! 256 KB" },
	/* 56 */  { M_ATARI8,   512,  "SIC! 512 KB" },
	/* 57 */  { M_ATARI8,     2,  "Standard 2 KB" },
	/* 58 */  { M_ATARI8,     4,  "Standard 4 KB" },
	/* 59 */  { M_ATARI8,     4,  "Right slot 4 KB" },
	/* 60 */  { M_ATARI8,    32,  "Blizzard 32 KB" },
	/* 61 */  { M_ATARI8,  2048,  "MegaMax 2 MB" },
	/* 62 */  { M_ATARI8,131072,  "The!Cart 128 MB" },
	/* 63 */  { M_ATARI8,  4096,  "Flash MegaCart 4 MB" },
	/* 64 */  { M_ATARI8,  2048,  "MegaCart 2 MB" },
	/* 65 */  { M_ATARI8, 32768,  "The!Cart 32 MB" },
	/* 66 */  { M_ATARI8, 65536,  "The!Cart 64 MB" },
	/* 67 */  { M_ATARI8,    64,  "XEGS 64 KB (banks 8-15)" },
	/* 68 */  { M_ATARI8,   128,  "Atrax 128 KB" },
	/* 69 */  { M_ATARI8,    32,  "aDawliah 32 KB" },
	/* 70 */  { M_ATARI8,    64,  "aDawliah 64 KB" },
	/* 71 */  { M_5200,      64,  "Super Cart 64 KB 5200" },
	/* 72 */  { M_5200,     128,  "Super Cart 128 KB 5200" },
	/* 73 */  { M_5200,     256,  "Super Cart 256 KB 5200" },
	/* 74 */  { M_5200,     512,  "Super Cart 512 KB 5200" },
	/* 75 */  { M_ATARI8,  1024,  "Atarimax 1 MB Flash (new)" },
	/* 76 */  { M_ATARI8,    16, "16 KB Williams cartridge" },
	/* 77 */  { M_ATARI8,     8, "MIO diagnostics 8KB cartridge" },
	/* 78 */  { M_ATARI8,     8, "Telelink II cartridge" },
	/* 79 */  { M_ATARI8,    16, "Pronto cartridge" },
	/* 80 */  { M_ATARI8,    64, "JRC64 cartridge (linear)" },
	/* 81 */  { M_ATARI8,    64, "MDDOS cartridge" },
	/* 82 */  { M_ATARI8,    32, "COS32 cartridge" },
	/* 83 */  { M_ATARI8,  1024, "SIC+ 1024 KB cartridge" },
	/* 84 */  { M_ATARI8,  1024, "Corina 1M+8K EEPROM" },
	/* 85 */  { M_ATARI8,   512, "Corina 512K + 512K SRAM + 8K EEPROM" },
	/* 86 */  { M_ATARI8,     8, "XE Multicart (8KB)" },
	/* 87 */  { M_ATARI8,    16, "XE Multicart (16KB)" },
	/* 88 */  { M_ATARI8,    32, "XE Multicart (32KB)" },
	/* 89 */  { M_ATARI8,    64, "XE Multicart (64KB)" },
	/* 90 */  { M_ATARI8,   128, "XE Multicart (128KB)" },
	/* 91 */  { M_ATARI8,   256, "XE Multicart (256KB)" },
	/* 92 */  { M_ATARI8,   512, "XE Multicart (512KB)" },
	/* 93 */  { M_ATARI8,  1024, "XE Multicart (1024KB)" },
	/* 94 */  { M_ATARI8,    64, "Ram-Cart 64 KB cartridge" },
	/* 95 */  { M_ATARI8,   128, "Ram-Cart 128 KB cartridge" },
	/* 96 */  { M_ATARI8,   256, "Double Ram-Cart 2x128/256 KB cartridge" },
	/* 97 */  { M_ATARI8,  1024, "Ram-Cart 1 MB cartridge" },
	/* 98 */  { M_ATARI8,  2048, "Ram-Cart 2 MB cartridge" },
	/* 99 */  { M_ATARI8,  4096, "Ram-Cart 4 MB cartridge" },
	/* 100 */ { M_ATARI8,  8192, "Ram-Cart 8 MB cartridge" },
	/* 101 */ { M_ATARI8, 16384, "Ram-Cart 16 MB cartridge" },
	/* 102 */ { M_ATARI8, 32768, "Ram-Cart 32 MB cartridge" },
	/* 103 */ { M_ATARI8,    32, "SiDiCar 32 KB cartridge" },
	/* 104 */ { M_INVALID,    0, 0 },
	/* 105 */ { M_INVALID,    0, 0 },
	/* 106 */ { M_INVALID,    0, 0 },
	/* 107 */ { M_INVALID,    0, 0 },
	/* 108 */ { M_INVALID,    0, 0 },
	/* 109 */ { M_INVALID,    0, 0 },
	/* 110 */ { M_INVALID,    0, 0 },
	/* 111 */ { M_INVALID,    0, 0 },
	/* 112 */ { M_INVALID,    0, 0 },
	/* 113 */ { M_INVALID,    0, 0 },
	/* 114 */ { M_INVALID,    0, 0 },
	/* 115 */ { M_INVALID,    0, 0 },
	/* 116 */ { M_INVALID,    0, 0 },
	/* 117 */ { M_INVALID,    0, 0 },
	/* 118 */ { M_INVALID,    0, 0 },
	/* 119 */ { M_INVALID,    0, 0 },
	/* 120 */ { M_INVALID,    0, 0 },
	/* 121 */ { M_INVALID,    0, 0 },
	/* 122 */ { M_INVALID,    0, 0 },
	/* 123 */ { M_INVALID,    0, 0 },
	/* 124 */ { M_INVALID,    0, 0 },
	/* 125 */ { M_INVALID,    0, 0 },
	/* 126 */ { M_INVALID,    0, 0 },
	/* 127 */ { M_INVALID,    0, 0 },
	/* 128 */ { M_INVALID,    0, 0 },
	/* 129 */ { M_INVALID,    0, 0 },
	/* 130 */ { M_INVALID,    0, 0 },
	/* 131 */ { M_INVALID,    0, 0 },
	/* 132 */ { M_INVALID,    0, 0 },
	/* 133 */ { M_INVALID,    0, 0 },
	/* 134 */ { M_INVALID,    0, 0 },
	/* 135 */ { M_INVALID,    0, 0 },
	/* 136 */ { M_INVALID,    0, 0 },
	/* 137 */ { M_INVALID,    0, 0 },
	/* 138 */ { M_INVALID,    0, 0 },
	/* 139 */ { M_INVALID,    0, 0 },
	/* 140 */ { M_INVALID,    0, 0 },
	/* 141 */ { M_INVALID,    0, 0 },
	/* 142 */ { M_INVALID,    0, 0 },
	/* 143 */ { M_INVALID,    0, 0 },
	/* 144 */ { M_INVALID,    0, 0 },
	/* 145 */ { M_INVALID,    0, 0 },
	/* 146 */ { M_INVALID,    0, 0 },
	/* 147 */ { M_INVALID,    0, 0 },
	/* 148 */ { M_INVALID,    0, 0 },
	/* 149 */ { M_INVALID,    0, 0 },
	/* 150 */ { M_INVALID,    0, 0 },
	/* 151 */ { M_INVALID,    0, 0 },
	/* 152 */ { M_INVALID,    0, 0 },
	/* 153 */ { M_INVALID,    0, 0 },
	/* 154 */ { M_INVALID,    0, 0 },
	/* 155 */ { M_INVALID,    0, 0 },
	/* 156 */ { M_INVALID,    0, 0 },
	/* 157 */ { M_INVALID,    0, 0 },
	/* 158 */ { M_INVALID,    0, 0 },
	/* 159 */ { M_INVALID,    0, 0 },
	/* 160 */ { M_ATARI8,    64, "JRC64 cartridge (interleaved)" },
};

const int MAX_CART_TYPE = (sizeof(cart_types)/sizeof(cart_t))-1;

/* helper functions.
	get_msb_dword() and put_msb_dword() are written the way they are in
	order to avoid endian-ness issues caused by casts or calls to some
	endian-aware function like htonl().
*/

static unsigned int get_msb_dword(unsigned char *cart, int offset) {
	return
		(cart[offset]   << 24) |
		(cart[offset+1] << 16) |
		(cart[offset+2] <<  8) |
		(cart[offset+3]);
}

static void put_msb_dword(unsigned char *cart, int offset, unsigned int data) {
	int i;
	for(i=3; i>=0; i--) {
		cart[offset+i] = data & 0xff;
		data >>= 8;
	}
}

/* has_cart_signature() returns boolean */
int has_cart_signature(unsigned char *cart) {
	return memcmp(cart, CART_SIGNATURE, 4) == 0;
}

void cart_dump_header(unsigned char *cart, int calc_cksum) {
	char *type = "UNKNOWN";
	unsigned int id = get_cart_type(cart);
	unsigned int real_id = get_msb_dword(cart, CART_TYPE_OFFSET);

	if(id)
		type = cart_types[id].name;
	else
		calc_cksum = 0;

	/* Show real type, if get_cart_type() returned zero */
	fprintf(stderr, "CART signature: %s\n",
			(has_cart_signature(cart) ? "Present" : "MISSING"));
	fprintf(stderr, "Cartridge type: %s (ID %d)\n", type, real_id);
	fprintf(stderr, "ROM size:       ");
	if(id)
		fprintf(stderr, "%d bytes + 16 byte header\n", get_cart_size(cart));
	else
		fprintf(stderr, "UNKNOWN\n");

	fprintf(stderr, "Machine type:   ");
	switch(get_cart_machine(cart)) {
		case M_ATARI8:
			fprintf(stderr, "Atari 8-bit computer\n");
			break;

		case M_5200:
			fprintf(stderr, "Atari 5200\n");
			break;

		default:
			fprintf(stderr, "UNKNOWN\n");
			break;
	}

	fprintf(stderr, "CART checksum:  0x%08x", get_cart_checksum(cart));
	if(calc_cksum) {
		fputs((cart_checksum_ok(cart) ? "OK" : "BAD"), stderr);
	}
	fputc('\n', stderr);
}

/* get_cart_type() returns the cartridge ID from the CART header, or zero
	if it's an invalid/unknown type. */
unsigned int get_cart_type(unsigned char *cart) {
	unsigned int type = get_msb_dword(cart, CART_TYPE_OFFSET);

	if(type == 0 || type > MAX_CART_TYPE)
		return 0;

	return type;
}

/* get_cart_size() returns the cartridge ROM size in bytes, NOT including
	the 16-byte header, or zero if invalid type */
unsigned int get_cart_size(unsigned char *cart) {
	unsigned int type = get_cart_type(cart);
	if(type == 0)
		return 0;

	return cart_types[type].size * 1024;
}

/* get_cart_checksum() returns the checksum stored in the header. It does
	NOT calculate the checksum (use calc_rom_checksum() for that) */
unsigned int get_cart_checksum(unsigned char *cart) {
	return get_msb_dword(cart, CART_CHECKSUM_OFFSET);
}

machine_t get_cart_machine(unsigned char *cart) {
	unsigned int type = get_cart_type(cart);
	if(type == 0)
		return M_INVALID;

	return cart_types[type].machine;
}

/* calc_rom_checksum() is the odd man out: it takes a pointer to the
	raw ROM data, NOT to the header+data like all the other functions do! */
unsigned int calc_rom_checksum(unsigned char *rom, int bytes) {
	unsigned int cksum = 0;

	while(bytes-- > 0) cksum += *rom++;

	return cksum;
}

/* cart_checksum_ok() must be called with a complete .CAR image, not just
	a header! */
unsigned int cart_checksum_ok(unsigned char *cart) {
	unsigned int bytes = get_cart_size(cart);
	unsigned int got = calc_rom_checksum(cart + 16, bytes);
	unsigned int expected = get_cart_checksum(cart);

	return (got == expected);
}

/* create_cart_header() must be supplied with a buffer, which must be at least
	16 bytes in size. Returns 0 with buffer unchanged if type was invalid. */
int create_cart_header(
		unsigned char *buffer,
		unsigned char *rom,
		unsigned int type)
{
	if(type == 0 || type > MAX_CART_TYPE)
		return 0;

	memcpy(buffer, CART_SIGNATURE, 4);

	set_cart_type(buffer, type);
	set_cart_checksum(buffer,
			calc_rom_checksum(rom, cart_types[type].size * 1024));
	set_cart_unused(buffer, 0);

	return 1;
}

void set_cart_checksum(unsigned char *cart, unsigned int sum) {
	put_msb_dword(cart, CART_CHECKSUM_OFFSET, sum);
}

void set_cart_type(unsigned char *cart, unsigned int type) {
	put_msb_dword(cart, CART_TYPE_OFFSET, type);
}

void set_cart_unused(unsigned char *cart, unsigned int data) {
	put_msb_dword(cart, CART_UNUSED_OFFSET, data);
}