patch-pre2.0.8 linux/arch/ppc/boot/mk_type41.c

• Lines: 205
• Date: Mon May 27 12:00:57 1996
• Orig file: pre2.0.7/linux/arch/ppc/boot/mk_type41.c
• Orig date: Thu Jan 1 02:00:00 1970

diff -u --recursive --new-file pre2.0.7/linux/arch/ppc/boot/mk_type41.c linux/arch/ppc/boot/mk_type41.c
@@ -0,0 +1,204 @@
+/*
+ * This program will make a type 0x41 load image from an
+ * executable file.  Note:  assumes that the executable has
+ * already been "flattened" by 'mkboot'.
+ *
+ * usage: mk_type41 flat-file image
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <sys/stat.h>
+
+_LE(long val, unsigned char *le)
+{
+	le[0] = val;
+	le[1] = val >> 8;
+	le[2] = val >> 16;
+	le[3] = val >> 24;
+}
+
+main(int argc, char *argv[])
+{
+	int in_fd, out_fd, len, size;
+	struct stat info;
+	char buf[8192];
+	struct hdr
+	{
+		unsigned long entry_point;
+		unsigned long image_length;
+	} hdr;
+	if (argc != 3)
+	{
+		fprintf(stderr, "usage: mk_type41 <boot-file> <image>\n");
+		exit(1);
+	}
+	if ((in_fd = open(argv[1], 0)) < 0)
+	{
+		fprintf(stderr, "Can't open input file: '%s': %s\n", argv[1], strerror(errno));
+		exit(2);
+	}
+	if ((out_fd = creat(argv[2], 0666)) < 0)
+	{
+		fprintf(stderr, "Can't create outpue file: '%s': %s\n", argv[2], strerror(errno));
+		exit(2);
+	}
+	if (fstat(in_fd, &info) < 0)
+	{
+		fprintf(stderr, "Can't get info on input file: %s\n", strerror(errno));
+		exit(4);
+	}
+	write_prep_boot_partition(out_fd);
+	_LE(0x400, &hdr.entry_point);
+	_LE(info.st_size+0x400, &hdr.image_length);
+	lseek(out_fd, 0x200, 0);
+	if (write(out_fd, &hdr, sizeof(hdr)) != sizeof(hdr))
+	{
+		fprintf(stderr, "Can't write output file: %s\n", strerror(errno));
+		exit(5);
+	}
+	lseek(out_fd, 0x400, 0);
+	while ((len = read(in_fd, buf, sizeof(buf))) > 0)
+	{
+		if (write(out_fd, buf, len) != len)
+		{
+			fprintf(stderr, "Can't write output file: %s\n", strerror(errno));
+			exit(5);
+		}
+	}
+	if (len < 0)
+	{
+		fprintf(stderr, "Can't read input file: %s\n", strerror(errno));
+		exit(6);
+	}
+	close(in_fd);
+	close(out_fd);
+}
+
+/* Adapted from IBM Naked Application Package (NAP) */
+
+#define Align(value,boundary)						\
+	(((value) + (boundary) - 1) & ~((boundary) - 1))
+
+#define HiByte(word)		((word_t)(word) >> 8)
+#define LoByte(word)		((word_t)(word) & 0xFF)
+
+#define HiWord(dword)		((dword_t)(dword) >> 16)
+#define LoWord(dword)		((dword_t)(dword) & 0xFFFF)
+
+/*
+ * Little-endian stuff
+ */
+#define LeWord(word)							\
+	(((word_t)(word) >> 8) | ((word_t)(word) << 8))
+
+#define LeDword(dword)							\
+	(LeWord(LoWord(dword)) << 16) | LeWord(HiWord(dword))
+
+#define PcDword(dword)							\
+	(LeWord(LoWord(dword)) << 16) | LeWord(HiWord(dword))
+
+
+typedef unsigned long dword_t;
+typedef unsigned short word_t;
+typedef unsigned char byte_t;
+typedef byte_t block_t[512];
+typedef byte_t page_t[4096];
+
+/*
+ * Partition table entry
+ *  - from the PReP spec
+ */
+typedef struct partition_entry {
+    byte_t	boot_indicator;
+    byte_t	starting_head;
+    byte_t	starting_sector;
+    byte_t	starting_cylinder;
+
+    byte_t	system_indicator;
+    byte_t	ending_head;
+    byte_t	ending_sector;
+    byte_t	ending_cylinder;
+
+    dword_t	beginning_sector;
+    dword_t	number_of_sectors;
+} partition_entry_t;
+
+#define BootActive	0x80
+#define SystemPrep	0x41
+
+
+/*
+ * Writes the "boot record", which contains the partition table, to the
+ * diskette, followed by the dummy PC boot block and load image descriptor
+ * block.  It returns the number of bytes it has written to the load
+ * image.
+ *
+ * The boot record is the first block of the diskette and identifies the
+ * "PReP" partition.  The "PReP" partition contains the "load image" starting
+ * at offset zero within the partition.  The first block of the load image is
+ * a dummy PC boot block.  The second block is the "load image descriptor"
+ * which contains the size of the load image and the entry point into the
+ * image.  The actual boot image starts at offset 1024 bytes (third sector)
+ * in the partition.
+ */
+void
+write_prep_boot_partition(int out_fd)
+{
+    block_t block;
+    partition_entry_t *pe = (partition_entry_t *)&block[0x1BE];
+    dword_t *entry  = (dword_t *)&block[0];
+    dword_t *length = (dword_t *)&block[4];
+
+    bzero( &block, sizeof block );
+
+    /*
+     * Magic marker
+     */
+    block[510] = 0x55;
+    block[511] = 0xAA;
+
+    /*
+     * Build a "PReP" partition table entry in the boot record
+     *  - "PReP" may only look at the system_indicator
+     */
+    pe->boot_indicator   = BootActive;
+    pe->system_indicator = SystemPrep;
+
+    /*
+     * The first block of the diskette is used by this "boot record" which
+     * actually contains the partition table. (The first block of the
+     * partition contains the boot image, but I digress...)  We'll set up
+     * one partition on the diskette and it shall contain the rest of the
+     * diskette.
+     */
+    pe->starting_head     = 0;		/* zero-based			     */
+    pe->starting_sector   = 2;		/* one-based			     */
+    pe->starting_cylinder = 0;		/* zero-based			     */
+
+    pe->ending_head       = 1;		/* assumes two heads		     */
+    pe->ending_sector     = 18;		/* assumes 18 sectors/track	     */
+    pe->ending_cylinder   = 79;		/* assumes 80 cylinders/diskette     */
+
+    /*
+     * The "PReP" software ignores the above fields and just looks at
+     * the next two.
+     *   - size of the diskette is (assumed to be)
+     *     (2 tracks/cylinder)(18 sectors/tracks)(80 cylinders/diskette)
+     *   - unlike the above sector nunbers, the beginning sector is zero-based!
+     */
+#if 0     
+    pe->beginning_sector  = LeDword(1);
+#else
+    /* This has to be 0 on the PowerStack? */   
+    pe->beginning_sector  = LeDword(0);
+#endif    
+    pe->number_of_sectors = LeDword(2*18*80-1);
+
+    /*
+     * Write the partition table
+     */
+    lseek( out_fd, 0, 0 );
+    write( out_fd, block, sizeof block );
+}
+