part_amiga.c 8.78 KB
Newer Older
1 2
/*
 * (C) Copyright 2001
wdenk's avatar
wdenk committed
3
 * Hans-Joerg Frieden, Hyperion Entertainment
4 5
 * Hans-JoergF@hyperion-entertainment.com
 *
6
 * SPDX-License-Identifier:	GPL-2.0+
7 8 9 10 11 12
 */
#include <common.h>
#include <command.h>
#include <ide.h>
#include "part_amiga.h"

13
#ifdef HAVE_BLOCK_DEVICE
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

#undef AMIGA_DEBUG

#ifdef AMIGA_DEBUG
#define PRINTF(fmt, args...) printf(fmt ,##args)
#else
#define PRINTF(fmt, args...)
#endif

struct block_header
{
    u32 id;
    u32 summed_longs;
    s32 chk_sum;
};

static unsigned char block_buffer[DEFAULT_SECTOR_SIZE];
static struct rigid_disk_block rdb = {0};
static struct bootcode_block bootcode = {0};

/*
 * Copy a bcpl to a c string
 */
static void bcpl_strcpy(char *to, char *from)
{
    int len = *from++;

    while (len)
    {
	*to++ = *from++;
	len--;
    }
    *to = 0;
}

/*
 * Print a BCPL String. BCPL strings start with a byte with the length
 * of the string, and don't contain a terminating nul character
 */
static void bstr_print(char *string)
{
    int len = *string++;
    char buffer[256];
    int i;
wdenk's avatar
wdenk committed
58

59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82
    i = 0;
    while (len)
    {
	buffer[i++] = *string++;
	len--;
    }

    buffer[i] = 0;
    printf("%-10s", buffer);
}

/*
 * Sum a block. The checksum of a block must end up at zero
 * to be valid. The chk_sum field is selected so that adding
 * it yields zero.
 */
int sum_block(struct block_header *header)
{
    s32 *block = (s32 *)header;
    u32 i;
    s32 sum = 0;

    for (i = 0; i < header->summed_longs; i++)
	sum += *block++;
wdenk's avatar
wdenk committed
83

84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
    return (sum != 0);
}

/*
 * Print an AmigaOS disk type. Disk types are a four-byte identifier
 * describing the file system. They are usually written as a three-letter
 * word followed by a backslash and a version number. For example,
 * DOS\0 would be the original file system. SFS\0 would be SmartFileSystem.
 * DOS\1 is FFS.
 */
static void print_disk_type(u32 disk_type)
{
    char buffer[6];
    buffer[0] = (disk_type & 0xFF000000)>>24;
    buffer[1] = (disk_type & 0x00FF0000)>>16;
    buffer[2] = (disk_type & 0x0000FF00)>>8;
    buffer[3] = '\\';
    buffer[4] = (disk_type & 0x000000FF) + '0';
    buffer[5] = 0;
    printf("%s", buffer);
}

/*
 * Print the info contained within the given partition block
 */
static void print_part_info(struct partition_block *p)
{
    struct amiga_part_geometry *g;
wdenk's avatar
wdenk committed
112

113 114 115
    g = (struct amiga_part_geometry *)&(p->environment);

    bstr_print(p->drive_name);
wdenk's avatar
wdenk committed
116 117
    printf("%6d\t%6d\t",
	   g->low_cyl * g->block_per_track * g->surfaces ,
118 119 120 121 122 123 124 125 126 127 128
	   (g->high_cyl - g->low_cyl + 1) * g->block_per_track * g->surfaces - 1);
    print_disk_type(g->dos_type);
    printf("\t%5d\n", g->boot_priority);
}

/*
 * Search for the Rigid Disk Block. The rigid disk block is required
 * to be within the first 16 blocks of a drive, needs to have
 * the ID AMIGA_ID_RDISK ('RDSK') and needs to have a valid
 * sum-to-zero checksum
 */
