patch-pre2.0.8 linux/arch/ppc/boot/mk_type41.c
Next file: linux/arch/ppc/config.in
Previous file: linux/arch/ppc/boot/compressed/unzip.c
Back to the patch index
Back to the overall index
- 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 );
+}
+
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen, slshen@lbl.gov
with Sam's (original) version of this