129
struct rigid_disk_block *get_rdisk(struct blk_desc *dev_desc)
130 131 132 133 134 135 136
{
    int i;
    int limit;
    char *s;

    s = getenv("amiga_scanlimit");
    if (s)
137
	limit = simple_strtoul(s, NULL, 10);
138 139 140 141 142
    else
	limit = AMIGA_BLOCK_LIMIT;

    for (i=0; i<limit; i++)
    {
143
	ulong res = blk_dread(dev_desc, i, 1, (ulong *)block_buffer);
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
	if (res == 1)
	{
	    struct rigid_disk_block *trdb = (struct rigid_disk_block *)block_buffer;
	    if (trdb->id == AMIGA_ID_RDISK)
	    {
		PRINTF("Rigid disk block suspect at %d, checking checksum\n",i);
		if (sum_block((struct block_header *)block_buffer) == 0)
		{
		    PRINTF("FOUND\n");
		    memcpy(&rdb, trdb, sizeof(struct rigid_disk_block));
		    return (struct rigid_disk_block *)&rdb;
		}
	    }
	}
    }
    PRINTF("Done scanning, no RDB found\n");
    return NULL;
}

wdenk's avatar
wdenk committed
163
/*
164 165 166 167 168
 * Search for boot code
 * Again, the first boot block must be located somewhere in the first 16 blocks, or rooted in the
 * Ridgid disk block
 */

169
struct bootcode_block *get_bootcode(struct blk_desc *dev_desc)
170 171 172 173 174 175 176
{
    int i;
    int limit;
    char *s;

    s = getenv("amiga_scanlimit");
    if (s)
177
	limit = simple_strtoul(s, NULL, 10);
178 179 180 181 182 183 184
    else
	limit = AMIGA_BLOCK_LIMIT;

    PRINTF("Scanning for BOOT from 0 to %d\n", limit);

    for (i = 0; i < limit; i++)
    {
185
	ulong res = blk_dread(dev_desc, i, 1, (ulong *)block_buffer);
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205
	if (res == 1)
	{
	    struct bootcode_block *boot = (struct bootcode_block *)block_buffer;
	    if (boot->id == AMIGA_ID_BOOT)
	    {
		PRINTF("BOOT block at %d, checking checksum\n", i);
		if (sum_block((struct block_header *)block_buffer) == 0)
		{
		    PRINTF("Found valid bootcode block\n");
		    memcpy(&bootcode, boot, sizeof(struct bootcode_block));
		    return &bootcode;
		}
	    }
	}
    }

    PRINTF("No boot code found on disk\n");
    return 0;
}

wdenk's avatar
wdenk committed
206
/*
207 208 209
 * Test if the given partition has an Amiga partition table/Rigid
 * Disk block
 */
210
static int part_test_amiga(struct blk_desc *dev_desc)
211 212 213 214
{
    struct rigid_disk_block *rdb;
    struct bootcode_block *bootcode;

215
    PRINTF("part_test_amiga: Testing for an Amiga RDB partition\n");
wdenk's avatar
wdenk committed
216

217 218 219 220 221
    rdb = get_rdisk(dev_desc);
    if (rdb)
    {
	bootcode = get_bootcode(dev_desc);
	if (bootcode)
222
	    PRINTF("part_test_amiga: bootable Amiga disk\n");
223
	else
224
	    PRINTF("part_test_amiga: non-bootable Amiga disk\n");
225 226 227

	return 0;
    }
wdenk's avatar
wdenk committed
228
    else
229
    {
230
	PRINTF("part_test_amiga: no RDB found\n");
231 232 233 234 235
	return -1;
    }

}

wdenk's avatar
wdenk committed
236
/*
237 238
 * Find partition number partnum on the given drive.
 */
239 240
static struct partition_block *find_partition(struct blk_desc *dev_desc,
					      int partnum)
241 242 243 244 245 246 247
{
    struct rigid_disk_block *rdb;
    struct partition_block *p;
    u32 block;

    PRINTF("Trying to find partition block %d\n", partnum);
    rdb = get_rdisk(dev_desc);
wdenk's avatar
wdenk committed
248
    if (!rdb)
249 250 251 252
    {
	PRINTF("find_partition: no rdb found\n");
	return NULL;
    }
wdenk's avatar
wdenk committed
253

254 255 256 257 258 259 260
    PRINTF("find_partition: Scanning partition list\n");

    block = rdb->partition_list;
    PRINTF("find_partition: partition list at 0x%x\n", block);

    while (block != 0xFFFFFFFF)
    {
261
	ulong res = blk_dread(dev_desc, block, 1, (ulong *)block_buffer);
262 263 264 265 266 267 268 269 270
	if (res == 1)
	{
	    p = (struct partition_block *)block_buffer;
	    if (p->id == AMIGA_ID_PART)
	    {
		PRINTF("PART block suspect at 0x%x, checking checksum\n",block);
		if (sum_block((struct block_header *)p) == 0)
		{
		    if (partnum == 0) break;
wdenk's avatar
wdenk committed
271
		    else
272 273 274 275 276 277 278 279 280
		    {
			partnum--;
			block = p->next;
		    }
		}
	    } else block = 0xFFFFFFFF;
	} else block = 0xFFFFFFFF;
    }

wdenk's avatar
wdenk committed
281
    if (block == 0xFFFFFFFF)
282 283 284 285 286 287 288 289
    {
	PRINTF("PART block not found\n");
	return NULL;
    }

    return (struct partition_block *)block_buffer;
}

wdenk's avatar
wdenk committed
290
/*
291 292
 * Get info about a partition
 */
293
static int part_get_info_amiga(struct blk_desc *dev_desc, int part,
294
				    disk_partition_t *info)
295 296 297 298 299 300 301 302 303 304 305
{
    struct partition_block *p = find_partition(dev_desc, part-1);
    struct amiga_part_geometry *g;
    u32 disk_type;

    if (!p) return -1;

    g = (struct amiga_part_geometry *)&(p->environment);
    info->start = g->low_cyl  * g->block_per_track * g->surfaces;
    info->size  = (g->high_cyl - g->low_cyl + 1) * g->block_per_track * g->surfaces - 1;
    info->blksz = rdb.block_bytes;
306
    bcpl_strcpy((char *)info->name, p->drive_name);
wdenk's avatar
wdenk committed
307

308 309 310 311 312 313 314 315 316

    disk_type = g->dos_type;

    info->type[0] = (disk_type & 0xFF000000)>>24;
    info->type[1] = (disk_type & 0x00FF0000)>>16;
    info->type[2] = (disk_type & 0x0000FF00)>>8;
    info->type[3] = '\\';
    info->type[4] = (disk_type & 0x000000FF) + '0';
    info->type[5] = 0;
wdenk's avatar
wdenk committed
317

318 319 320
    return 0;
}

321
static void part_print_amiga(struct blk_desc *dev_desc)
wdenk's avatar
wdenk committed
322
{
323 324 325 326 327 328 329
    struct rigid_disk_block *rdb;
    struct bootcode_block *boot;
    struct partition_block *p;
    u32 block;
    int i = 1;

    rdb = get_rdisk(dev_desc);
wdenk's avatar
wdenk committed
330
    if (!rdb)
331
    {
332
	PRINTF("part_print_amiga: no rdb found\n");
333 334
	return;
    }
wdenk's avatar
wdenk committed
335

336
    PRINTF("part_print_amiga: Scanning partition list\n");
337 338

    block = rdb->partition_list;
339
    PRINTF("part_print_amiga: partition list at 0x%x\n", block);
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355

    printf("Summary:  DiskBlockSize: %d\n"
	   "          Cylinders    : %d\n"
	   "          Sectors/Track: %d\n"
	   "          Heads        : %d\n\n",
	   rdb->block_bytes, rdb->cylinders, rdb->sectors,
	   rdb->heads);

    printf("                 First   Num. \n"
	   "Nr.  Part. Name  Block   Block  Type        Boot Priority\n");

    while (block != 0xFFFFFFFF)
    {
	ulong res;

	PRINTF("Trying to load block #0x%X\n", block);
wdenk's avatar
wdenk committed
356

357
	res = blk_dread(dev_desc, block, 1, (ulong *)block_buffer);
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
	if (res == 1)
	{
	    p = (struct partition_block *)block_buffer;
	    if (p->id == AMIGA_ID_PART)
	    {
		PRINTF("PART block suspect at 0x%x, checking checksum\n",block);
		if (sum_block((struct block_header *)p) == 0)
		{
		    printf("%-4d ", i); i++;
		    print_part_info(p);
		    block = p->next;
		}
	    } else block = 0xFFFFFFFF;
	} else block = 0xFFFFFFFF;
    }

    boot = get_bootcode(dev_desc);
    if (boot)
    {
	printf("Disk is bootable\n");
    }
}

381 382 383
U_BOOT_PART_TYPE(amiga) = {
	.name		= "AMIGA",
	.part_type	= PART_TYPE_AMIGA,
384
	.max_entries	= AMIGA_ENTRY_NUMBERS,
385
	.get_info	= part_get_info_amiga,
386 387
	.print		= part_print_amiga,
	.test		= part_test_amiga,
388 389
};

390
#endif