[realtek] Explicitly disable VLAN offload

Some cards seem to have the receive VLAN tag stripping feature enabled
by default, which causes received VLAN packets to be misinterpreted as
being received by the trunk device.

Fix by disabling VLAN tag stripping in the C+ Command Register.

Debugged-by: ?????? <yiyihu@gmail.com>
Tested-by: ?????? <yiyihu@gmail.com>
Signed-off-by: Michael Brown <mcb30@ipxe.org>

.github/workflows/build.yml

@@ -4,53 +4,21 @@ on: push
 
 jobs:
 
-  cache:
-    name: Cache
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Cache permissions
-        run: |
-          sudo chown $(id -un) /var/cache/apt/archives
-      - name: Cache packages
-        uses: actions/cache@v4
-        with:
-          path: /var/cache/apt/archives/*.deb
-          key: apt-cache-${{ github.run_id }}-${{ github.run_attempt }}
-          restore-keys: |
-            apt-cache-
-      - name: Download packages
-        run: |
-          sudo apt update
-          sudo apt install -y -d -o Acquire::Retries=50 \
-                           mtools syslinux isolinux \
-                           libc6-dev-i386 valgrind \
-                           gcc-arm-none-eabi gcc-aarch64-linux-gnu
-
   x86:
     name: x86
-    runs-on: ubuntu-22.04
-    needs: cache
+    runs-on: ubuntu-20.04
     steps:
       - name: Check out code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
         with:
           fetch-depth: 0
-      - name: Cache permissions
-        run: |
-          sudo chown $(id -un) /var/cache/apt/archives
-      - name: Cache packages
-        uses: actions/cache/restore@v4
-        with:
-          path: /var/cache/apt/archives/*.deb
-          key: apt-cache-${{ github.run_id }}-${{ github.run_attempt }}
       - name: Install packages
         run: |
           sudo dpkg --add-architecture i386
           sudo apt update
           sudo apt install -y -o Acquire::Retries=50 \
                            mtools syslinux isolinux \
-                           libc6-dev-i386 valgrind \
-                           libgcc-s1:i386 libc6-dbg:i386
+                           libc6-dev-i386 libc6-dbg:i386 valgrind
       - name: Build (BIOS)
         run: |
           make -j 4 -C src
@@ -64,21 +32,12 @@ jobs:
 
   arm32:
     name: ARM32
-    runs-on: ubuntu-22.04
-    needs: cache
+    runs-on: ubuntu-20.04
     steps:
       - name: Check out code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
         with:
           fetch-depth: 0
-      - name: Cache permissions
-        run: |
-          sudo chown $(id -un) /var/cache/apt/archives
-      - name: Cache packages
-        uses: actions/cache/restore@v4
-        with:
-          path: /var/cache/apt/archives/*.deb
-          key: apt-cache-${{ github.run_id }}-${{ github.run_attempt }}
       - name: Install packages
         run: |
           sudo apt update
@@ -93,21 +52,12 @@ jobs:
 
   arm64:
     name: ARM64
-    runs-on: ubuntu-22.04
-    needs: cache
+    runs-on: ubuntu-20.04
     steps:
       - name: Check out code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
         with:
           fetch-depth: 0
-      - name: Cache permissions
-        run: |
-          sudo chown $(id -un) /var/cache/apt/archives
-      - name: Cache packages
-        uses: actions/cache/restore@v4
-        with:
-          path: /var/cache/apt/archives/*.deb
-          key: apt-cache-${{ github.run_id }}-${{ github.run_attempt }}
       - name: Install packages
         run: |
           sudo apt update

.github/workflows/coverity.yml

@@ -8,10 +8,10 @@ on:
 jobs:
   submit:
     name: Submit
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
     steps:
       - name: Check out code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
       - name: Download Coverity Scan
         run: |
           curl --form token=${{ secrets.COVERITY_SCAN_TOKEN }} \

contrib/cloud/aws-import

@@ -46,19 +46,11 @@ def create_snapshot(region, description, image):
     return snapshot_id
 
 
-def import_image(region, name, architecture, image, public, overwrite):
+def import_image(region, name, architecture, image, public):
     """Import an AMI image"""
     client = boto3.client('ec2', region_name=region)
     resource = boto3.resource('ec2', region_name=region)
     description = '%s (%s)' % (name, architecture)
-    images = client.describe_images(Filters=[{'Name': 'name',
-                                              'Values': [description]}])
-    if overwrite and images['Images']:
-        images = images['Images'][0]
-        image_id = images['ImageId']
-        snapshot_id = images['BlockDeviceMappings'][0]['Ebs']['SnapshotId']
-        resource.Image(image_id).deregister()
-        resource.Snapshot(snapshot_id).delete()
     snapshot_id = create_snapshot(region=region, description=description,
                                   image=image)
     client.get_waiter('snapshot_completed').wait(SnapshotIds=[snapshot_id])
@@ -96,8 +88,6 @@ parser.add_argument('--name', '-n',
                     help="Image name")
 parser.add_argument('--public', '-p', action='store_true',
                     help="Make image public")
-parser.add_argument('--overwrite', action='store_true',
-                    help="Overwrite any existing image with same name")
 parser.add_argument('--region', '-r', action='append',
                     help="AWS region(s)")
 parser.add_argument('--wiki', '-w', metavar='FILE',
@@ -125,8 +115,7 @@ with ThreadPoolExecutor(max_workers=len(imports)) as executor:
                                name=args.name,
                                architecture=architectures[image],
                                image=image,
-                               public=args.public,
-                               overwrite=args.overwrite): (region, image)
+                               public=args.public): (region, image)
                for region, image in imports}
     results = {futures[future]: future.result()
                for future in as_completed(futures)}

contrib/cloud/aws-int13con

@@ -1,68 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-
-import boto3
-
-BLOCKSIZE = 512 * 1024
-
-IPXELOG_OFFSET = 16 * 1024
-
-IPXELOG_MAGIC = b'iPXE LOG'
-
-
-def create_snapshot(region, instance_id):
-    """Create root volume snapshot"""
-    client = boto3.client('ec2', region_name=region)
-    resource = boto3.resource('ec2', region_name=region)
-    instance = resource.Instance(instance_id)
-    volumes = list(instance.volumes.all())
-    snapshot = volumes[0].create_snapshot()
-    snapshot.wait_until_completed()
-    return snapshot.id
-
-
-def get_snapshot_block(region, snapshot_id, index):
-    """Get block content from snapshot"""
-    client = boto3.client('ebs', region_name=region)
-    blocks = client.list_snapshot_blocks(SnapshotId=snapshot_id,
-                                         StartingBlockIndex=index)
-    token = blocks['Blocks'][0]['BlockToken']
-    block = client.get_snapshot_block(SnapshotId=snapshot_id,
-                                      BlockIndex=index,
-                                      BlockToken=token)
-    return block['BlockData'].read()
-
-
-def get_block0_content(region, instance_id):
-    """Get content of root volume block zero from instance"""
-    client = boto3.client('ec2', region_name=region)
-    resource = boto3.resource('ec2', region_name=region)
-    snapshot_id = create_snapshot(region, instance_id)
-    block = get_snapshot_block(region, snapshot_id, 0)
-    resource.Snapshot(snapshot_id).delete()
-    return block
-
-
-def get_int13con_output(region, instance_id):
-    """Get INT13 console output"""
-    block = get_block0_content(region, instance_id)
-    logpart = block[IPXELOG_OFFSET:]
-    magic = logpart[:len(IPXELOG_MAGIC)]
-    if magic != IPXELOG_MAGIC:
-        raise ValueError("Invalid log magic signature")
-    log = logpart[len(IPXELOG_MAGIC):].split(b'\0')[0]
-    return log.decode()
-
-
-# Parse command-line arguments
-parser = argparse.ArgumentParser(description="Get AWS INT13 console output")
-parser.add_argument('--region', '-r', help="AWS region")
-parser.add_argument('id', help="Instance ID")
-args = parser.parse_args()
-
-# Get console output from INT13CON partition
-output = get_int13con_output(args.region, args.id)
-
-# Print console output
-print(output)

src/.gitignore

@@ -1,4 +1,4 @@
 .toolcheck
 .echocheck
 TAGS*
-bin-*
+bin*

src/Makefile.efi

@@ -23,9 +23,9 @@ NON_AUTO_MEDIA	+= efidrv
 NON_AUTO_MEDIA	+= drv.efi
 NON_AUTO_MEDIA	+= efirom
 
-# Include SNP and MNP drivers in the all-drivers build
+# Include SNP driver in the all-drivers build
 #
-DRIVERS_net += snp mnp
+DRIVERS_net += snp
 
 # Rules for building EFI files
 #
@@ -50,10 +50,6 @@ $(BIN)/efidrv.cab : $(BIN)/alldrv.efis # $(ALL_drv.efi) is not yet defined
 	$(QM)$(ECHO) "  [CAB] $@"
 	$(Q)$(LCAB) -n -q $(ALL_drv.efi) $@
 
-$(BIN)/%.iso : $(BIN)/%.efi util/genfsimg
-	$(QM)$(ECHO) "  [GENFSIMG] $@"
-	$(Q)util/genfsimg -o $@ $<
-
-$(BIN)/%.usb : $(BIN)/%.efi util/genfsimg
+$(BIN)/%.iso $(BIN)/%.usb : $(BIN)/%.efi util/genfsimg
 	$(QM)$(ECHO) "  [GENFSIMG] $@"
 	$(Q)util/genfsimg -o $@ $<

src/Makefile.housekeeping

@@ -502,13 +502,6 @@ LDFLAGS		+= --gc-sections
 #
 LDFLAGS		+= -static
 
-# Use separate code segment if supported by linker
-#
-ZSC_TEST	= $(LD) -z separate-code --version 2>&1 > /dev/null
-ZSC_FLAGS	:= $(shell [ -z "`$(ZSC_TEST)`" ] && \
-		     $(ECHO) '-z separate-code -z max-page-size=4096')
-LDFLAGS		+= $(ZSC_FLAGS)
-
 # compiler.h is needed for our linking and debugging system
 #
 CFLAGS		+= -include include/compiler.h
@@ -1009,7 +1002,6 @@ endif
 # Device ID tables (using IDs from ROM definition file)
 #
 define obj_pci_id_asm
-	.section ".note.GNU-stack", "", $(ASM_TCHAR)progbits
 	.section ".pci_devlist.$(1)", "a", $(ASM_TCHAR)progbits
 	.globl pci_devlist_$(1)
 pci_devlist_$(1):
@@ -1179,7 +1171,7 @@ BLIB		= $(BIN)/blib.a
 $(BLIB) : $(BLIB_OBJS) $(BLIB_LIST) $(MAKEDEPS)
 	$(Q)$(RM) $(BLIB)
 	$(QM)$(ECHO) "  [AR] $@"
-	$(Q)$(AR) rcD $@ $(sort $(BLIB_OBJS))
+	$(Q)$(AR) rD $@ $(sort $(BLIB_OBJS))
 	$(Q)$(OBJCOPY) --enable-deterministic-archives \
 		       --prefix-symbols=$(SYMBOL_PREFIX) $@
 	$(Q)$(RANLIB) -D $@

src/arch/arm/Makefile

@@ -9,5 +9,4 @@ INCDIRS		+= arch/arm/include
 
 # ARM-specific directories containing source files
 #
-SRCDIRS		+= arch/arm/core
 SRCDIRS		+= arch/arm/interface/efi

src/arch/arm/core/arm_io.c

@@ -46,7 +46,7 @@ union arm32_io_qword {
  *
  * This is not atomic for ARM32.
  */
-static __unused uint64_t arm32_readq ( volatile uint64_t *io_addr ) {
+static uint64_t arm32_readq ( volatile uint64_t *io_addr ) {
 	volatile union arm32_io_qword *ptr =
 		container_of ( io_addr, union arm32_io_qword, qword );
 	union arm32_io_qword tmp;
@@ -64,8 +64,7 @@ static __unused uint64_t arm32_readq ( volatile uint64_t *io_addr ) {
  *
  * This is not atomic for ARM32.
  */
-static __unused void arm32_writeq ( uint64_t data,
-				    volatile uint64_t *io_addr ) {
+static void arm32_writeq ( uint64_t data, volatile uint64_t *io_addr ) {
 	volatile union arm32_io_qword *ptr =
 		container_of ( io_addr, union arm32_io_qword, qword );
 	union arm32_io_qword tmp;
@@ -83,6 +82,7 @@ PROVIDE_IOAPI_INLINE ( arm, readl );
 PROVIDE_IOAPI_INLINE ( arm, writeb );
 PROVIDE_IOAPI_INLINE ( arm, writew );
 PROVIDE_IOAPI_INLINE ( arm, writel );
+PROVIDE_IOAPI_INLINE ( arm, iodelay );
 PROVIDE_IOAPI_INLINE ( arm, mb );
 #ifdef __aarch64__
 PROVIDE_IOAPI_INLINE ( arm, readq );
@@ -91,4 +91,3 @@ PROVIDE_IOAPI_INLINE ( arm, writeq );
 PROVIDE_IOAPI ( arm, readq, arm32_readq );
 PROVIDE_IOAPI ( arm, writeq, arm32_writeq );
 #endif
-PROVIDE_DUMMY_PIO ( arm );

src/arch/arm/include/bits/entropy.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_ENTROPY_H
+#define _BITS_ENTROPY_H
+
+/** @file
+ *
+ * ARM-specific entropy API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_ENTROPY_H */

src/arch/arm/include/bits/io.h

@@ -9,9 +9,6 @@
 
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
-/** Page shift */
-#define PAGE_SHIFT 12
-
 #include <ipxe/arm_io.h>
 
 #endif /* _BITS_IO_H */

src/arch/arm/include/bits/mp.h

@@ -1,12 +0,0 @@
-#ifndef _BITS_MP_H
-#define _BITS_MP_H
-
-/** @file
- *
- * ARM-specific multiprocessor API implementation
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_MP_H */

src/arch/arm/include/bits/pci_io.h

@@ -9,4 +9,6 @@
 
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
+#include <ipxe/io.h>
+
 #endif /* _BITS_PCI_IO_H */

src/arch/arm/include/ipxe/arm_io.h

@@ -15,13 +15,14 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 #define IOAPI_PREFIX_arm __arm_
 #endif
 
-#include <ipxe/dummy_pio.h>
-
 /*
  * Memory space mappings
  *
  */
 
+/** Page shift */
+#define PAGE_SHIFT 12
+
 /*
  * Physical<->Bus address mappings
  *
@@ -79,6 +80,55 @@ ARM_WRITEX ( w, uint16_t, "h", "" );
 ARM_WRITEX ( l, uint32_t, "", "" );
 #endif
 
+/*
+ * Dummy PIO reads and writes up to 32 bits
+ *
+ * There is no common standard for I/O-space access for ARM, and
+ * non-MMIO peripherals are vanishingly rare.  Provide dummy
+ * implementations that will allow code to link and should cause
+ * drivers to simply fail to detect hardware at runtime.
+ *
+ */
+
+#define ARM_INX( _suffix, _type )					      \
+static inline __always_inline _type					      \
+IOAPI_INLINE ( arm, in ## _suffix ) ( volatile _type *io_addr __unused) {     \
+	return ~( (_type) 0 );						      \
+}									      \
+static inline __always_inline void					      \
+IOAPI_INLINE ( arm, ins ## _suffix ) ( volatile _type *io_addr __unused,      \
+				       _type *data, unsigned int count ) {    \
+	memset ( data, 0xff, count * sizeof ( *data ) );		      \
+}
+ARM_INX ( b, uint8_t );
+ARM_INX ( w, uint16_t );
+ARM_INX ( l, uint32_t );
+
+#define ARM_OUTX( _suffix, _type )					      \
+static inline __always_inline void					      \
+IOAPI_INLINE ( arm, out ## _suffix ) ( _type data __unused,		      \
+				       volatile _type *io_addr __unused ) {   \
+	/* Do nothing */						      \
+}									      \
+static inline __always_inline void					      \
+IOAPI_INLINE ( arm, outs ## _suffix ) ( volatile _type *io_addr __unused,     \
+					const _type *data __unused,	      \
+					unsigned int count __unused ) {	      \
+	/* Do nothing */						      \
+}
+ARM_OUTX ( b, uint8_t );
+ARM_OUTX ( w, uint16_t );
+ARM_OUTX ( l, uint32_t );
+
+/*
+ * Slow down I/O
+ *
+ */
+static inline __always_inline void
+IOAPI_INLINE ( arm, iodelay ) ( void ) {
+	/* Nothing to do */
+}
+
 /*
  * Memory barrier
  *
@@ -93,7 +143,4 @@ IOAPI_INLINE ( arm, mb ) ( void ) {
 #endif
 }
 
-/* Dummy PIO */
-DUMMY_PIO ( arm );
-
 #endif /* _IPXE_ARM_IO_H */

src/arch/arm/interface/efi/efiarm_nap.c

@@ -46,12 +46,8 @@ static void efiarm_cpu_nap ( void ) {
 	 * The EFI shell doesn't seem to bother sleeping the CPU; it
 	 * just sits there idly burning power.
 	 *
-	 * If a shutdown is in progess, there may be nothing to
-	 * generate an interrupt since the timer is disabled in the
-	 * first step of ExitBootServices().
 	 */
-	if ( ! efi_shutdown_in_progress )
-		__asm__ __volatile__ ( "wfi" );
+	__asm__ __volatile__ ( "wfi" );
 }
 
 PROVIDE_NAP ( efiarm, cpu_nap, efiarm_cpu_nap );

src/arch/arm32/core/arm32_bigint.c

@@ -36,23 +36,19 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  * Multiply big integers
  *
  * @v multiplicand0	Element 0 of big integer to be multiplied
- * @v multiplicand_size	Number of elements in multiplicand
  * @v multiplier0	Element 0 of big integer to be multiplied
- * @v multiplier_size	Number of elements in multiplier
  * @v result0		Element 0 of big integer to hold result
+ * @v size		Number of elements
  */
 void bigint_multiply_raw ( const uint32_t *multiplicand0,
-			   unsigned int multiplicand_size,
 			   const uint32_t *multiplier0,
-			   unsigned int multiplier_size,
-			   uint32_t *result0 ) {
-	unsigned int result_size = ( multiplicand_size + multiplier_size );
-	const bigint_t ( multiplicand_size ) __attribute__ (( may_alias ))
-		*multiplicand = ( ( const void * ) multiplicand0 );
-	const bigint_t ( multiplier_size ) __attribute__ (( may_alias ))
-		*multiplier = ( ( const void * ) multiplier0 );
-	bigint_t ( result_size ) __attribute__ (( may_alias ))
-		*result = ( ( void * ) result0 );
+			   uint32_t *result0, unsigned int size ) {
+	const bigint_t ( size ) __attribute__ (( may_alias )) *multiplicand =
+		( ( const void * ) multiplicand0 );
+	const bigint_t ( size ) __attribute__ (( may_alias )) *multiplier =
+		( ( const void * ) multiplier0 );
+	bigint_t ( size * 2 ) __attribute__ (( may_alias )) *result =
+		( ( void * ) result0 );
 	unsigned int i;
 	unsigned int j;
 	uint32_t multiplicand_element;
@@ -66,9 +62,9 @@ void bigint_multiply_raw ( const uint32_t *multiplicand0,
 	memset ( result, 0, sizeof ( *result ) );
 
 	/* Multiply integers one element at a time */
-	for ( i = 0 ; i < multiplicand_size ; i++ ) {
+	for ( i = 0 ; i < size ; i++ ) {
 		multiplicand_element = multiplicand->element[i];
-		for ( j = 0 ; j < multiplier_size ; j++ ) {
+		for ( j = 0 ; j < size ; j++ ) {
 			multiplier_element = multiplier->element[j];
 			result_elements = &result->element[ i + j ];
 			/* Perform a single multiply, and add the
@@ -77,7 +73,7 @@ void bigint_multiply_raw ( const uint32_t *multiplicand0,
 			 * never overflow beyond the end of the
 			 * result, since:
 			 *
-			 *     a < 2^{n}, b < 2^{m} => ab < 2^{n+m}
+			 *     a < 2^{n}, b < 2^{n} => ab < 2^{2n}
 			 */
 			__asm__ __volatile__ ( "umull %1, %2, %5, %6\n\t"
 					       "ldr %3, [%0]\n\t"

src/arch/arm32/include/bits/bigint.h

@@ -310,9 +310,7 @@ bigint_done_raw ( const uint32_t *value0, unsigned int size __unused,
 }
 
 extern void bigint_multiply_raw ( const uint32_t *multiplicand0,
-				  unsigned int multiplicand_size,
 				  const uint32_t *multiplier0,
-				  unsigned int multiplier_size,
-				  uint32_t *value0 );
+				  uint32_t *value0, unsigned int size );
 
 #endif /* _BITS_BIGINT_H */

src/arch/arm32/include/bits/compiler.h

@@ -8,9 +8,6 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
 #ifndef ASSEMBLY
 
-/** Unprefixed constant operand modifier */
-#define ASM_NO_PREFIX "c"
-
 #define __asmcall
 #define __libgcc
 

src/arch/arm32/libgcc/lldivmod.S

@@ -1,6 +1,7 @@
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
 
 	.section ".note.GNU-stack", "", %progbits
+	.text
 	.thumb
 
 /**

src/arch/arm32/libgcc/llshift.S

@@ -1,6 +1,7 @@
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
 
 	.section ".note.GNU-stack", "", %progbits
+	.text
 	.arm
 
 /**

src/arch/arm64/core/arm64_bigint.c

@@ -36,23 +36,19 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  * Multiply big integers
  *
  * @v multiplicand0	Element 0 of big integer to be multiplied
- * @v multiplicand_size	Number of elements in multiplicand
  * @v multiplier0	Element 0 of big integer to be multiplied
- * @v multiplier_size	Number of elements in multiplier
  * @v result0		Element 0 of big integer to hold result
+ * @v size		Number of elements
  */
 void bigint_multiply_raw ( const uint64_t *multiplicand0,
-			   unsigned int multiplicand_size,
 			   const uint64_t *multiplier0,
-			   unsigned int multiplier_size,
-			   uint64_t *result0 ) {
-	unsigned int result_size = ( multiplicand_size + multiplier_size );
-	const bigint_t ( multiplicand_size ) __attribute__ (( may_alias ))
-		*multiplicand = ( ( const void * ) multiplicand0 );
-	const bigint_t ( multiplier_size ) __attribute__ (( may_alias ))
-		*multiplier = ( ( const void * ) multiplier0 );
-	bigint_t ( result_size ) __attribute__ (( may_alias ))
-		*result = ( ( void * ) result0 );
+			   uint64_t *result0, unsigned int size ) {
+	const bigint_t ( size ) __attribute__ (( may_alias )) *multiplicand =
+		( ( const void * ) multiplicand0 );
+	const bigint_t ( size ) __attribute__ (( may_alias )) *multiplier =
+		( ( const void * ) multiplier0 );
+	bigint_t ( size * 2 ) __attribute__ (( may_alias )) *result =
+		( ( void * ) result0 );
 	unsigned int i;
 	unsigned int j;
 	uint64_t multiplicand_element;
@@ -67,9 +63,9 @@ void bigint_multiply_raw ( const uint64_t *multiplicand0,
 	memset ( result, 0, sizeof ( *result ) );
 
 	/* Multiply integers one element at a time */
-	for ( i = 0 ; i < multiplicand_size ; i++ ) {
+	for ( i = 0 ; i < size ; i++ ) {
 		multiplicand_element = multiplicand->element[i];
-		for ( j = 0 ; j < multiplier_size ; j++ ) {
+		for ( j = 0 ; j < size ; j++ ) {
 			multiplier_element = multiplier->element[j];
 			result_elements = &result->element[ i + j ];
 			/* Perform a single multiply, and add the
@@ -78,7 +74,7 @@ void bigint_multiply_raw ( const uint64_t *multiplicand0,
 			 * never overflow beyond the end of the
 			 * result, since:
 			 *
-			 *     a < 2^{n}, b < 2^{m} => ab < 2^{n+m}
+			 *     a < 2^{n}, b < 2^{n} => ab < 2^{2n}
 			 */
 			__asm__ __volatile__ ( "mul %1, %6, %7\n\t"
 					       "umulh %2, %6, %7\n\t"

src/arch/arm64/core/setjmp.S

@@ -1,6 +1,5 @@
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
 
-	.section ".note.GNU-stack", "", %progbits
 	.text
 
 	/* Must match jmp_buf structure layout */

src/arch/arm64/include/bits/bigint.h

@@ -311,9 +311,7 @@ bigint_done_raw ( const uint64_t *value0, unsigned int size __unused,
 }
 
 extern void bigint_multiply_raw ( const uint64_t *multiplicand0,
-				  unsigned int multiplicand_size,
 				  const uint64_t *multiplier0,
-				  unsigned int multiplier_size,
-				  uint64_t *value0 );
+				  uint64_t *value0, unsigned int size );
 
 #endif /* _BITS_BIGINT_H */

src/arch/arm64/include/bits/compiler.h

@@ -8,9 +8,6 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
 #ifndef ASSEMBLY
 
-/** Unprefixed constant operand modifier */
-#define ASM_NO_PREFIX "c"
-
 #define __asmcall
 #define __libgcc
 

src/arch/i386/core/gdbidt.S

@@ -9,7 +9,6 @@
  * Interrupt handlers
  ****************************************************************************
  */
-	.section ".note.GNU-stack", "", @progbits
 	.section ".text", "ax", @progbits
 	.code32
 

src/arch/i386/core/setjmp.S

@@ -1,9 +1,8 @@
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
 
-	.section ".note.GNU-stack", "", @progbits
 	.text
-	.code32
 	.arch i386
+	.code32
 
 	/* Must match jmp_buf structure layout */
 	.struct	0

src/arch/i386/include/bits/compiler.h

@@ -8,9 +8,6 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
 #ifndef ASSEMBLY
 
-/** Unprefixed constant operand modifier */
-#define ASM_NO_PREFIX "c"
-
 /** Declare a function with standard calling conventions */
 #define __asmcall __attribute__ (( cdecl, regparm(0) ))
 

src/arch/i386/tests/gdbstub_test.S

@@ -1,5 +1,3 @@
-	.section ".note.GNU-stack", "", @progbits
-	.code32
 	.arch i386
 
 	.section ".data", "aw", @progbits

src/arch/loong64/Makefile

@@ -1,27 +0,0 @@
-# Assembler section type character
-#
-ASM_TCHAR	:= @
-ASM_TCHAR_OPS	:= @
-
-# LoongArch64-specific flags
-#
-CFLAGS		+= -fstrength-reduce -fomit-frame-pointer
-CFLAGS		+= -falign-jumps=1 -falign-loops=1 -falign-functions=1
-
-# Check if -mno-explicit-relocs is valid
-ifeq ($(CCTYPE),gcc)
-MNER_TEST = $(CC) -mno-explicit-relocs -x c -c /dev/null -o /dev/null >/dev/null 2>&1
-MNER_FLAGS := $(shell $(MNER_TEST) && $(ECHO) '-mno-explicit-relocs')
-WORKAROUND_CFLAGS += $(MNER_FLAGS)
-endif
-
-# EFI requires -fshort-wchar, and nothing else currently uses wchar_t
-CFLAGS		+= -fshort-wchar
-
-# LoongArch64-specific directories containing source files
-SRCDIRS		+= arch/loong64/core
-SRCDIRS		+= arch/loong64/interface/efi
-
-# Include platform-specific Makefile
-MAKEDEPS	+= arch/loong64/Makefile.$(PLATFORM)
-include arch/loong64/Makefile.$(PLATFORM)

src/arch/loong64/Makefile.efi

@@ -1,14 +0,0 @@
-# -*- makefile -*- : Force emacs to use Makefile mode
-
-# Specify EFI image builder
-#
-ELF2EFI		= $(ELF2EFI64)
-
-# Specify EFI boot file
-#
-EFI_BOOT_FILE	= bootloongarch64.efi
-
-# Include generic EFI Makefile
-#
-MAKEDEPS	+= Makefile.efi
-include Makefile.efi

src/arch/loong64/Makefile.linux

@@ -1,10 +0,0 @@
-# -*- makefile -*- : Force emacs to use Makefile mode
-
-# Starting virtual address
-#
-LDFLAGS += -Ttext=0x120000000
-
-# Include generic Linux Makefile
-#
-MAKEDEPS += Makefile.linux
-include Makefile.linux

src/arch/loong64/core/loong64_bigint.c

@@ -1,124 +0,0 @@
-/*
- * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>.
- * Copyright (c) 2023, Xiaotian Wu <wuxiaotian@loongson.cn>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- *
- * You can also choose to distribute this program under the terms of
- * the Unmodified Binary Distribution Licence (as given in the file
- * COPYING.UBDL), provided that you have satisfied its requirements.
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <stdint.h>
-#include <string.h>
-#include <ipxe/bigint.h>
-
-/** @file
- *
- * Big integer support
- */
-
-/**
- * Multiply big integers
- *
- * @v multiplicand0	Element 0 of big integer to be multiplied
- * @v multiplicand_size	Number of elements in multiplicand
- * @v multiplier0	Element 0 of big integer to be multiplied
- * @v multiplier_size	Number of elements in multiplier
- * @v result0		Element 0 of big integer to hold result
- */
-void bigint_multiply_raw ( const uint64_t *multiplicand0,
-			   unsigned int multiplicand_size,
-			   const uint64_t *multiplier0,
-			   unsigned int multiplier_size,
-			   uint64_t *result0 ) {
-	unsigned int result_size = ( multiplicand_size + multiplier_size );
-	const bigint_t ( multiplicand_size ) __attribute__ (( may_alias ))
-		*multiplicand = ( ( const void * ) multiplicand0 );
-	const bigint_t ( multiplier_size ) __attribute__ (( may_alias ))
-		*multiplier = ( ( const void * ) multiplier0 );
-	bigint_t ( result_size ) __attribute__ (( may_alias ))
-		*result = ( ( void * ) result0 );
-	unsigned int i;
-	unsigned int j;
-	uint64_t multiplicand_element;
-	uint64_t multiplier_element;
-	uint64_t *result_elements;
-	uint64_t discard_low;
-	uint64_t discard_high;
-	uint64_t discard_temp_low;
-	uint64_t discard_temp_high;
-
-	/* Zero result */
-	memset ( result, 0, sizeof ( *result ) );
-
-	/* Multiply integers one element at a time */
-	for ( i = 0 ; i < multiplicand_size ; i++ ) {
-		multiplicand_element = multiplicand->element[i];
-		for ( j = 0 ; j < multiplier_size ; j++ ) {
-			multiplier_element = multiplier->element[j];
-			result_elements = &result->element[ i + j ];
-			/* Perform a single multiply, and add the
-			 * resulting double-element into the result,
-			 * carrying as necessary.  The carry can
-			 * never overflow beyond the end of the
-			 * result, since:
-			 *
-			 *     a < 2^{n}, b < 2^{m} => ab < 2^{n+m}
-			 */
-			__asm__ __volatile__ ( "mul.d   %1, %6, %7\n\t"
-					       "mulh.du %2, %6, %7\n\t"
-
-					       "ld.d    %3, %0, 0\n\t"
-					       "ld.d    %4, %0, 8\n\t"
-
-					       "add.d   %3, %3, %1\n\t"
-					       "sltu    $t0, %3, %1\n\t"
-
-					       "add.d   %4, %4, %2\n\t"
-					       "sltu    $t1, %4, %2\n\t"
-
-					       "add.d   %4, %4, $t0\n\t"
-					       "sltu    $t0, %4, $t0\n\t"
-					       "or      $t0, $t0, $t1\n\t"
-
-					       "st.d    %3,  %0, 0\n\t"
-					       "st.d    %4,  %0, 8\n\t"
-
-					       "addi.d  %0,  %0, 16\n\t"
-					       "beqz    $t0, 2f\n"
-					       "1:\n\t"
-					       "ld.d    %3,  %0, 0\n\t"
-					       "add.d   %3,  %3, $t0\n\t"
-					       "sltu    $t0, %3, $t0\n\t"
-					       "st.d    %3,  %0, 0\n\t"
-					       "addi.d  %0, %0, 8\n\t"
-					       "bnez    $t0, 1b\n"
-					       "2:"
-					       : "+r" ( result_elements ),
-						 "=&r" ( discard_low ),
-						 "=&r" ( discard_high ),
-						 "=r" ( discard_temp_low ),
-						 "=r" ( discard_temp_high ),
-						 "+m" ( *result )
-					       : "r" ( multiplicand_element ),
-						 "r" ( multiplier_element )
-					       : "t0", "t1" );
-		}
-	}
-}

src/arch/loong64/core/loong64_io.c

@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2023, Xiaotian Wu <wuxiaotian@loongson.cn>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- *
- * You can also choose to distribute this program under the terms of
- * the Unmodified Binary Distribution Licence (as given in the file
- * COPYING.UBDL), provided that you have satisfied its requirements.
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <ipxe/io.h>
-#include <ipxe/loong64_io.h>
-
-/** @file
- *
- * iPXE I/O API for LoongArch64
- *
- */
-
-PROVIDE_IOAPI_INLINE ( loong64, phys_to_bus );
-PROVIDE_IOAPI_INLINE ( loong64, bus_to_phys );
-PROVIDE_IOAPI_INLINE ( loong64, readb );
-PROVIDE_IOAPI_INLINE ( loong64, readw );
-PROVIDE_IOAPI_INLINE ( loong64, readl );
-PROVIDE_IOAPI_INLINE ( loong64, readq );
-PROVIDE_IOAPI_INLINE ( loong64, writeb );
-PROVIDE_IOAPI_INLINE ( loong64, writew );
-PROVIDE_IOAPI_INLINE ( loong64, writel );
-PROVIDE_IOAPI_INLINE ( loong64, writeq );
-PROVIDE_IOAPI_INLINE ( loong64, mb );
-PROVIDE_DUMMY_PIO ( loong64 );

src/arch/loong64/core/loong64_string.c

@@ -1,266 +0,0 @@
-/*
- * Copyright (C) 2016 Michael Brown <mbrown@fensystems.co.uk>.
- * Copyright (c) 2023, Xiaotian Wu <wuxiaotian@loongson.cn>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- *
- * You can also choose to distribute this program under the terms of
- * the Unmodified Binary Distribution Licence (as given in the file
- * COPYING.UBDL), provided that you have satisfied its requirements.
- */
-
-/** @file
- *
- * Optimised string operations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <string.h>
-
-/**
- * Copy memory area
- *
- * @v dest		Destination address
- * @v src		Source address
- * @v len		Length
- * @ret dest		Destination address
- */
-void loong64_memcpy ( void *dest, const void *src, size_t len ) {
-	void *discard_dest;
-	void *discard_end;
-	const void *discard_src;
-	size_t discard_offset;
-	unsigned long discard_data;
-	unsigned long discard_low;
-	unsigned long discard_high;
-
-	/* If length is too short, then just copy individual bytes.
-	 */
-	if ( len < 16 ) {
-		__asm__ __volatile__ ( "beqz %0, 2f\n\t"
-				       "\n1:\n\t"
-				       "addi.d %0, %0, -1\n\t"
-				       "ldx.b %1, %3, %0\n\t"
-				       "stx.b %1, %2, %0\n\t"
-				       "bnez %0, 1b\n\t"
-				       "\n2:\n\t"
-				       : "=&r" ( discard_offset ),
-					 "=&r" ( discard_data )
-				       : "r" ( dest ), "r" ( src ), "0" ( len )
-				       : "memory", "t0" );
-		return;
-	}
-
-	/* Copy 16 bytes at a time: one initial
-	 * potentially unaligned access, multiple destination-aligned
-	 * accesses, one final potentially unaligned access.
-	 */
-	__asm__ __volatile__ ( "ld.d %3, %1, 0\n\t"
-			       "ld.d %4, %1, 8\n\t"
-			       "addi.d %1, %1, 16\n\t"
-			       "st.d %3, %0, 0\n\t"
-			       "st.d %4, %0, 8\n\t"
-			       "addi.d %0, %0, 16\n\t"
-			       "andi %3, %0, 15\n\t"
-			       "sub.d %0, %0, %3\n\t"
-			       "sub.d %1, %1, %3\n\t"
-			       "addi.d $t0, $zero, 0xf\n\t"
-			       "andn %2, %5, $t0\n\t"
-			       "b 2f\n\t"
-			       "\n1:\n\t"
-			       "ld.d %3, %1, 0\n\t"
-			       "ld.d %4, %1, 8\n\t"
-			       "addi.d %1, %1, 16\n\t"
-			       "st.d %3, %0, 0\n\t"
-			       "st.d %4, %0, 8\n\t"
-			       "addi.d %0, %0, 16\n\t"
-			       "\n2:\n\t"
-			       "bne %0, %2, 1b\n\t"
-			       "ld.d %3, %6, -16\n\t"
-			       "ld.d %4, %6, -8\n\t"
-			       "st.d %3, %5, -16\n\t"
-			       "st.d %4, %5, -8\n\t"
-			       : "=&r" ( discard_dest ),
-				 "=&r" ( discard_src ),
-				 "=&r" ( discard_end ),
-				 "=&r" ( discard_low ),
-				 "=&r" ( discard_high )
-			       : "r" ( dest + len ), "r" ( src + len ),
-				 "0" ( dest ), "1" ( src )
-			       : "memory", "t0" );
-}
-
-/**
- * Zero memory region
- *
- * @v dest		Destination region
- * @v len		Length
- */
-void loong64_bzero ( void *dest, size_t len ) {
-	size_t discard_offset;
-	void *discard_dest;
-	void *discard_end;
-
-	/* If length is too short, then just zero individual bytes.
-	 */
-	if ( len < 16 ) {
-		__asm__ __volatile__ ( "beqz %0, 2f\n\t"
-				       "\n1:\n\t"
-				       "addi.d %0, %0, -1\n\t"
-				       "stx.b $zero, %1, %0\n\t"
-				       "bnez %0, 1b\n\t"
-				       "\n2:\n\t"
-				       : "=&r" ( discard_offset )
-				       : "r" ( dest ), "0" ( len )
-				       : "memory" );
-		return;
-	}
-
-	/* To zero 16 bytes at a time: one initial
-	 * potentially unaligned access, multiple aligned accesses,
-	 * one final potentially unaligned access.
-	 */
-
-	__asm__ __volatile__ ( "st.d $zero, %0, 0\n\t"
-			       "st.d $zero, %0, 8\n\t"
-			       "addi.d %0, %0, 16\n\t"
-			       "addi.w $t0, $zero, 15\n\t"
-			       "andn %0, %0, $t0\n\t"
-			       "addi.w $t0, $zero, 15\n\t"
-			       "andn %1, %2, $t0\n\t"
-			       "b 2f\n\t"
-			       "\n1:\n\t"
-			       "st.d $zero, %0, 0\n\t"
-			       "st.d $zero, %0, 8\n\t"
-			       "addi.d %0, %0, 16\n\t"
-			       "\n2:\n\t"
-			       "bne %0, %1, 1b\n\t"
-			       "st.d $zero, %2, -16\n\t"
-			       "st.d $zero, %2, -8\n\t"
-			       : "=&r" ( discard_dest ),
-				 "=&r" ( discard_end )
-			       : "r" ( dest + len ), "0" ( dest )
-			       : "memory", "t0" );
-}
-
-/**
- * Fill memory region
- *
- * @v dest		Destination region
- * @v len		Length
- * @v character		Fill character
- *
- * The unusual parameter order is to allow for more efficient
- * tail-calling to loong64_memset() when zeroing a region.
- */
-void loong64_memset ( void *dest, size_t len, int character ) {
-	size_t discard_offset;
-
-	/* Use optimised zeroing code if applicable */
-	if ( character == 0 ) {
-		loong64_bzero ( dest, len );
-		return;
-	}
-
-	/* Fill one byte at a time.  Calling memset() with a non-zero
-	 * value is relatively rare and unlikely to be
-	 * performance-critical.
-	 */
-	__asm__ __volatile__ ( "beqz %0, 2f\n\t"
-			       "\n1:\n\t"
-			       "addi.d %0, %0, -1\n\t"
-			       "stx.b %2, %1, %0\n\t"
-			       "bnez %0, 1b\n\t"
-			       "\n2:\n\t"
-			       : "=&r" ( discard_offset )
-			       : "r" ( dest ), "r" ( character ), "0" ( len )
-			       : "memory" );
-}
-
-/**
- * Copy (possibly overlapping) memory region forwards
- *
- * @v dest		Destination region
- * @v src		Source region
- * @v len		Length
- */
-void loong64_memmove_forwards ( void *dest, const void *src, size_t len ) {
-	void *discard_dest;
-	const void *discard_src;
-	unsigned long discard_data;
-
-	/* Assume memmove() is not performance-critical, and perform a
-	 * bytewise copy for simplicity.
-	 */
-	__asm__ __volatile__ ( "b 2f\n\t"
-			       "\n1:\n\t"
-			       "ld.b %2, %1, 0\n\t"
-			       "addi.d %1, %1, 1\n\t"
-			       "st.b %2, %0, 0\n\t"
-			       "addi.d %0, %0, 1\n\t"
-			       "\n2:\n\t"
-			       "bne %0, %3, 1b\n\t"
-			       : "=&r" ( discard_dest ),
-				 "=&r" ( discard_src ),
-				 "=&r" ( discard_data )
-			       : "r" ( dest + len ), "0" ( dest ), "1" ( src )
-			       : "memory" );
-}
-
-/**
- * Copy (possibly overlapping) memory region backwards
- *
- * @v dest		Destination region
- * @v src		Source region
- * @v len		Length
- */
-void loong64_memmove_backwards ( void *dest, const void *src, size_t len ) {
-	size_t discard_offset;
-	unsigned long discard_data;
-
-	/* Assume memmove() is not performance-critical, and perform a
-	 * bytewise copy for simplicity.
-	 */
-	__asm__ __volatile__ ( "beqz %0, 2f\n\t"
-			       "\n1:\n\t"
-			       "addi.d %0, %0, -1\n\t"
-			       "ldx.b %1, %3, %0\n\t"
-			       "stx.b %1, %2, %0\n\t"
-			       "bnez %0, 1b\n\t"
-			       "\n2:\n\t"
-			       : "=&r" ( discard_offset ),
-				 "=&r" ( discard_data )
-			       : "r" ( dest ), "r" ( src ), "0" ( len )
-			       : "memory" );
-}
-
-/**
- * Copy (possibly overlapping) memory region
- *
- * @v dest		Destination region
- * @v src		Source region
- * @v len		Length
- */
-void loong64_memmove ( void *dest, const void *src, size_t len ) {
-
-	if ( dest <= src ) {
-		loong64_memmove_forwards ( dest, src, len );
-	} else {
-		loong64_memmove_backwards ( dest, src, len );
-	}
-}

src/arch/loong64/core/setjmp.S

@@ -1,53 +0,0 @@
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
-
-	.section ".note.GNU-stack", "", %progbits
-	.text
-/*
-   int setjmp(jmp_buf env);
-*/
-	.globl	setjmp
-	.type	setjmp, %function
-setjmp:
-	/* Store registers */
-	st.d	$s0, $a0, 0x0
-	st.d	$s1, $a0, 0x8
-	st.d	$s2, $a0, 0x10
-	st.d	$s3, $a0, 0x18
-	st.d	$s4, $a0, 0x20
-	st.d	$s5, $a0, 0x28
-	st.d	$s6, $a0, 0x30
-	st.d	$s7, $a0, 0x38
-	st.d	$s8, $a0, 0x40
-	st.d	$fp, $a0, 0x48
-	st.d	$sp, $a0, 0x50
-	st.d	$ra, $a0, 0x58
-
-	move	$a0, $zero
-	jirl	$zero, $ra, 0
-	.size	setjmp, . - setjmp
-
-/*
-   void longjmp(jmp_buf env, int val);
-*/
-	.globl	longjmp
-	.type	longjmp, %function
-longjmp:
-	/* Restore registers */
-	ld.d	$s0, $a0, 0x0
-	ld.d	$s1, $a0, 0x8
-	ld.d	$s2, $a0, 0x10
-	ld.d	$s3, $a0, 0x18
-	ld.d	$s4, $a0, 0x20
-	ld.d	$s5, $a0, 0x28
-	ld.d	$s6, $a0, 0x30
-	ld.d	$s7, $a0, 0x38
-	ld.d	$s8, $a0, 0x40
-	ld.d	$fp, $a0, 0x48
-	ld.d	$sp, $a0, 0x50
-	ld.d	$ra, $a0, 0x58
-	addi.d	$a0, $zero, 1    # a0 = 1
-	beqz	$a1, .exit       # if (a1 == 0); goto L0
-	move	$a0, $a1         # a0 = a1
-.exit:
-	jirl	$zero, $ra, 0
-	.size	longjmp, . - longjmp

src/arch/loong64/include/bits/acpi.h

@@ -1,12 +0,0 @@
-#ifndef _BITS_ACPI_H
-#define _BITS_ACPI_H
-
-/** @file
- *
- * LoongArch64-specific ACPI API implementations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_ACPI_H */

src/arch/loong64/include/bits/bigint.h

@@ -1,366 +0,0 @@
-#ifndef _BITS_BIGINT_H
-#define _BITS_BIGINT_H
-
-/** @file
- *
- * Big integer support
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <stdint.h>
-#include <string.h>
-#include <strings.h>
-
-/** Element of a big integer */
-typedef uint64_t bigint_element_t;
-
-/**
- * Initialise big integer
- *
- * @v value0	Element 0 of big integer to initialise
- * @v size		Number of elements
- * @v data		Raw data
- * @v len		Length of raw data
- */
-static inline __attribute__ (( always_inline )) void
-bigint_init_raw ( uint64_t *value0, unsigned int size,
-		  const void *data, size_t len ) {
-	size_t pad_len = ( sizeof ( bigint_t ( size ) ) - len );
-	uint8_t *value_byte = ( ( void * ) value0 );
-	const uint8_t *data_byte = ( data + len );
-
-	/* Copy raw data in reverse order, padding with zeros */
-	while ( len-- )
-		*(value_byte++) = *(--data_byte);
-	while ( pad_len-- )
-		*(value_byte++) = 0;
-}
-
-/**
- * Add big integers
- *
- * @v addend0		Element 0 of big integer to add
- * @v value0		Element 0 of big integer to be added to
- * @v size		Number of elements
- */
-static inline __attribute__ (( always_inline )) void
-bigint_add_raw ( const uint64_t *addend0, uint64_t *value0,
-		 unsigned int size ) {
-	bigint_t ( size ) __attribute__ (( may_alias )) *value =
-		( ( void * ) value0 );
-	uint64_t *discard_addend;
-	uint64_t *discard_value;
-	uint64_t discard_addend_i;
-	uint64_t discard_value_i;
-	uint64_t discard_carry;
-	uint64_t discard_temp;
-	unsigned int discard_size;
-
-	__asm__ __volatile__ ( "\n1:\n\t"
-			       /* Load addend[i] and value[i] */
-			       "ld.d %3, %0, 0\n\t"
-			       "ld.d %4, %1, 0\n\t"
-			       /* Add carry flag and addend */
-			       "add.d %4, %4, %5\n\t"
-			       "sltu %6, %4, %5\n\t"
-			       "add.d %4, %4, %3\n\t"
-			       "sltu %5, %4, %3\n\t"
-			       "or %5, %5, %6\n\t"
-			       /* Store value[i] */
-			       "st.d %4, %1, 0\n\t"
-			       /* Loop */
-			       "addi.d %0, %0, 8\n\t"
-			       "addi.d %1, %1, 8\n\t"
-			       "addi.w %2, %2, -1\n\t"
-			       "bnez %2, 1b\n\t"
-			       : "=r" ( discard_addend ),
-				 "=r" ( discard_value ),
-				 "=r" ( discard_size ),
-				 "=r" ( discard_addend_i ),
-				 "=r" ( discard_value_i ),
-				 "=r" ( discard_carry ),
-				 "=r" ( discard_temp ),
-				 "+m" ( *value )
-			       : "0" ( addend0 ), "1" ( value0 ),
-				 "2" ( size ), "5" ( 0 ) );
-}
-
-/**
- * Subtract big integers
- *
- * @v subtrahend0	Element 0 of big integer to subtract
- * @v value0		Element 0 of big integer to be subtracted from
- * @v size		Number of elements
- */
-static inline __attribute__ (( always_inline )) void
-bigint_subtract_raw ( const uint64_t *subtrahend0, uint64_t *value0,
-		      unsigned int size ) {
-	bigint_t ( size ) __attribute__ (( may_alias )) *value =
-		( ( void * ) value0 );
-	uint64_t *discard_subtrahend;
-	uint64_t *discard_value;
-	uint64_t discard_subtrahend_i;
-	uint64_t discard_value_i;
-	uint64_t discard_carry;
-	uint64_t discard_temp;
-	unsigned int discard_size;
-
-	__asm__ __volatile__ ( "\n1:\n\t"
-			       /* Load subtrahend[i] and value[i] */
-			       "ld.d %3, %0, 0\n\t"
-			       "ld.d %4, %1, 0\n\t"
-			       /* Subtract carry flag and subtrahend */
-			       "sltu %6, %4, %5\n\t"
-			       "sub.d %4, %4, %5\n\t"
-			       "sltu %5, %4, %3\n\t"
-			       "sub.d %4, %4, %3\n\t"
-			       "or %5, %5, %6\n\t"
-			       /* Store value[i] */
-			       "st.d %4, %1, 0\n\t"
-			       /* Loop */
-			       "addi.d %0, %0, 8\n\t"
-			       "addi.d %1, %1, 8\n\t"
-			       "addi.w %2, %2, -1\n\t"
-			       "bnez %2, 1b\n\t"
-			       : "=r" ( discard_subtrahend ),
-				 "=r" ( discard_value ),
-				 "=r" ( discard_size ),
-				 "=r" ( discard_subtrahend_i ),
-				 "=r" ( discard_value_i ),
-				 "=r" ( discard_carry ),
-				 "=r" ( discard_temp ),
-				 "+m" ( *value )
-			       : "0" ( subtrahend0 ), "1" ( value0 ),
-				 "2" ( size ), "5" ( 0 ) );
-}
-
-/**
- * Rotate big integer left
- *
- * @v value0		Element 0 of big integer
- * @v size		Number of elements
- */
-static inline __attribute__ (( always_inline )) void
-bigint_rol_raw ( uint64_t *value0, unsigned int size ) {
-	bigint_t ( size ) __attribute__ (( may_alias )) *value =
-		( ( void * ) value0 );
-	uint64_t *discard_value;
-	uint64_t discard_value_i;
-	uint64_t discard_carry;
-	uint64_t discard_temp;
-	unsigned int discard_size;
-
-	__asm__ __volatile__ ( "\n1:\n\t"
-			       /* Load value[i] */
-			       "ld.d %2, %0, 0\n\t"
-			       /* Shift left */
-			       "rotri.d %2, %2, 63\n\t"
-			       "andi %4, %2, 1\n\t"
-			       "xor %2, %2, %4\n\t"
-			       "or %2, %2, %3\n\t"
-			       "move %3, %4\n\t"
-			       /* Store value[i] */
-			       "st.d %2, %0, 0\n\t"
-			       /* Loop  */
-			       "addi.d %0, %0, 8\n\t"
-			       "addi.w %1, %1, -1\n\t"
-			       "bnez %1, 1b\n\t"
-			       : "=r" ( discard_value ),
-				 "=r" ( discard_size ),
-				 "=r" ( discard_value_i ),
-				 "=r" ( discard_carry ),
-				 "=r" ( discard_temp ),
-				 "+m" ( *value )
-			       : "0" ( value0 ), "1" ( size ), "3" ( 0 )
-			       : "cc" );
-}
-
-/**
- * Rotate big integer right
- *
- * @v value0		Element 0 of big integer
- * @v size		Number of elements
- */
-static inline __attribute__ (( always_inline )) void
-bigint_ror_raw ( uint64_t *value0, unsigned int size ) {
-	bigint_t ( size ) __attribute__ (( may_alias )) *value =
-		( ( void * ) value0 );
-	uint64_t *discard_value;
-	uint64_t discard_value_i;
-	uint64_t discard_carry;
-	uint64_t discard_temp;
-	unsigned int discard_size;
-
-	__asm__ __volatile__ ( "\n1:\n\t"
-			       /* Load value[i] */
-			       "ld.d %2, %0, -8\n\t"
-			       /* Shift right */
-			       "andi %4, %2, 1\n\t"
-			       "xor %2, %2, %4\n\t"
-			       "or %2, %2, %3\n\t"
-			       "move %3, %4\n\t"
-			       "rotri.d %2, %2, 1\n\t"
-			       /* Store value[i] */
-			       "st.d %2, %0, -8\n\t"
-			       /* Loop  */
-			       "addi.d %0, %0, -8\n\t"
-			       "addi.w %1, %1, -1\n\t"
-			       "bnez %1, 1b\n\t"
-			       : "=r" ( discard_value ),
-				 "=r" ( discard_size ),
-				 "=r" ( discard_value_i ),
-				 "=r" ( discard_carry ),
-				 "=r" ( discard_temp ),
-				 "+m" ( *value )
-			       : "0" ( value0 + size ), "1" ( size ), "3" ( 0 )
-			       : "cc" );
-}
-
-/**
- * Test if big integer is equal to zero
- *
- * @v value0		Element 0 of big integer
- * @v size		Number of elements
- * @ret is_zero		Big integer is equal to zero
- */
-static inline __attribute__ (( always_inline, pure )) int
-bigint_is_zero_raw ( const uint64_t *value0, unsigned int size ) {
-	const uint64_t *value = value0;
-	uint64_t value_i;
-
-	do {
-		value_i = *(value++);
-		if ( value_i )
-			break;
-	} while ( --size );
-
-	return ( value_i == 0 );
-}
-
-/**
- * Compare big integers
- *
- * @v value0		Element 0 of big integer
- * @v reference0	Element 0 of reference big integer
- * @v size		Number of elements
- * @ret geq		Big integer is greater than or equal to the reference
- */
-static inline __attribute__ (( always_inline, pure )) int
-bigint_is_geq_raw ( const uint64_t *value0, const uint64_t *reference0,
-		    unsigned int size ) {
-	const uint64_t *value = ( value0 + size );
-	const uint64_t *reference = ( reference0 + size );
-	uint64_t value_i;
-	uint64_t reference_i;
-
-	do {
-		value_i = *(--value);
-		reference_i = *(--reference);
-		if ( value_i != reference_i )
-			break;
-	} while ( --size );
-
-	return ( value_i >= reference_i );
-}
-
-/**
- * Test if bit is set in big integer
- *
- * @v value0		Element 0 of big integer
- * @v size		Number of elements
- * @v bit		Bit to test
- * @ret is_set		Bit is set
- */
-static inline __attribute__ (( always_inline )) int
-bigint_bit_is_set_raw ( const uint64_t *value0, unsigned int size,
-			unsigned int bit ) {
-	const bigint_t ( size ) __attribute__ (( may_alias )) *value =
-		( ( const void * ) value0 );
-	unsigned int index = ( bit / ( 8 * sizeof ( value->element[0] ) ) );
-	unsigned int subindex = ( bit % ( 8 * sizeof ( value->element[0] ) ) );
-
-	return ( !! ( value->element[index] & ( 1UL << subindex ) ) );
-}
-
-/**
- * Find highest bit set in big integer
- *
- * @v value0		Element 0 of big integer
- * @v size		Number of elements
- * @ret max_bit		Highest bit set + 1 (or 0 if no bits set)
- */
-static inline __attribute__ (( always_inline )) int
-bigint_max_set_bit_raw ( const uint64_t *value0, unsigned int size ) {
-	const uint64_t *value = ( value0 + size );
-	int max_bit = ( 8 * sizeof ( bigint_t ( size ) ) );
-	uint64_t value_i;
-
-	do {
-		value_i = *(--value);
-		max_bit -= ( 64 - fls ( value_i ) );
-		if ( value_i )
-			break;
-	} while ( --size );
-
-	return max_bit;
-}
-
-/**
- * Grow big integer
- *
- * @v source0		Element 0 of source big integer
- * @v source_size	Number of elements in source big integer
- * @v dest0		Element 0 of destination big integer
- * @v dest_size		Number of elements in destination big integer
- */
-static inline __attribute__ (( always_inline )) void
-bigint_grow_raw ( const uint64_t *source0, unsigned int source_size,
-		  uint64_t *dest0, unsigned int dest_size ) {
-	unsigned int pad_size = ( dest_size - source_size );
-
-	memcpy ( dest0, source0, sizeof ( bigint_t ( source_size ) ) );
-	memset ( ( dest0 + source_size ), 0, sizeof ( bigint_t ( pad_size ) ) );
-}
-
-/**
- * Shrink big integer
- *
- * @v source0		Element 0 of source big integer
- * @v source_size	Number of elements in source big integer
- * @v dest0		Element 0 of destination big integer
- * @v dest_size		Number of elements in destination big integer
- */
-static inline __attribute__ (( always_inline )) void
-bigint_shrink_raw ( const uint64_t *source0, unsigned int source_size __unused,
-		    uint64_t *dest0, unsigned int dest_size ) {
-
-	memcpy ( dest0, source0, sizeof ( bigint_t ( dest_size ) ) );
-}
-
-/**
- * Finalise big integer
- *
- * @v value0		Element 0 of big integer to finalise
- * @v size		Number of elements
- * @v out		Output buffer
- * @v len		Length of output buffer
- */
-static inline __attribute__ (( always_inline )) void
-bigint_done_raw ( const uint64_t *value0, unsigned int size __unused,
-		  void *out, size_t len ) {
-	const uint8_t *value_byte = ( ( const void * ) value0 );
-	uint8_t *out_byte = ( out + len );
-
-	/* Copy raw data in reverse order */
-	while ( len-- )
-		*(--out_byte) = *(value_byte++);
-}
-
-extern void bigint_multiply_raw ( const uint64_t *multiplicand0,
-				  unsigned int multiplicand_size,
-				  const uint64_t *multiplier0,
-				  unsigned int multiplier_size,
-				  uint64_t *value0 );
-
-#endif /* _BITS_BIGINT_H */

src/arch/loong64/include/bits/bitops.h

@@ -1,102 +0,0 @@
-#ifndef _BITS_BITOPS_H
-#define _BITS_BITOPS_H
-
-/** @file
- *
- * loongArch bit operations
- *
- * We perform atomic bit set and bit clear operations using "ll"
- * and "sc".  We use the output constraint to inform the
- * compiler that any memory from the start of the bit field up to and
- * including the byte containing the bit may be modified.  (This is
- * overkill but shouldn't matter in practice since we're unlikely to
- * subsequently read other bits from the same bit field.)
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <stdint.h>
-
-/**
- * Test and set bit atomically
- *
- * @v bit		Bit to set
- * @v bits		Bit field
- * @ret old		Old value of bit (zero or non-zero)
- */
-static inline __attribute__ (( always_inline )) int
-test_and_set_bit ( unsigned int bit, volatile void *bits ) {
-	unsigned int index = ( bit / 64 );
-	unsigned int offset = ( bit % 64 );
-	volatile uint64_t *qword = ( ( ( volatile uint64_t * ) bits ) + index );
-	uint64_t mask = ( 1UL << offset );
-	uint64_t old;
-	uint64_t new;
-
-	__asm__ __volatile__ ( "1:				\n\t"
-			       "ll.d %[old], %[qword]		\n\t"
-			       "or   %[new], %[old], %[mask]	\n\t"
-			       "sc.d %[new], %[qword]		\n\t"
-			       "beqz %[new], 1b			\n\t"
-			       : [old] "=&r" ( old ),
-				 [new] "=&r" ( new ),
-				 [qword] "+m" ( *qword )
-			       : [mask] "r" ( mask )
-			       : "cc", "memory");
-	return ( !! ( old & mask ) );
-}
-
-/**
- * Test and clear bit atomically
- *
- * @v bit		Bit to set
- * @v bits		Bit field
- * @ret old		Old value of bit (zero or non-zero)
- */
-static inline __attribute__ (( always_inline )) int
-test_and_clear_bit ( unsigned int bit, volatile void *bits ) {
-	unsigned int index = ( bit / 64 );
-	unsigned int offset = ( bit % 64 );
-	volatile uint64_t *qword = ( ( ( volatile uint64_t * ) bits ) + index );
-	uint64_t mask = ( 1UL << offset );
-	uint64_t old;
-	uint64_t new;
-
-	__asm__ __volatile__ ( "1:				\n\t"
-			       "ll.d %[old], %[qword]		\n\t"
-			       "andn %[new], %[old], %[mask]	\n\t"
-			       "sc.d %[new], %[qword]		\n\t"
-			       "beqz %[new], 1b			\n\t"
-			       : [old] "=&r" ( old ),
-				 [new] "=&r" ( new ),
-				 [qword] "+m" ( *qword )
-			       : [mask] "r" ( mask )
-			       : "cc", "memory");
-	return ( !! ( old & mask ) );
-}
-
-/**
- * Set bit atomically
- *
- * @v bit		Bit to set
- * @v bits		Bit field
- */
-static inline __attribute__ (( always_inline )) void
-set_bit ( unsigned int bit, volatile void *bits ) {
-
-	test_and_set_bit ( bit, bits );
-}
-
-/**
- * Clear bit atomically
- *
- * @v bit		Bit to set
- * @v bits		Bit field
- */
-static inline __attribute__ (( always_inline )) void
-clear_bit ( unsigned int bit, volatile void *bits ) {
-
-	test_and_clear_bit ( bit, bits );
-}
-
-#endif /* _BITS_BITOPS_H */

src/arch/loong64/include/bits/byteswap.h

@@ -1,47 +0,0 @@
-#ifndef _BITS_BYTESWAP_H
-#define _BITS_BYTESWAP_H
-
-/** @file
- *
- * Byte-order swapping functions
- *
- */
-
-#include <stdint.h>
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-static inline __attribute__ (( always_inline, const )) uint16_t
-__bswap_variable_16 ( uint16_t x ) {
-	__asm__ ( "revb.2h %0, %1" : "=r" ( x ) : "r" ( x ) );
-	return x;
-}
-
-static inline __attribute__ (( always_inline )) void
-__bswap_16s ( uint16_t *x ) {
-	*x = __bswap_variable_16 ( *x );
-}
-
-static inline __attribute__ (( always_inline, const )) uint32_t
-__bswap_variable_32 ( uint32_t x ) {
-	__asm__ ( "revb.2w %0, %1" : "=r" ( x ) : "r" ( x ) );
-	return x;
-}
-
-static inline __attribute__ (( always_inline )) void
-__bswap_32s ( uint32_t *x ) {
-	*x = __bswap_variable_32 ( *x );
-}
-
-static inline __attribute__ (( always_inline, const )) uint64_t
-__bswap_variable_64 ( uint64_t x ) {
-	__asm__ ( "revb.d %0, %1" : "=r" ( x ) : "r" ( x ) );
-	return x;
-}
-
-static inline __attribute__ (( always_inline )) void
-__bswap_64s ( uint64_t *x ) {
-	*x = __bswap_variable_64 ( *x );
-}
-
-#endif

src/arch/loong64/include/bits/compiler.h

@@ -1,19 +0,0 @@
-#ifndef _BITS_COMPILER_H
-#define _BITS_COMPILER_H
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-/** Dummy relocation type */
-#define RELOC_TYPE_NONE R_LARCH_NONE
-
-#ifndef ASSEMBLY
-
-/** Unprefixed constant operand modifier */
-#define ASM_NO_PREFIX "a"
-
-#define __asmcall
-#define __libgcc
-
-#endif /* ASSEMBLY */
-
-#endif /*_BITS_COMPILER_H */

src/arch/loong64/include/bits/endian.h

@@ -1,8 +0,0 @@
-#ifndef _BITS_ENDIAN_H
-#define _BITS_ENDIAN_H
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#define __BYTE_ORDER __LITTLE_ENDIAN
-
-#endif /* _BITS_ENDIAN_H */

src/arch/loong64/include/bits/errfile.h

@@ -1,19 +0,0 @@
-#ifndef _BITS_ERRFILE_H
-#define _BITS_ERRFILE_H
-
-/** @file
- *
- * LoongArch64-specific error file identifiers
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-/**
- * @addtogroup errfile Error file identifiers
- * @{
- */
-
-/** @} */
-
-#endif /* _BITS_ERRFILE_H */

src/arch/loong64/include/bits/hyperv.h

@@ -1,12 +0,0 @@
-#ifndef _BITS_HYPERV_H
-#define _BITS_HYPERV_H
-
-/** @file
- *
- * Hyper-V interface
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_HYPERV_H */

src/arch/loong64/include/bits/io.h

@@ -1,17 +0,0 @@
-#ifndef _BITS_IO_H
-#define _BITS_IO_H
-
-/** @file
- *
- * LoongArch64-specific I/O API implementations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-/** Page shift */
-#define PAGE_SHIFT 12
-
-#include <ipxe/loong64_io.h>
-
-#endif /* _BITS_IO_H */

src/arch/loong64/include/bits/iomap.h

@@ -1,12 +0,0 @@
-#ifndef _BITS_IOMAP_H
-#define _BITS_IOMAP_H
-
-/** @file
- *
- * LoongArch64-specific I/O mapping API implementations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_IOMAP_H */

src/arch/loong64/include/bits/mp.h

@@ -1,12 +0,0 @@
-#ifndef _BITS_MP_H
-#define _BITS_MP_H
-
-/** @file
- *
- * LoongArch64-specific multiprocessor API implementation
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_MP_H */

src/arch/loong64/include/bits/nap.h

@@ -1,14 +0,0 @@
-#ifndef _BITS_NAP_H
-#define _BITS_NAP_H
-
-/** @file
- *
- * LoongArch64-specific CPU sleeping API implementations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <ipxe/efi/efiloong64_nap.h>
-
-#endif /* _BITS_NAP_H */

src/arch/loong64/include/bits/pci_io.h

@@ -1,12 +0,0 @@
-#ifndef _BITS_PCI_IO_H
-#define _BITS_PCI_IO_H
-
-/** @file
- *
- * LoongArch64-specific PCI I/O API implementations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_PCI_IO_H */

src/arch/loong64/include/bits/profile.h

@@ -1,28 +0,0 @@
-#ifndef _BITS_PROFILE_H
-#define _BITS_PROFILE_H
-
-/** @file
- *
- * Profiling
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <stdint.h>
-
-/**
- * Get profiling timestamp
- *
- * @ret timestamp	Timestamp
- */
-static inline __attribute__ (( always_inline )) uint64_t
-profile_timestamp ( void ) {
-	uint64_t cycles;
-
-	/* Read cycle counter */
-	__asm__ __volatile__ ( "rdtime.d %0, $zero\n\t" : "=r" ( cycles ) );
-	return cycles;
-}
-
-#endif /* _BITS_PROFILE_H */

src/arch/loong64/include/bits/reboot.h

@@ -1,12 +0,0 @@
-#ifndef _BITS_REBOOT_H
-#define _BITS_REBOOT_H
-
-/** @file
- *
- * LoongArch64-specific reboot API implementations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_REBOOT_H */

src/arch/loong64/include/bits/sanboot.h

@@ -1,12 +0,0 @@
-#ifndef _BITS_SANBOOT_H
-#define _BITS_SANBOOT_H
-
-/** @file
- *
- * LoongArch64-specific sanboot API implementations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_SANBOOT_H */

src/arch/loong64/include/bits/smbios.h

@@ -1,12 +0,0 @@
-#ifndef _BITS_SMBIOS_H
-#define _BITS_SMBIOS_H
-
-/** @file
- *
- * LoongArch64-specific SMBIOS API implementations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_SMBIOS_H */

src/arch/loong64/include/bits/stdint.h

@@ -1,23 +0,0 @@
-#ifndef _BITS_STDINT_H
-#define _BITS_STDINT_H
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-typedef __SIZE_TYPE__		size_t;
-typedef signed long		ssize_t;
-typedef signed long		off_t;
-
-typedef unsigned char		uint8_t;
-typedef unsigned short		uint16_t;
-typedef unsigned int		uint32_t;
-typedef unsigned long long	uint64_t;
-
-typedef signed char		int8_t;
-typedef signed short		int16_t;
-typedef signed int		int32_t;
-typedef signed long long	int64_t;
-
-typedef unsigned long		physaddr_t;
-typedef unsigned long		intptr_t;
-
-#endif /* _BITS_STDINT_H */

src/arch/loong64/include/bits/string.h

@@ -1,61 +0,0 @@
-#ifndef _BITS_STRING_H
-#define _BITS_STRING_H
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-/** @file
- *
- * String functions
- *
- */
-
-extern void loong64_bzero ( void *dest, size_t len );
-extern void loong64_memset ( void *dest, size_t len, int character );
-extern void loong64_memcpy ( void *dest, const void *src, size_t len );
-extern void loong64_memmove_forwards ( void *dest, const void *src, size_t len );
-extern void loong64_memmove_backwards ( void *dest, const void *src, size_t len );
-extern void loong64_memmove ( void *dest, const void *src, size_t len );
-
-/**
- * Fill memory region
- *
- * @v dest		Destination region
- * @v character		Fill character
- * @v len		Length
- * @ret dest		Destination region
- */
-static inline __attribute__ (( always_inline )) void *
-memset ( void *dest, int character, size_t len ) {
-	loong64_memset ( dest, len, character );
-	return dest;
-}
-
-/**
- * Copy memory region
- *
- * @v dest		Destination region
- * @v src		Source region
- * @v len		Length
- * @ret dest		Destination region
- */
-static inline __attribute__ (( always_inline )) void *
-memcpy ( void *dest, const void *src, size_t len ) {
-	loong64_memcpy ( dest, src, len );
-	return dest;
-}
-
-/**
- * Copy (possibly overlapping) memory region
- *
- * @v dest		Destination region
- * @v src		Source region
- * @v len		Length
- * @ret dest		Destination region
- */
-static inline __attribute__ (( always_inline )) void *
-memmove ( void *dest, const void *src, size_t len ) {
-	loong64_memmove ( dest, src, len );
-	return dest;
-}
-
-#endif /* _BITS_STRING_H */

src/arch/loong64/include/bits/strings.h

@@ -1,69 +0,0 @@
-#ifndef _BITS_STRINGS_H
-#define _BITS_STRINGS_H
-
-/** @file
- *
- * String functions
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-/**
- * Find first (i.e. least significant) set bit
- *
- * @v value		Value
- * @ret lsb		Least significant bit set in value (LSB=1), or zero
- */
-static inline __attribute__ (( always_inline )) int __ffsll ( long long value ){
-	unsigned long long bits = value;
-	unsigned long long lsb;
-	unsigned int lz;
-
-	/* Extract least significant set bit */
-	lsb = ( bits & -bits );
-
-	/* Count number of leading zeroes before LSB */
-	__asm__ ( "clz.d %0, %1" : "=r" ( lz ) : "r" ( lsb ) );
-
-	return ( 64 - lz );
-}
-
-/**
- * Find first (i.e. least significant) set bit
- *
- * @v value		Value
- * @ret lsb		Least significant bit set in value (LSB=1), or zero
- */
-static inline __attribute__ (( always_inline )) int __ffsl ( long value ) {
-
-	return __ffsll ( value );
-}
-
-/**
- * Find last (i.e. most significant) set bit
- *
- * @v value		Value
- * @ret msb		Most significant bit set in value (LSB=1), or zero
- */
-static inline __attribute__ (( always_inline )) int __flsll ( long long value ){
-	unsigned int lz;
-
-	/* Count number of leading zeroes */
-	__asm__ ( "clz.d %0, %1" : "=r" ( lz ) : "r" ( value ) );
-
-	return ( 64 - lz );
-}
-
-/**
- * Find last (i.e. most significant) set bit
- *
- * @v value		Value
- * @ret msb		Most significant bit set in value (LSB=1), or zero
- */
-static inline __attribute__ (( always_inline )) int __flsl ( long value ) {
-
-	return __flsll ( value );
-}
-
-#endif /* _BITS_STRINGS_H */

src/arch/loong64/include/bits/tcpip.h

@@ -1,19 +0,0 @@
-#ifndef _BITS_TCPIP_H
-#define _BITS_TCPIP_H
-
-/** @file
- *
- * Transport-network layer interface
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-static inline __attribute__ (( always_inline )) uint16_t
-tcpip_continue_chksum ( uint16_t partial, const void *data, size_t len ) {
-
-	/* Not yet optimised */
-	return generic_tcpip_continue_chksum ( partial, data, len );
-}
-
-#endif /* _BITS_TCPIP_H */

src/arch/loong64/include/bits/time.h

@@ -1,12 +0,0 @@
-#ifndef _BITS_TIME_H
-#define _BITS_TIME_H
-
-/** @file
- *
- * LoongArch64-specific time API implementations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_TIME_H */

src/arch/loong64/include/bits/uaccess.h

@@ -1,12 +0,0 @@
-#ifndef _BITS_UACCESS_H
-#define _BITS_UACCESS_H
-
-/** @file
- *
- * LoongArch64-specific user access API implementations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_UACCESS_H */

src/arch/loong64/include/bits/uart.h

@@ -1,12 +0,0 @@
-#ifndef _BITS_UART_H
-#define _BITS_UART_H
-
-/** @file
- *
- * 16550-compatible UART
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_UART_H */

src/arch/loong64/include/bits/umalloc.h

@@ -1,12 +0,0 @@
-#ifndef _BITS_UMALLOC_H
-#define _BITS_UMALLOC_H
-
-/** @file
- *
- * LoongArch64-specific user memory allocation API implementations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_UMALLOC_H */

src/arch/loong64/include/bits/xen.h

@@ -1,13 +0,0 @@
-#ifndef _BITS_XEN_H
-#define _BITS_XEN_H
-
-/** @file
- *
- * Xen interface
- *
- */
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <ipxe/nonxen.h>
-
-#endif /* _BITS_XEN_H */

src/arch/loong64/include/gdbmach.h

@@ -1,45 +0,0 @@
-#ifndef GDBMACH_H
-#define GDBMACH_H
-
-/** @file
- *
- * GDB architecture specifics
- *
- * This file declares functions for manipulating the machine state and
- * debugging context.
- *
- */
-
-#include <stdint.h>
-
-typedef unsigned long gdbreg_t;
-
-/* Register snapshot */
-enum {
-	/* Not yet implemented */
-	GDBMACH_NREGS,
-};
-
-#define GDBMACH_SIZEOF_REGS ( GDBMACH_NREGS * sizeof ( gdbreg_t ) )
-
-static inline void gdbmach_set_pc ( gdbreg_t *regs, gdbreg_t pc ) {
-	/* Not yet implemented */
-	( void ) regs;
-	( void ) pc;
-}
-
-static inline void gdbmach_set_single_step ( gdbreg_t *regs, int step ) {
-	/* Not yet implemented */
-	( void ) regs;
-	( void ) step;
-}
-
-static inline void gdbmach_breakpoint ( void ) {
-	/* Not yet implemented */
-}
-
-extern int gdbmach_set_breakpoint ( int type, unsigned long addr, size_t len,
-				    int enable );
-extern void gdbmach_init ( void );
-
-#endif /* GDBMACH_H */

src/arch/loong64/include/ipxe/efi/dhcparch.h

@@ -1,20 +0,0 @@
-#ifndef _IPXE_EFI_DHCPARCH_H
-#define _IPXE_EFI_DHCPARCH_H
-
-/** @file
- *
- * DHCP client architecture definitions
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <ipxe/dhcp.h>
-
-/** DHCP client architecture */
-#define DHCP_ARCH_CLIENT_ARCHITECTURE DHCP_CLIENT_ARCHITECTURE_LOONG64
-
-/** DHCP client network device interface */
-#define DHCP_ARCH_CLIENT_NDI 1 /* UNDI */ , 3, 10 /* v3.10 */
-
-#endif /* _IPXE_EFI_DHCPARCH_H */

src/arch/loong64/include/ipxe/efi/efiloong64_nap.h

@@ -1,18 +0,0 @@
-#ifndef _IPXE_EFILOONG64_NAP_H
-#define _IPXE_EFILOONG64_NAP_H
-
-/** @file
- *
- * EFI CPU sleeping
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#ifdef NAP_EFILOONG64
-#define NAP_PREFIX_efiloong64
-#else
-#define NAP_PREFIX_efiloong64 __efiloong64_
-#endif
-
-#endif /* _IPXE_EFILOONG64_NAP_H */

src/arch/loong64/include/ipxe/loong64_io.h

@@ -1,82 +0,0 @@
-#ifndef _IPXE_LOONG64_IO_H
-#define _IPXE_LOONG64_IO_H
-
-/** @file
- *
- * iPXE I/O API for LoongArch64
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#ifdef IOAPI_LOONG64
-#define IOAPI_PREFIX_loong64
-#else
-#define IOAPI_PREFIX_loong64 __loong64_
-#endif
-
-#include <ipxe/dummy_pio.h>
-
-/*
- * Memory space mappings
- *
- */
-
-/*
- * Physical<->Bus address mappings
- *
- */
-
-static inline __always_inline unsigned long
-IOAPI_INLINE ( loong64, phys_to_bus ) ( unsigned long phys_addr ) {
-	return phys_addr;
-}
-
-static inline __always_inline unsigned long
-IOAPI_INLINE ( loong64, bus_to_phys ) ( unsigned long bus_addr ) {
-	return bus_addr;
-}
-
-/*
- * MMIO reads and writes up to native word size
- *
- */
-
-#define LOONG64_READX( _suffix, _type, _insn_suffix )			      \
-static inline __always_inline _type					      \
-IOAPI_INLINE ( loong64, read ## _suffix ) ( volatile _type *io_addr ) {	      \
-	_type data;							      \
-	__asm__ __volatile__ ( "ld." _insn_suffix " %0, %1"		      \
-			       : "=r" ( data ) : "m" ( *io_addr ) );	      \
-	return data;							      \
-}
-LOONG64_READX ( b, uint8_t, "bu");
-LOONG64_READX ( w, uint16_t, "hu");
-LOONG64_READX ( l, uint32_t, "wu");
-LOONG64_READX ( q, uint64_t, "d");
-
-#define LOONG64_WRITEX( _suffix, _type, _insn_suffix )			      \
-static inline __always_inline void					      \
-IOAPI_INLINE ( loong64, write ## _suffix ) ( _type data,		      \
-					     volatile _type *io_addr ) {      \
-	__asm__ __volatile__ ( "st." _insn_suffix " %0, %1"		      \
-			       : : "r" ( data ), "m" ( *io_addr ) );	      \
-}
-LOONG64_WRITEX ( b, uint8_t, "b");
-LOONG64_WRITEX ( w, uint16_t, "h");
-LOONG64_WRITEX ( l, uint32_t, "w" );
-LOONG64_WRITEX ( q, uint64_t, "d");
-
-/*
- * Memory barrier
- *
- */
-static inline __always_inline void
-IOAPI_INLINE ( loong64, mb ) ( void ) {
-	__asm__ __volatile__ ( "dbar 0" );
-}
-
-/* Dummy PIO */
-DUMMY_PIO ( loong64 );
-
-#endif /* _IPXE_LOONG64_IO_H */

src/arch/loong64/include/limits.h

@@ -1,53 +0,0 @@
-#ifndef LIMITS_H
-#define LIMITS_H	1
-
-/* Number of bits in a `char' */
-#define CHAR_BIT	8
-
-/* Minimum and maximum values a `signed char' can hold */
-#define SCHAR_MIN	(-128)
-#define SCHAR_MAX	127
-
-/* Maximum value an `unsigned char' can hold. (Minimum is 0.) */
-#define UCHAR_MAX	255
-
-/* Minimum and maximum values a `char' can hold */
-#define CHAR_MIN	SCHAR_MIN
-#define CHAR_MAX	SCHAR_MAX
-
-/* Minimum and maximum values a `signed short int' can hold */
-#define SHRT_MIN	(-32768)
-#define SHRT_MAX	32767
-
-/* Maximum value an `unsigned short' can hold. (Minimum is 0.) */
-#define USHRT_MAX	65535
-
-/* Minimum and maximum values a `signed int' can hold */
-#define INT_MIN		(-INT_MAX - 1)
-#define INT_MAX		2147483647
-
-/* Maximum value an `unsigned int' can hold. (Minimum is 0.) */
-#define UINT_MAX	4294967295U
-
-/* Minimum and maximum values a `signed int' can hold */
-#define INT_MAX		2147483647
-#define INT_MIN		(-INT_MAX - 1)
-
-/* Maximum value an `unsigned int' can hold. (Minimum is 0.) */
-#define UINT_MAX	4294967295U
-
-/* Minimum and maximum values a `signed long' can hold */
-#define LONG_MAX	9223372036854775807L
-#define LONG_MIN	(-LONG_MAX - 1L)
-
-/* Maximum value an `unsigned long' can hold. (Minimum is 0.) */
-#define ULONG_MAX	18446744073709551615UL
-
-/* Minimum and maximum values a `signed long long' can hold */
-#define LLONG_MAX	9223372036854775807LL
-#define LLONG_MIN	(-LONG_MAX - 1LL)
-
-/* Maximum value an `unsigned long long' can hold. (Minimum is 0.) */
-#define ULLONG_MAX	18446744073709551615ULL
-
-#endif /* LIMITS_H */

src/arch/loong64/include/setjmp.h

@@ -1,31 +0,0 @@
-#ifndef _SETJMP_H
-#define _SETJMP_H
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <stdint.h>
-
-/** jump buffer env*/
-typedef struct {
-	uint64_t s0;
-	uint64_t s1;
-	uint64_t s2;
-	uint64_t s3;
-	uint64_t s4;
-	uint64_t s5;
-	uint64_t s6;
-	uint64_t s7;
-	uint64_t s8;
-
-	uint64_t fp;
-	uint64_t sp;
-	uint64_t ra;
-} jmp_buf[1];
-
-extern int __asmcall __attribute__ (( returns_twice ))
-setjmp ( jmp_buf env );
-
-extern void __asmcall __attribute__ (( noreturn ))
-longjmp ( jmp_buf env, int val );
-
-#endif /* _SETJMP_H */

src/arch/loong64/interface/efi/efiloong64_nap.c

@@ -1,57 +0,0 @@
-/*
- * Copyright (c) 2023, Xiaotian Wu <wuxiaotian@loongson.cn>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- *
- * You can also choose to distribute this program under the terms of
- * the Unmodified Binary Distribution Licence (as given in the file
- * COPYING.UBDL), provided that you have satisfied its requirements.
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <ipxe/nap.h>
-#include <ipxe/efi/efi.h>
-
-/** @file
- *
- * iPXE CPU sleeping API for EFI
- *
- */
-
-/**
- * Sleep until next interrupt
- *
- */
-static void efiloong64_cpu_nap ( void ) {
-	/*
-	 * I can't find any EFI API that allows us to put the CPU to
-	 * sleep.  The CpuSleep() function is defined in CpuLib.h, but
-	 * isn't part of any exposed protocol so we have no way to
-	 * call it.
-	 *
-	 * The EFI shell doesn't seem to bother sleeping the CPU; it
-	 * just sits there idly burning power.
-	 *
-	 * If a shutdown is in progess, there may be nothing to
-	 * generate an interrupt since the timer is disabled in the
-	 * first step of ExitBootServices().
-	 */
-	if ( ! efi_shutdown_in_progress )
-		__asm__ __volatile__ ( "idle 0" );
-}
-
-PROVIDE_NAP ( efiloong64, cpu_nap, efiloong64_cpu_nap );

src/arch/x86/Makefile.pcbios

@@ -13,13 +13,6 @@ LDSCRIPT_PREFIX	= arch/x86/scripts/prefixonly.lds
 #
 LDFLAGS		+= -N --no-check-sections
 
-# Do not warn about RWX segments (required by most prefixes)
-#
-WRWX_TEST	= $(LD) --warn-rwx-segments --version 2>&1 > /dev/null
-WRWX_FLAGS	:= $(shell [ -z "`$(WRWX_TEST)`" ] && \
-		     $(ECHO) '--no-warn-rwx-segments')
-LDFLAGS		+= $(WRWX_FLAGS)
-
 # Media types.
 #
 MEDIA		+= rom
@@ -61,15 +54,9 @@ LIST_NAME_mrom := ROMS
 LIST_NAME_pcirom := ROMS
 LIST_NAME_isarom := ROMS
 
-# ISO images
+# ISO or FAT filesystem images
 NON_AUTO_MEDIA	+= iso
-$(BIN)/%.iso : $(BIN)/%.lkrn util/genfsimg
-	$(QM)$(ECHO) "  [GENFSIMG] $@"
-	$(Q)util/genfsimg -o $@ $<
-
-# FAT filesystem images (via syslinux)
-NON_AUTO_MEDIA	+= sdsk
-$(BIN)/%.sdsk : $(BIN)/%.lkrn util/genfsimg
+$(BIN)/%.iso $(BIN)/%.sdsk: $(BIN)/%.lkrn util/genfsimg
 	$(QM)$(ECHO) "  [GENFSIMG] $@"
 	$(Q)util/genfsimg -o $@ $<
 

src/arch/x86/core/mpcall.S

@@ -1,197 +0,0 @@
-/*
- * Copyright (C) 2024 Michael Brown <mbrown@fensystems.co.uk>.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- *
- * You can also choose to distribute this program under the terms of
- * the Unmodified Binary Distribution Licence (as given in the file
- * COPYING.UBDL), provided that you have satisfied its requirements.
- */
-
-	FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
-
-/** @file
- *
- * Multiprocessor functions
- *
- */
-
-	.section ".note.GNU-stack", "", @progbits
-	.text
-
-/* Selectively assemble code for 32-bit/64-bit builds */
-#if defined ( __x86_64__ ) && ! defined ( PLATFORM_pcbios )
-#define codemp code64
-#define DI rdi
-#define SP rsp
-#define if32 if 0
-#define if64 if 1
-#else
-#define codemp code32
-#define DI edi
-#define SP esp
-#define if32 if 1
-#define if64 if 0
-#endif
-
-/* Standard features CPUID leaf */
-#define CPUID_FEATURES 0x00000001
-
-/* x2APIC is supported */
-#define CPUID_FEATURES_ECX_X2APIC 0x00200000
-
-/* Extended topology enumeration CPUID leaf */
-#define CPUID_XT_ENUM 0x0000000b
-
-/*
- * Call multiprocessor function from C code
- *
- * Parameters:
- *	4(%esp)/%rdi	Multiprocessor function
- *	8(%esp)/%rsi	Opaque data pointer
- */
-	.section ".text.mp_call", "ax", @progbits
-	.codemp
-	.globl	mp_call
-mp_call:
-.if64	/* Preserve registers, load incoming parameters into registers */
-	pushq	%rax
-	pushq	%rcx
-	pushq	%rdx
-	pushq	%rbx
-	pushq	%rsp
-	pushq	%rbp
-	pushq	%rsi
-	pushq	%rdi
-	pushq	%r8
-	pushq	%r9
-	pushq	%r10
-	pushq	%r11
-	pushq	%r12
-	pushq	%r13
-	pushq	%r14
-	pushq	%r15
-.else
-	pushal
-	movl	36(%esp), %eax
-	movl	40(%esp), %edx
-.endif
-	/* Call multiprocessor function */
-	call	mp_jump
-
-.if64	/* Restore registers and return */
-	popq	%r15
-	popq	%r14
-	popq	%r13
-	popq	%r12
-	popq	%r11
-	popq	%r10
-	popq	%r9
-	popq	%r8
-	popq	%rdi
-	popq	%rsi
-	popq	%rbp
-	leaq	8(%rsp), %rsp /* discard */
-	popq	%rbx
-	popq	%rdx
-	popq	%rcx
-	popq	%rax
-.else
-	popal
-.endif
-	ret
-	.size	mp_call, . - mp_call
-
-/*
- * Jump to multiprocessor function
- *
- * Parameters:
- *	%eax/%rdi	Multiprocessor function
- *	%edx/%rsi	Opaque data pointer
- *	%esp/%rsp	Stack, or NULL to halt AP upon completion
- *
- * Obtain the CPU identifier (i.e. the APIC ID) and perform a tail
- * call into the specified multiprocessor function.
- *
- * This code may run with no stack on an application processor.
- */
-	.section ".text.mp_jump", "ax", @progbits
-	.codemp
-	.globl	mp_jump
-mp_jump:
-.if32	/* Move function parameters to available registers */
-	movl	%eax, %edi
-	movl	%edx, %esi
-.endif
-
-	/* Get 8-bit APIC ID and x2APIC feature bit */
-	movl	$CPUID_FEATURES, %eax
-	cpuid
-	shrl	$24, %ebx
-	movl	%ebx, %edx
-
-	/* Get 32-bit x2APIC ID if applicable */
-	testl	$CPUID_FEATURES_ECX_X2APIC, %ecx
-	jz	1f
-	movl	$CPUID_XT_ENUM, %eax
-	xorl	%ecx, %ecx
-	cpuid
-1:
-
-.if64	/* Tail call to function */
-	movq	%rdi, %rax
-	movq	%rsi, %rdi
-	movl	%edx, %esi
-	jmp	*%rax
-.else
-	movl	%esi, %eax
-	jmp	*%edi
-.endif
-	.size	mp_jump, . - mp_jump
-
-/*
- * Update maximum CPU identifier
- *
- * Parameters:
- *	%eax/%rdi	Pointer to shared maximum APIC ID
- *	%edx/%rsi	CPU identifier (APIC ID)
- *	%esp/%rsp	Stack, or NULL to halt AP upon completion
- *
- * This code may run with no stack on an application processor.
- */
-	.section ".text.mp_update_max_cpuid", "ax", @progbits
-	.codemp
-	.globl	mp_update_max_cpuid
-mp_update_max_cpuid:
-.if32	/* Move function parameters to available registers */
-	movl	%eax, %edi
-	movl	%edx, %esi
-.endif
-	/* Update maximum APIC ID (atomically) */
-	movl	(%DI), %eax
-1:	cmpl	%esi, %eax
-	jae	2f
-	lock cmpxchgl %esi, (%DI)
-	jnz	1b
-2:
-	/* Return to caller (if stack exists), or halt application processor */
-	test	%SP, %SP
-	jz	3f
-	ret
-3:	cli
-	hlt
-	jmp	3b
-	.size	mp_update_max_cpuid, . - mp_update_max_cpuid

src/arch/x86/core/patch_cf.S

@@ -22,9 +22,9 @@
 
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
 
-	.section ".note.GNU-stack", "", @progbits
-	.code16
+	.text
 	.arch i386
+	.code16
 
 /****************************************************************************
  * Set/clear CF on the stack as appropriate, assumes stack is as it should

src/arch/x86/core/rdrand.c

@@ -1,103 +0,0 @@
-/*
- * Copyright (C) 2023 Michael Brown <mbrown@fensystems.co.uk>.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- *
- * You can also choose to distribute this program under the terms of
- * the Unmodified Binary Distribution Licence (as given in the file
- * COPYING.UBDL), provided that you have satisfied its requirements.
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-/** @file
- *
- * Hardware random number generator
- *
- */
-
-#include <errno.h>
-#include <ipxe/cpuid.h>
-#include <ipxe/entropy.h>
-#include <ipxe/drbg.h>
-
-struct entropy_source rdrand_entropy __entropy_source ( ENTROPY_PREFERRED );
-
-/** Number of times to retry RDRAND instruction */
-#define RDRAND_RETRY_COUNT 16
-
-/** Colour for debug messages */
-#define colour &rdrand_entropy
-
-/**
- * Enable entropy gathering
- *
- * @ret rc		Return status code
- */
-static int rdrand_entropy_enable ( void ) {
-	struct x86_features features;
-
-	/* Check that RDRAND is supported */
-	x86_features ( &features );
-	if ( ! ( features.intel.ecx & CPUID_FEATURES_INTEL_ECX_RDRAND ) ) {
-		DBGC ( colour, "RDRAND not supported\n" );
-		return -ENOTSUP;
-	}
-
-	/* Data returned by RDRAND is theoretically full entropy, up
-	 * to a security strength of 128 bits, so assume that each
-	 * sample contains exactly 8 bits of entropy.
-	 */
-	if ( DRBG_SECURITY_STRENGTH > 128 )
-		return -ENOTSUP;
-	entropy_init ( &rdrand_entropy, MIN_ENTROPY ( 8.0 ) );
-
-	return 0;
-}
-
-/**
- * Get noise sample
- *
- * @ret noise		Noise sample
- * @ret rc		Return status code
- */
-static int rdrand_get_noise ( noise_sample_t *noise ) {
-	unsigned int result;
-	unsigned int discard_c;
-	unsigned int ok;
-
-	/* Issue RDRAND, retrying until CF is set */
-	__asm__ ( "\n1:\n\t"
-		  "rdrand %0\n\t"
-		  "sbb %1, %1\n\t"
-		  "loopz 1b\n\t"
-		  : "=r" ( result ), "=r" ( ok ), "=c" ( discard_c )
-		  : "2" ( RDRAND_RETRY_COUNT ) );
-	if ( ! ok ) {
-		DBGC ( colour, "RDRAND failed to become ready\n" );
-		return -EBUSY;
-	}
-
-	*noise = result;
-	return 0;
-}
-
-/** Hardware random number generator entropy source */
-struct entropy_source rdrand_entropy __entropy_source ( ENTROPY_PREFERRED ) = {
-	.name = "rdrand",
-	.enable = rdrand_entropy_enable,
-	.get_noise = rdrand_get_noise,
-};

src/arch/x86/core/stack.S

@@ -1,6 +1,6 @@
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
 
-	.section ".note.GNU-stack", "", @progbits
+	.arch i386
 
 #ifdef __x86_64__
 #define STACK_SIZE 8192

src/arch/x86/core/stack16.S

@@ -1,6 +1,6 @@
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
 
-	.section ".note.GNU-stack", "", @progbits
+	.arch i386
 
 /****************************************************************************
  * Internal stack

src/arch/x86/core/ucode_mp.S

@@ -1,257 +0,0 @@
-/*
- * Copyright (C) 2024 Michael Brown <mbrown@fensystems.co.uk>.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- *
- * You can also choose to distribute this program under the terms of
- * the Unmodified Binary Distribution Licence (as given in the file
- * COPYING.UBDL), provided that you have satisfied its requirements.
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-/** @file
- *
- * Microcode updates
- *
- */
-
-	.section ".note.GNU-stack", "", @progbits
-	.text
-
-/* Selectively assemble code for 32-bit/64-bit builds */
-#if defined ( __x86_64__ ) && ! defined ( PLATFORM_pcbios )
-#define codemp code64
-#define AX rax
-#define BX rbx
-#define CX rcx
-#define DX rdx
-#define SI rsi
-#define DI rdi
-#define BP rbp
-#define SP rsp
-#define if32 if 0
-#define if64 if 1
-#else
-#define codemp code32
-#define AX eax
-#define BX ebx
-#define CX ecx
-#define DX edx
-#define SI esi
-#define DI edi
-#define BP ebp
-#define SP esp
-#define if32 if 1
-#define if64 if 0
-#endif
-
-/* Standard features CPUID leaf */
-#define CPUID_FEATURES 0x00000001
-
-/* BIOS update signature MSR */
-#define MSR_BIOS_SIGN_ID 0x0000008b
-
-/** Microcode update control layout
- *
- * This must match the layout of struct ucode_control.
- */
-	.struct	0
-CONTROL_DESC:
-	.space	8
-CONTROL_STATUS:
-	.space	8
-CONTROL_TRIGGER_MSR:
-	.space	4
-CONTROL_APIC_MAX:
-	.space	4
-CONTROL_APIC_UNEXPECTED:
-	.space	4
-CONTROL_APIC_MASK:
-	.space	4
-CONTROL_APIC_TEST:
-	.space	4
-CONTROL_VER_CLEAR:
-	.space	1
-CONTROL_VER_HIGH:
-	.space	1
-CONTROL_LEN:
-
-/* We use register %ebp/%rbp to hold the address of the update control */
-#define CONTROL BP
-
-/* Microcode update descriptor layout
- *
- * This must match the layout of struct ucode_descriptor.
- */
-	.struct	0
-DESC_SIGNATURE:
-	.space	4
-DESC_VERSION:
-	.space	4
-DESC_ADDRESS:
-	.space	8
-DESC_LEN:
-
-/* We use register %esi/%rsi to hold the address of the descriptor */
-#define DESC SI
-
-/** Microcode update status report layout
- *
- * This must match the layout of struct ucode_status.
- */
-	.struct	0
-STATUS_SIGNATURE:
-	.space	4
-STATUS_ID:
-	.space	4
-STATUS_BEFORE:
-	.space	4
-STATUS_AFTER:
-	.space	4
-STATUS_LEN:
-	.equ	LOG2_STATUS_LEN, 4
-	.if	( 1 << LOG2_STATUS_LEN ) - STATUS_LEN
-	.error	"LOG2_STATUS_LEN value is incorrect"
-	.endif
-
-/* We use register %edi/%rdi to hold the address of the status report */
-#define STATUS DI
-
-/*
- * Update microcode
- *
- * Parameters:
- *	%eax/%rdi	Microcode update structure
- *	%edx/%rsi	CPU identifier (APIC ID)
- *	%esp/%rsp	Stack, or NULL to halt AP upon completion
- *
- * This code may run with no stack on an application processor (AP).
- * All values must be held in registers, and no subroutine calls are
- * possible.  No firmware routines may be called.
- *
- * Since cpuid/rdmsr/wrmsr require the use of %eax, %ebx, %ecx, and
- * %edx, we have essentially only three registers available for
- * long-term state.
- */
-	.text
-	.globl	ucode_update
-	.codemp
-	.section ".text.ucode_update", "ax", @progbits
-ucode_update:
-
-.if64	/* Get input parameters */
-	movq	%rdi, %CONTROL
-	movl	%esi, %edx
-.else
-	movl	%eax, %CONTROL
-.endif
-	/* Check against maximum expected APIC ID */
-	cmpl	CONTROL_APIC_MAX(%CONTROL), %edx
-	jbe	1f
-	movl	%edx, CONTROL_APIC_UNEXPECTED(%CONTROL)
-	jmp	done
-1:
-	/* Calculate per-CPU status report buffer address */
-	mov	%DX, %STATUS
-	shl	$LOG2_STATUS_LEN, %STATUS
-	add	CONTROL_STATUS(%CONTROL), %STATUS
-
-	/* Report APIC ID */
-	movl	%edx, STATUS_ID(%STATUS)
-
-	/* Get and report CPU signature */
-	movl	$CPUID_FEATURES, %eax
-	cpuid
-	movl	%eax, STATUS_SIGNATURE(%STATUS)
-
-	/* Check APIC ID mask */
-	movl	STATUS_ID(%STATUS), %eax
-	andl	CONTROL_APIC_MASK(%CONTROL), %eax
-	cmpl	CONTROL_APIC_TEST(%CONTROL), %eax
-	jne	done
-
-	/* Clear BIOS_SIGN_ID MSR if applicable */
-	movl	$MSR_BIOS_SIGN_ID, %ecx
-	xorl	%eax, %eax
-	xorl	%edx, %edx
-	testb	$0xff, CONTROL_VER_CLEAR(%CONTROL)
-	jz	1f
-	wrmsr
-1:
-	/* Get CPU signature to repopulate BIOS_SIGN_ID MSR (for Intel) */
-	movl	$CPUID_FEATURES, %eax
-	cpuid
-
-	/* Get initial microcode version */
-	movl	$MSR_BIOS_SIGN_ID, %ecx
-	rdmsr
-	testb	$0xff, CONTROL_VER_HIGH(%CONTROL)
-	jz	1f
-	movl	%edx, %eax
-1:	movl	%eax, STATUS_BEFORE(%STATUS)
-
-	/* Get start of descriptor list */
-	mov	CONTROL_DESC(%CONTROL), %DESC
-	sub	$DESC_LEN, %DESC
-
-1:	/* Walk update descriptor list to find a matching CPU signature */
-	add	$DESC_LEN, %DESC
-	movl	DESC_SIGNATURE(%DESC), %eax
-	testl	%eax, %eax
-	jz	noload
-	cmpl	STATUS_SIGNATURE(%STATUS), %eax
-	jne	1b
-
-	/* Compare (signed) microcode versions */
-	movl	STATUS_BEFORE(%STATUS), %eax
-	cmpl	DESC_VERSION(%DESC), %eax
-	jge	noload
-
-	/* Load microcode update */
-	movl	CONTROL_TRIGGER_MSR(%CONTROL), %ecx
-	movl	(DESC_ADDRESS + 0)(%DESC), %eax
-	movl	(DESC_ADDRESS + 4)(%DESC), %edx
-	wrmsr
-
-noload:	/* Clear BIOS_SIGN_ID MSR if applicable */
-	movl	$MSR_BIOS_SIGN_ID, %ecx
-	xorl	%eax, %eax
-	xorl	%edx, %edx
-	testb	$0xff, CONTROL_VER_CLEAR(%CONTROL)
-	jz	1f
-	wrmsr
-1:
-	/* Get CPU signature to repopulate BIOS_SIGN_ID MSR (for Intel) */
-	movl	$CPUID_FEATURES, %eax
-	cpuid
-
-	/* Get and report final microcode version */
-	movl	$MSR_BIOS_SIGN_ID, %ecx
-	rdmsr
-	testb	$0xff, CONTROL_VER_HIGH(%CONTROL)
-	jz	1f
-	movl	%edx, %eax
-1:	movl	%eax, STATUS_AFTER(%STATUS)
-
-done:	/* Return to caller (if stack exists), or halt application processor */
-	test	%SP, %SP
-	jz	1f
-	ret
-1:	cli
-	hlt
-	jmp	1b
-	.size	ucode_update, . - ucode_update

src/arch/x86/core/x86_bigint.c

@@ -36,23 +36,19 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  * Multiply big integers
  *
  * @v multiplicand0	Element 0 of big integer to be multiplied
- * @v multiplicand_size	Number of elements in multiplicand
  * @v multiplier0	Element 0 of big integer to be multiplied
- * @v multiplier_size	Number of elements in multiplier
  * @v result0		Element 0 of big integer to hold result
+ * @v size		Number of elements
  */
 void bigint_multiply_raw ( const uint32_t *multiplicand0,
-			   unsigned int multiplicand_size,
 			   const uint32_t *multiplier0,
-			   unsigned int multiplier_size,
-			   uint32_t *result0 ) {
-	unsigned int result_size = ( multiplicand_size + multiplier_size );
-	const bigint_t ( multiplicand_size ) __attribute__ (( may_alias ))
-		*multiplicand = ( ( const void * ) multiplicand0 );
-	const bigint_t ( multiplier_size ) __attribute__ (( may_alias ))
-		*multiplier = ( ( const void * ) multiplier0 );
-	bigint_t ( result_size ) __attribute__ (( may_alias ))
-		*result = ( ( void * ) result0 );
+			   uint32_t *result0, unsigned int size ) {
+	const bigint_t ( size ) __attribute__ (( may_alias )) *multiplicand =
+		( ( const void * ) multiplicand0 );
+	const bigint_t ( size ) __attribute__ (( may_alias )) *multiplier =
+		( ( const void * ) multiplier0 );
+	bigint_t ( size * 2 ) __attribute__ (( may_alias )) *result =
+		( ( void * ) result0 );
 	unsigned int i;
 	unsigned int j;
 	uint32_t multiplicand_element;
@@ -66,9 +62,9 @@ void bigint_multiply_raw ( const uint32_t *multiplicand0,
 	memset ( result, 0, sizeof ( *result ) );
 
 	/* Multiply integers one element at a time */
-	for ( i = 0 ; i < multiplicand_size ; i++ ) {
+	for ( i = 0 ; i < size ; i++ ) {
 		multiplicand_element = multiplicand->element[i];
-		for ( j = 0 ; j < multiplier_size ; j++ ) {
+		for ( j = 0 ; j < size ; j++ ) {
 			multiplier_element = multiplier->element[j];
 			result_elements = &result->element[ i + j ];
 			/* Perform a single multiply, and add the
@@ -77,7 +73,7 @@ void bigint_multiply_raw ( const uint32_t *multiplicand0,
 			 * never overflow beyond the end of the
 			 * result, since:
 			 *
-			 *     a < 2^{n}, b < 2^{m} => ab < 2^{n+m}
+			 *     a < 2^{n}, b < 2^{n} => ab < 2^{2n}
 			 */
 			__asm__ __volatile__ ( "mull %5\n\t"
 					       "addl %%eax, (%6,%2,4)\n\t"

src/arch/x86/drivers/net/undiisr.S

@@ -10,9 +10,9 @@ FILE_LICENCE ( GPL2_OR_LATER )
 #define PIC1_ICR 0x20
 #define PIC2_ICR 0xa0
 	
-	.section ".note.GNU-stack", "", @progbits
-	.code16
+	.text
 	.arch i386
+	.code16
 
 	.section ".text16", "ax", @progbits
 	.globl undiisr

src/arch/x86/image/bzimage.c

@@ -247,17 +247,19 @@ static void bzimage_update_header ( struct image *image,
  *
  * @v image		bzImage file
  * @v bzimg		bzImage context
+ * @v cmdline		Kernel command line
  * @ret rc		Return status code
  */
 static int bzimage_parse_cmdline ( struct image *image,
-				   struct bzimage_context *bzimg ) {
-	const char *vga;
-	const char *mem;
+				   struct bzimage_context *bzimg,
+				   char *cmdline ) {
 	char *sep;
-	char *end;
+	char *vga;
+	char *mem;
 
 	/* Look for "vga=" */
-	if ( ( vga = image_argument ( image, "vga=" ) ) ) {
+	if ( ( vga = strstr ( cmdline, "vga=" ) ) ) {
+		vga += 4;
 		sep = strchr ( vga, ' ' );
 		if ( sep )
 			*sep = '\0';
@@ -268,10 +270,10 @@ static int bzimage_parse_cmdline ( struct image *image,
 		} else if ( strcmp ( vga, "ask" ) == 0 ) {
 			bzimg->vid_mode = BZI_VID_MODE_ASK;
 		} else {
-			bzimg->vid_mode = strtoul ( vga, &end, 0 );
-			if ( *end ) {
+			bzimg->vid_mode = strtoul ( vga, &vga, 0 );
+			if ( *vga ) {
 				DBGC ( image, "bzImage %p strange \"vga=\" "
-				       "terminator '%c'\n", image, *end );
+				       "terminator '%c'\n", image, *vga );
 			}
 		}
 		if ( sep )
@@ -279,9 +281,10 @@ static int bzimage_parse_cmdline ( struct image *image,
 	}
 
 	/* Look for "mem=" */
-	if ( ( mem = image_argument ( image, "mem=" ) ) ) {
-		bzimg->mem_limit = strtoul ( mem, &end, 0 );
-		switch ( *end ) {
+	if ( ( mem = strstr ( cmdline, "mem=" ) ) ) {
+		mem += 4;
+		bzimg->mem_limit = strtoul ( mem, &mem, 0 );
+		switch ( *mem ) {
 		case 'G':
 		case 'g':
 			bzimg->mem_limit <<= 10;
@@ -299,7 +302,7 @@ static int bzimage_parse_cmdline ( struct image *image,
 			break;
 		default:
 			DBGC ( image, "bzImage %p strange \"mem=\" "
-			       "terminator '%c'\n", image, *end );
+			       "terminator '%c'\n", image, *mem );
 			break;
 		}
 		bzimg->mem_limit -= 1;
@@ -313,10 +316,11 @@ static int bzimage_parse_cmdline ( struct image *image,
  *
  * @v image		bzImage image
  * @v bzimg		bzImage context
+ * @v cmdline		Kernel command line
  */
 static void bzimage_set_cmdline ( struct image *image,
-				  struct bzimage_context *bzimg ) {
-	const char *cmdline = ( image->cmdline ? image->cmdline : "" );
+				  struct bzimage_context *bzimg,
+				  const char *cmdline ) {
 	size_t cmdline_len;
 
 	/* Copy command line down to real-mode portion */
@@ -355,8 +359,8 @@ static size_t bzimage_load_initrd ( struct image *image,
 	size_t offset;
 	size_t pad_len;
 
-	/* Skip hidden images */
-	if ( initrd->flags & IMAGE_HIDDEN )
+	/* Do not include kernel image itself as an initrd */
+	if ( initrd == image )
 		return 0;
 
 	/* Create cpio header for non-prebuilt images */
@@ -406,6 +410,10 @@ static int bzimage_check_initrds ( struct image *image,
 	/* Calculate total loaded length of initrds */
 	for_each_image ( initrd ) {
 
+		/* Skip kernel */
+		if ( initrd == image )
+			continue;
+
 		/* Calculate length */
 		len += bzimage_load_initrd ( image, initrd, UNULL );
 		len = bzimage_align ( len );
@@ -520,6 +528,7 @@ static void bzimage_load_initrds ( struct image *image,
  */
 static int bzimage_exec ( struct image *image ) {
 	struct bzimage_context bzimg;
+	char *cmdline = ( image->cmdline ? image->cmdline : "" );
 	int rc;
 
 	/* Read and parse header from image */
@@ -542,7 +551,7 @@ static int bzimage_exec ( struct image *image ) {
 	}
 
 	/* Parse command line for bootloader parameters */
-	if ( ( rc = bzimage_parse_cmdline ( image, &bzimg ) ) != 0)
+	if ( ( rc = bzimage_parse_cmdline ( image, &bzimg, cmdline ) ) != 0)
 		return rc;
 
 	/* Check that initrds can be loaded */
@@ -559,7 +568,7 @@ static int bzimage_exec ( struct image *image ) {
 		      bzimg.rm_filesz, bzimg.pm_sz );
 
 	/* Store command line */
-	bzimage_set_cmdline ( image, &bzimg );
+	bzimage_set_cmdline ( image, &bzimg, cmdline );
 
 	/* Prepare for exiting.  Must do this before loading initrds,
 	 * since loading the initrds will corrupt the external heap.

src/arch/x86/image/multiboot.c

@@ -204,8 +204,8 @@ static int multiboot_add_modules ( struct image *image, physaddr_t start,
 			break;
 		}
 
-		/* Skip hidden images */
-		if ( module_image->flags & IMAGE_HIDDEN )
+		/* Do not include kernel image itself as a module */
+		if ( module_image == image )
 			continue;
 
 		/* Page-align the module */

src/arch/x86/image/ucode.c

@@ -1,798 +0,0 @@
-/*
- * Copyright (C) 2024 Michael Brown <mbrown@fensystems.co.uk>.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- *
- * You can also choose to distribute this program under the terms of
- * the Unmodified Binary Distribution Licence (as given in the file
- * COPYING.UBDL), provided that you have satisfied its requirements.
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-/** @file
- *
- * Microcode updates
- *
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <assert.h>
-#include <errno.h>
-#include <ipxe/uaccess.h>
-#include <ipxe/umalloc.h>
-#include <ipxe/image.h>
-#include <ipxe/cpuid.h>
-#include <ipxe/msr.h>
-#include <ipxe/mp.h>
-#include <ipxe/timer.h>
-#include <ipxe/ucode.h>
-
-/**
- * Maximum number of hyperthread siblings
- *
- * Microcode updates must not be performed on hyperthread siblings at
- * the same time, since they share microcode storage.
- *
- * Hyperthread siblings are always the lowest level of the CPU
- * topology and correspond to the least significant bits of the APIC
- * ID.  We may therefore avoid collisions by performing the microcode
- * updates in batches, with each batch targeting just one value for
- * the least significant N bits of the APIC ID.
- *
- * We assume that no CPUs exist with more than this number of
- * hyperthread siblings.  (This must be a power of two.)
- */
-#define UCODE_MAX_HT 8
-
-/** Time to wait for a microcode update to complete */
-#define UCODE_WAIT_MS 10
-
-/** A CPU vendor string */
-union ucode_vendor_id {
-	/** CPUID registers */
-	uint32_t dword[3];
-	/** Human-readable string */
-	uint8_t string[12];
-};
-
-/** A CPU vendor */
-struct ucode_vendor {
-	/** Vendor string */
-	union ucode_vendor_id id;
-	/** Microcode load trigger MSR */
-	uint32_t trigger_msr;
-	/** Microcode version requires manual clear */
-	uint8_t ver_clear;
-	/** Microcode version is reported via high dword */
-	uint8_t ver_high;
-};
-
-/** A microcode update */
-struct ucode_update {
-	/** CPU vendor, if known */
-	struct ucode_vendor *vendor;
-	/** Boot processor CPU signature */
-	uint32_t signature;
-	/** Platform ID */
-	uint32_t platform;
-	/** Number of potentially relevant signatures found */
-	unsigned int count;
-	/** Update descriptors (if being populated) */
-	struct ucode_descriptor *desc;
-};
-
-/** A microcode update summary */
-struct ucode_summary {
-	/** Number of CPUs processed */
-	unsigned int count;
-	/** Lowest observed microcode version */
-	int32_t low;
-	/** Highest observed microcode version */
-	int32_t high;
-};
-
-/** Intel CPU vendor */
-static struct ucode_vendor ucode_intel = {
-	.id = { .string = "GenuineIntel" },
-	.ver_clear = 1,
-	.ver_high = 1,
-	.trigger_msr = MSR_UCODE_TRIGGER_INTEL,
-};
-
-/** AMD CPU vendor */
-static struct ucode_vendor ucode_amd = {
-	.id = { .string = "AuthenticAMD" },
-	.trigger_msr = MSR_UCODE_TRIGGER_AMD,
-};
-
-/** List of known CPU vendors */
-static struct ucode_vendor *ucode_vendors[] = {
-	&ucode_intel,
-	&ucode_amd,
-};
-
-/**
- * Get CPU vendor name (for debugging)
- *
- * @v vendor		CPU vendor
- * @ret name		Name
- */
-static const char * ucode_vendor_name ( const union ucode_vendor_id *vendor ) {
-	static union {
-		union ucode_vendor_id vendor;
-		char text[ sizeof ( *vendor ) + 1 /* NUL */ ];
-	} u;
-
-	/* Construct name */
-	memcpy ( &u.vendor, vendor, sizeof ( u.vendor ) );
-	u.text[ sizeof ( u.text ) - 1 ] = '\0';
-	return u.text;
-}
-
-/**
- * Check status report
- *
- * @v update		Microcode update
- * @v control		Microcode update control
- * @v summary		Microcode update summary
- * @v id		APIC ID
- * @v optional		Status report is optional
- * @ret rc		Return status code
- */
-static int ucode_status ( struct ucode_update *update,
-			  struct ucode_control *control,
-			  struct ucode_summary *summary,
-			  unsigned int id, int optional ) {
-	struct ucode_status status;
-	struct ucode_descriptor *desc;
-
-	/* Sanity check */
-	assert ( id <= control->apic_max );
-
-	/* Read status report */
-	copy_from_user ( &status, phys_to_user ( control->status ),
-			 ( id * sizeof ( status ) ), sizeof ( status ) );
-
-	/* Ignore empty optional status reports */
-	if ( optional && ( ! status.signature ) )
-		return 0;
-	DBGC ( update, "UCODE %#08x signature %#08x ucode %#08x->%#08x\n",
-	       id, status.signature, status.before, status.after );
-
-	/* Check CPU signature */
-	if ( ! status.signature ) {
-		DBGC2 ( update, "UCODE %#08x has no signature\n", id );
-		return -ENOENT;
-	}
-
-	/* Check APIC ID is correct */
-	if ( status.id != id ) {
-		DBGC ( update, "UCODE %#08x wrong APIC ID %#08x\n",
-		       id, status.id );
-		return -EINVAL;
-	}
-
-	/* Check that maximum APIC ID was not exceeded */
-	if ( control->apic_unexpected ) {
-		DBGC ( update, "UCODE %#08x saw unexpected APIC ID %#08x\n",
-		       id, control->apic_unexpected );
-		return -ERANGE;
-	}
-
-	/* Check microcode was not downgraded */
-	if ( status.after < status.before ) {
-		DBGC ( update, "UCODE %#08x was downgraded %#08x->%#08x\n",
-		       id, status.before, status.after );
-		return -ENOTTY;
-	}
-
-	/* Check that expected updates (if any) were applied */
-	for ( desc = update->desc ; desc->signature ; desc++ ) {
-		if ( ( desc->signature == status.signature ) &&
-		     ( status.after < desc->version ) ) {
-			DBGC ( update, "UCODE %#08x failed update %#08x->%#08x "
-			       "(wanted %#08x)\n", id, status.before,
-			       status.after, desc->version );
-			return -EIO;
-		}
-	}
-
-	/* Update summary */
-	summary->count++;
-	if ( status.before < summary->low )
-		summary->low = status.before;
-	if ( status.after > summary->high )
-		summary->high = status.after;
-
-	return 0;
-}
-
-/**
- * Update microcode on all CPUs
- *
- * @v image		Microcode image
- * @v update		Microcode update
- * @v summary		Microcode update summary to fill in
- * @ret rc		Return status code
- */
-static int ucode_update_all ( struct image *image,
-			      struct ucode_update *update,
-			      struct ucode_summary *summary ) {
-	struct ucode_control control;
-	struct ucode_vendor *vendor;
-	userptr_t status;
-	unsigned int max;
-	unsigned int i;
-	size_t len;
-	int rc;
-
-	/* Initialise summary */
-	summary->count = 0;
-	summary->low = UCODE_VERSION_MAX;
-	summary->high = UCODE_VERSION_MIN;
-
-	/* Allocate status reports */
-	max = mp_max_cpuid();
-	len = ( ( max + 1 ) * sizeof ( struct ucode_status ) );
-	status = umalloc ( len );
-	if ( ! status ) {
-		DBGC ( image, "UCODE %s could not allocate %d status reports\n",
-		       image->name, ( max + 1 ) );
-		rc = -ENOMEM;
-		goto err_alloc;
-	}
-	memset_user ( status, 0, 0, len );
-
-	/* Construct control structure */
-	memset ( &control, 0, sizeof ( control ) );
-	control.desc = virt_to_phys ( update->desc );
-	control.status = user_to_phys ( status, 0 );
-	vendor = update->vendor;
-	if ( vendor ) {
-		control.ver_clear = vendor->ver_clear;
-		control.ver_high = vendor->ver_high;
-		control.trigger_msr = vendor->trigger_msr;
-	} else {
-		assert ( update->count == 0 );
-	}
-	control.apic_max = max;
-
-	/* Update microcode on boot processor */
-	mp_exec_boot ( ucode_update, &control );
-	if ( ( rc = ucode_status ( update, &control, summary,
-				   mp_boot_cpuid(), 0 ) ) != 0 ) {
-		DBGC ( image, "UCODE %s failed on boot processor: %s\n",
-		       image->name, strerror ( rc ) );
-		goto err_boot;
-	}
-
-	/* Update microcode on application processors, avoiding
-	 * simultaneous updates on hyperthread siblings.
-	 */
-	build_assert ( ( UCODE_MAX_HT & ( UCODE_MAX_HT - 1 ) ) == 0 );
-	control.apic_mask = ( UCODE_MAX_HT - 1 );
-	for ( ; control.apic_test <= control.apic_mask ; control.apic_test++ ) {
-		mp_start_all ( ucode_update, &control );
-		mdelay ( UCODE_WAIT_MS );
-	}
-
-	/* Check status reports */
-	summary->count = 0;
-	for ( i = 0 ; i <= max ; i++ ) {
-		if ( ( rc = ucode_status ( update, &control, summary,
-					   i, 1 ) ) != 0 ) {
-			goto err_status;
-		}
-	}
-
-	/* Success */
-	rc = 0;
-
- err_status:
- err_boot:
-	ufree ( status );
- err_alloc:
-	return rc;
-}
-
-/**
- * Add descriptor to list (if applicable)
- *
- * @v image		Microcode image
- * @v start		Starting offset within image
- * @v vendor		CPU vendor
- * @v desc		Microcode descriptor
- * @v platforms		Supported platforms, or 0 for all platforms
- * @v update		Microcode update
- */
-static void ucode_describe ( struct image *image, size_t start,
-			     const struct ucode_vendor *vendor,
-			     const struct ucode_descriptor *desc,
-			     uint32_t platforms, struct ucode_update *update ) {
-
-	/* Dump descriptor information */
-	DBGC2 ( image, "UCODE %s+%#04zx %s %#08x", image->name, start,
-		ucode_vendor_name ( &vendor->id ), desc->signature );
-	if ( platforms )
-		DBGC2 ( image, " (%#02x)", platforms );
-	DBGC2 ( image, " version %#08x\n", desc->version );
-
-	/* Check applicability */
-	if ( vendor != update->vendor )
-		return;
-	if ( ( desc->signature ^ update->signature ) & UCODE_SIGNATURE_MASK )
-		return;
-	if ( platforms && ( ! ( platforms & update->platform ) ) )
-		return;
-
-	/* Add descriptor, if applicable */
-	if ( update->desc ) {
-		memcpy ( &update->desc[update->count], desc, sizeof ( *desc ) );
-		DBGC ( image, "UCODE %s+%#04zx found %s %#08x version %#08x\n",
-		       image->name, start, ucode_vendor_name ( &vendor->id ),
-		       desc->signature, desc->version );
-	}
-	update->count++;
-}
-
-/**
- * Verify checksum
- *
- * @v image		Microcode image
- * @v start		Starting offset
- * @v len		Length
- * @ret rc		Return status code
- */
-static int ucode_verify ( struct image *image, size_t start, size_t len ) {
-	uint32_t checksum = 0;
-	uint32_t dword;
-	size_t offset;
-
-	/* Check length is a multiple of dwords */
-	if ( ( len % sizeof ( dword ) ) != 0 ) {
-		DBGC ( image, "UCODE %s+%#04zx invalid length %#zx\n",
-		       image->name, start, len );
-		return -EINVAL;
-	}
-
-	/* Calculate checksum */
-	for ( offset = start ; len ;
-	      offset += sizeof ( dword ), len -= sizeof ( dword ) ) {
-		copy_from_user ( &dword, image->data, offset,
-				 sizeof ( dword ) );
-		checksum += dword;
-	}
-	if ( checksum != 0 ) {
-		DBGC ( image, "UCODE %s+%#04zx bad checksum %#08x\n",
-		       image->name, start, checksum );
-		return -EINVAL;
-	}
-
-	return 0;
-}
-
-/**
- * Parse Intel microcode image
- *
- * @v image		Microcode image
- * @v start		Starting offset within image
- * @v update		Microcode update
- * @ret len		Length consumed, or negative error
- */
-static int ucode_parse_intel ( struct image *image, size_t start,
-			       struct ucode_update *update ) {
-	struct intel_ucode_header hdr;
-	struct intel_ucode_ext_header exthdr;
-	struct intel_ucode_ext ext;
-	struct ucode_descriptor desc;
-	size_t remaining;
-	size_t offset;
-	size_t data_len;
-	size_t len;
-	unsigned int i;
-	int rc;
-
-	/* Read header */
-	remaining = ( image->len - start );
-	if ( remaining < sizeof ( hdr ) ) {
-		DBGC ( image, "UCODE %s+%#04zx too small for Intel header\n",
-		       image->name, start );
-		return -ENOEXEC;
-	}
-	copy_from_user ( &hdr, image->data, start, sizeof ( hdr ) );
-
-	/* Determine lengths */
-	data_len = hdr.data_len;
-	if ( ! data_len )
-		data_len = INTEL_UCODE_DATA_LEN;
-	len = hdr.len;
-	if ( ! len )
-		len = ( sizeof ( hdr ) + data_len );
-
-	/* Verify a selection of fields */
-	if ( ( hdr.hver != INTEL_UCODE_HVER ) ||
-	     ( hdr.lver != INTEL_UCODE_LVER ) ||
-	     ( len < sizeof ( hdr ) ) ||
-	     ( len > remaining ) ||
-	     ( data_len > ( len - sizeof ( hdr ) ) ) ||
-	     ( ( data_len % sizeof ( uint32_t ) ) != 0 ) ||
-	     ( ( len % INTEL_UCODE_ALIGN ) != 0 ) ) {
-		DBGC2 ( image, "UCODE %s+%#04zx is not an Intel update\n",
-			image->name, start );
-		return -EINVAL;
-	}
-	DBGC2 ( image, "UCODE %s+%#04zx is an Intel update\n",
-		image->name, start );
-
-	/* Verify checksum */
-	if ( ( rc = ucode_verify ( image, start, len ) ) != 0 )
-		return rc;
-
-	/* Populate descriptor */
-	desc.signature = hdr.signature;
-	desc.version = hdr.version;
-	desc.address = user_to_phys ( image->data,
-				      ( start + sizeof ( hdr ) ) );
-
-	/* Add non-extended descriptor, if applicable */
-	ucode_describe ( image, start, &ucode_intel, &desc, hdr.platforms,
-			 update );
-
-	/* Construct extended descriptors, if applicable */
-	offset = ( sizeof ( hdr ) + data_len );
-	if ( offset <= ( len - sizeof ( exthdr ) ) ) {
-
-		/* Read extended header */
-		copy_from_user ( &exthdr, image->data, ( start + offset ),
-				 sizeof ( exthdr ) );
-		offset += sizeof ( exthdr );
-
-		/* Read extended signatures */
-		for ( i = 0 ; i < exthdr.count ; i++ ) {
-
-			/* Read extended signature */
-			if ( offset > ( len - sizeof ( ext ) ) ) {
-				DBGC ( image, "UCODE %s+%#04zx extended "
-				       "signature overrun\n",
-				       image->name, start );
-				return -EINVAL;
-			}
-			copy_from_user ( &ext, image->data, ( start + offset ),
-					 sizeof ( ext ) );
-			offset += sizeof ( ext );
-
-			/* Avoid duplicating non-extended descriptor */
-			if ( ( ext.signature == hdr.signature ) &&
-			     ( ext.platforms == hdr.platforms ) ) {
-				continue;
-			}
-
-			/* Construct descriptor, if applicable */
-			desc.signature = ext.signature;
-			ucode_describe ( image, start, &ucode_intel, &desc,
-					 ext.platforms, update );
-		}
-	}
-
-	return len;
-}
-
-/**
- * Parse AMD microcode image
- *
- * @v image		Microcode image
- * @v start		Starting offset within image
- * @v update		Microcode update
- * @ret len		Length consumed, or negative error
- */
-static int ucode_parse_amd ( struct image *image, size_t start,
-			     struct ucode_update *update ) {
-	struct amd_ucode_header hdr;
-	struct amd_ucode_equivalence equiv;
-	struct amd_ucode_patch_header phdr;
-	struct amd_ucode_patch patch;
-	struct ucode_descriptor desc;
-	size_t remaining;
-	size_t offset;
-	unsigned int count;
-	unsigned int used;
-	unsigned int i;
-
-	/* Read header */
-	remaining = ( image->len - start );
-	if ( remaining < sizeof ( hdr ) ) {
-		DBGC ( image, "UCODE %s+%#04zx too small for AMD header\n",
-		       image->name, start );
-		return -ENOEXEC;
-	}
-	copy_from_user ( &hdr, image->data, start, sizeof ( hdr ) );
-
-	/* Check header */
-	if ( hdr.magic != AMD_UCODE_MAGIC ) {
-		DBGC2 ( image, "UCODE %s+%#04zx is not an AMD update\n",
-			image->name, start );
-		return -ENOEXEC;
-	}
-	DBGC2 ( image, "UCODE %s+%#04zx is an AMD update\n",
-		image->name, start );
-	if ( hdr.type != AMD_UCODE_EQUIV_TYPE ) {
-		DBGC ( image, "UCODE %s+%#04zx unsupported equivalence table "
-		       "type %d\n", image->name, start, hdr.type );
-		return -ENOTSUP;
-	}
-	if ( hdr.len > ( remaining - sizeof ( hdr ) ) ) {
-		DBGC ( image, "UCODE %s+%#04zx truncated equivalence table\n",
-		       image->name, start );
-		return -EINVAL;
-	}
-
-	/* Count number of equivalence table entries */
-	offset = sizeof ( hdr );
-	for ( count = 0 ; offset < ( sizeof ( hdr ) + hdr.len ) ;
-	      count++, offset += sizeof ( equiv ) ) {
-		copy_from_user ( &equiv, image->data, ( start + offset ),
-				 sizeof ( equiv ) );
-		if ( ! equiv.signature )
-			break;
-	}
-	DBGC2 ( image, "UCODE %s+%#04zx has %d equivalence table entries\n",
-		image->name, start, count );
-
-	/* Parse available updates */
-	offset = ( sizeof ( hdr ) + hdr.len );
-	used = 0;
-	while ( used < count ) {
-
-		/* Read patch header */
-		if ( ( offset + sizeof ( phdr ) ) > remaining ) {
-			DBGC ( image, "UCODE %s+%#04zx truncated patch "
-			       "header\n", image->name, start );
-			return -EINVAL;
-		}
-		copy_from_user ( &phdr, image->data, ( start + offset ),
-				 sizeof ( phdr ) );
-		offset += sizeof ( phdr );
-
-		/* Validate patch header */
-		if ( phdr.type != AMD_UCODE_PATCH_TYPE ) {
-			DBGC ( image, "UCODE %s+%#04zx unsupported patch type "
-			       "%d\n", image->name, start, phdr.type );
-			return -ENOTSUP;
-		}
-		if ( phdr.len < sizeof ( patch ) ) {
-			DBGC ( image, "UCODE %s+%#04zx underlength patch\n",
-			       image->name, start );
-			return -EINVAL;
-		}
-		if ( phdr.len > ( remaining - offset ) ) {
-			DBGC ( image, "UCODE %s+%#04zx truncated patch\n",
-			       image->name, start );
-			return -EINVAL;
-		}
-
-		/* Read patch and construct descriptor */
-		copy_from_user ( &patch, image->data, ( start + offset ),
-				 sizeof ( patch ) );
-		desc.version = patch.version;
-		desc.address = user_to_phys ( image->data, ( start + offset ) );
-		offset += phdr.len;
-
-		/* Parse equivalence table to find matching signatures */
-		for ( i = 0 ; i < count ; i++ ) {
-			copy_from_user ( &equiv, image->data,
-					 ( start + sizeof ( hdr ) +
-					   ( i * ( sizeof ( equiv ) ) ) ),
-					 sizeof ( equiv ) );
-			if ( patch.id == equiv.id ) {
-				desc.signature = equiv.signature;
-				ucode_describe ( image, start, &ucode_amd,
-						 &desc, 0, update );
-				used++;
-			}
-		}
-	}
-
-	return offset;
-}
-
-/**
- * Parse microcode image
- *
- * @v image		Microcode image
- * @v update		Microcode update
- * @ret rc		Return status code
- */
-static int ucode_parse ( struct image *image, struct ucode_update *update ) {
-	size_t start;
-	int len;
-
-	/* Attempt to parse concatenated microcode updates */
-	for ( start = 0 ; start < image->len ; start += len ) {
-
-		/* Attempt to parse as Intel microcode */
-		len = ucode_parse_intel ( image, start, update );
-		if ( len > 0 )
-			continue;
-
-		/* Attempt to parse as AMD microcode */
-		len = ucode_parse_amd ( image, start, update );
-		if ( len > 0 )
-			continue;
-
-		/* Not a recognised microcode format */
-		DBGC ( image, "UCODE %s+%zx not recognised\n",
-		       image->name, start );
-		return -ENOEXEC;
-	}
-
-	return 0;
-}
-
-/**
- * Execute microcode update
- *
- * @v image		Microcode image
- * @ret rc		Return status code
- */
-static int ucode_exec ( struct image *image ) {
-	struct ucode_update update;
-	struct ucode_vendor *vendor;
-	struct ucode_summary summary;
-	union ucode_vendor_id id;
-	uint64_t platform_id;
-	uint32_t discard_a;
-	uint32_t discard_b;
-	uint32_t discard_c;
-	uint32_t discard_d;
-	unsigned int check;
-	unsigned int i;
-	size_t len;
-	int rc;
-
-	/* Initialise update */
-	memset ( &update, 0, sizeof ( update ) );
-	cpuid ( CPUID_VENDOR_ID, 0, &discard_a, &id.dword[0], &id.dword[2],
-		&id.dword[1] );
-	cpuid ( CPUID_FEATURES, 0, &update.signature, &discard_b,
-		&discard_c, &discard_d );
-
-	/* Identify CPU vendor, if recognised */
-	for ( i = 0 ; i < ( sizeof ( ucode_vendors ) /
-			    sizeof ( ucode_vendors[0] ) ) ; i++ ) {
-		vendor = ucode_vendors[i];
-		if ( memcmp ( &id, &vendor->id, sizeof ( id ) ) == 0 )
-			update.vendor = vendor;
-	}
-
-	/* Identify platform, if applicable */
-	if ( update.vendor == &ucode_intel ) {
-		platform_id = rdmsr ( MSR_PLATFORM_ID );
-		update.platform =
-			( 1 << MSR_PLATFORM_ID_VALUE ( platform_id ) );
-	}
-
-	/* Count number of matching update descriptors */
-	DBGC ( image, "UCODE %s applying to %s %#08x",
-	       image->name, ucode_vendor_name ( &id ), update.signature );
-	if ( update.platform )
-		DBGC ( image, " (%#02x)", update.platform );
-	DBGC ( image, "\n" );
-	if ( ( rc = ucode_parse ( image, &update ) ) != 0 )
-		goto err_count;
-	DBGC ( image, "UCODE %s found %d matching update(s)\n",
-	       image->name, update.count );
-
-	/* Allocate descriptors */
-	len = ( ( update.count + 1 /* terminator */ ) *
-		sizeof ( update.desc[0] ) );
-	update.desc = zalloc ( len );
-	if ( ! update.desc ) {
-		rc = -ENOMEM;
-		goto err_alloc;
-	}
-
-	/* Populate descriptors */
-	check = update.count;
-	update.count = 0;
-	if ( ( rc = ucode_parse ( image, &update ) ) != 0 )
-		goto err_parse;
-	assert ( check == update.count );
-
-	/* Perform update */
-	if ( ( rc = ucode_update_all ( image, &update, &summary ) ) != 0 )
-		goto err_update;
-
-	/* Print summary if directed to do so */
-	if ( image->cmdline && ( strstr ( image->cmdline, "-v" ) ) ) {
-		printf ( "Microcode: " );
-		if ( summary.low == summary.high ) {
-			printf ( "already version %#x", summary.low );
-		} else {
-			printf ( "updated version %#x->%#x",
-				 summary.low, summary.high );
-		}
-		printf ( " (x%d)\n", summary.count );
-	}
-
- err_update:
- err_parse:
-	free ( update.desc );
- err_alloc:
- err_count:
-	return rc;
-}
-
-/**
- * Probe microcode update image
- *
- * @v image		Microcode image
- * @ret rc		Return status code
- */
-static int ucode_probe ( struct image *image ) {
-	union {
-		struct intel_ucode_header intel;
-		struct amd_ucode_header amd;
-	} header;
-
-	/* Sanity check */
-	if ( image->len < sizeof ( header )  ) {
-		DBGC ( image, "UCODE %s too short\n", image->name );
-		return -ENOEXEC;
-	}
-
-	/* Read first microcode image header */
-	copy_from_user ( &header, image->data, 0, sizeof ( header ) );
-
-	/* Check for something that looks like an Intel update
-	 *
-	 * Intel updates unfortunately have no magic signatures or
-	 * other easily verifiable fields.  We check a small selection
-	 * of header fields that can be easily verified.
-	 *
-	 * We do not attempt to fully parse the update, since we want
-	 * errors to be reported at the point of attempting to execute
-	 * the image, and do not want to have a microcode image
-	 * erroneously treated as a PXE boot executable.
-	 */
-	if ( ( header.intel.hver == INTEL_UCODE_HVER ) &&
-	     ( header.intel.lver == INTEL_UCODE_LVER ) &&
-	     ( ( header.intel.date.century == 0x19 ) ||
-	       ( ( header.intel.date.century >= 0x20 ) &&
-		 ( header.intel.date.century <= 0x29 ) ) ) ) {
-		DBGC ( image, "UCODE %s+%#04zx looks like an Intel update\n",
-		       image->name, ( ( size_t ) 0 ) );
-		return 0;
-	}
-
-	/* Check for AMD update signature */
-	if ( ( header.amd.magic == AMD_UCODE_MAGIC ) &&
-	     ( header.amd.type == AMD_UCODE_EQUIV_TYPE ) ) {
-		DBGC ( image, "UCODE %s+%#04zx looks like an AMD update\n",
-		       image->name, ( ( size_t ) 0 ) );
-		return 0;
-	}
-
-	return -ENOEXEC;
-}
-
-/** Microcode update image type */
-struct image_type ucode_image_type __image_type ( PROBE_NORMAL ) = {
-	.name = "ucode",
-	.probe = ucode_probe,
-	.exec = ucode_exec,
-};

src/arch/x86/include/bits/bigint.h

@@ -323,9 +323,7 @@ bigint_done_raw ( const uint32_t *value0, unsigned int size __unused,
 }
 
 extern void bigint_multiply_raw ( const uint32_t *multiplicand0,
-				  unsigned int multiplicand_size,
 				  const uint32_t *multiplier0,
-				  unsigned int multiplier_size,
-				  uint32_t *value0 );
+				  uint32_t *value0, unsigned int size );
 
 #endif /* _BITS_BIGINT_H */

src/arch/x86/include/bits/entropy.h

@@ -0,0 +1,14 @@
+#ifndef _BITS_ENTROPY_H
+#define _BITS_ENTROPY_H
+
+/** @file
+ *
+ * x86-specific entropy API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <ipxe/rtc_entropy.h>
+
+#endif /* _BITS_ENTROPY_H */

src/arch/x86/include/bits/errfile.h

@@ -28,7 +28,6 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 #define ERRFILE_cpuid		( ERRFILE_ARCH | ERRFILE_CORE | 0x00110000 )
 #define ERRFILE_rdtsc_timer	( ERRFILE_ARCH | ERRFILE_CORE | 0x00120000 )
 #define ERRFILE_acpi_timer	( ERRFILE_ARCH | ERRFILE_CORE | 0x00130000 )
-#define ERRFILE_rdrand		( ERRFILE_ARCH | ERRFILE_CORE | 0x00140000 )
 
 #define ERRFILE_bootsector     ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x00000000 )
 #define ERRFILE_bzimage	       ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x00010000 )
@@ -44,7 +43,6 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 #define ERRFILE_sdi	       ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x000b0000 )
 #define ERRFILE_initrd	       ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x000c0000 )
 #define ERRFILE_pxe_call       ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x000d0000 )
-#define ERRFILE_ucode	       ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x000e0000 )
 
 #define ERRFILE_undi		 ( ERRFILE_ARCH | ERRFILE_NET | 0x00000000 )
 #define ERRFILE_undiload	 ( ERRFILE_ARCH | ERRFILE_NET | 0x00010000 )

src/arch/x86/include/bits/io.h

@@ -9,9 +9,6 @@
 
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
-/** Page shift */
-#define PAGE_SHIFT 12
-
 #include <ipxe/x86_io.h>
 
 #endif /* _BITS_IO_H */

src/arch/x86/include/bits/mp.h

@@ -1,14 +0,0 @@
-#ifndef _BITS_MP_H
-#define _BITS_MP_H
-
-/** @file
- *
- * x86-specific multiprocessor API implementation
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <ipxe/bios_mp.h>
-
-#endif /* _BITS_MP_H */

src/arch/x86/include/ipxe/bios_mp.h

@@ -1,32 +0,0 @@
-#ifndef _IPXE_BIOS_MP_H
-#define _IPXE_BIOS_MP_H
-
-/** @file
- *
- * BIOS multiprocessor API implementation
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <ipxe/io.h>
-
-#ifdef MPAPI_PCBIOS
-#define MPAPI_PREFIX_pcbios
-#else
-#define MPAPI_PREFIX_pcbios __pcbios_
-#endif
-
-/**
- * Calculate address as seen by a multiprocessor function
- *
- * @v address		Address in boot processor address space
- * @ret address		Address in application processor address space
- */
-static inline __attribute__ (( always_inline )) mp_addr_t
-MPAPI_INLINE ( pcbios, mp_address ) ( void *address ) {
-
-	return virt_to_phys ( address );
-}
-
-#endif /* _IPXE_BIOS_MP_H */

src/arch/x86/include/ipxe/cpuid.h

@@ -39,9 +39,6 @@ struct x86_features {
 /** Get standard features */
 #define CPUID_FEATURES 0x00000001UL
 
-/** RDRAND instruction is supported */
-#define CPUID_FEATURES_INTEL_ECX_RDRAND 0x40000000UL
-
 /** Hypervisor is present */
 #define CPUID_FEATURES_INTEL_ECX_HYPERVISOR 0x80000000UL
 

src/arch/x86/include/ipxe/rtc_entropy.h

@@ -0,0 +1,62 @@
+#ifndef _IPXE_RTC_ENTROPY_H
+#define _IPXE_RTC_ENTROPY_H
+
+/** @file
+ *
+ * RTC-based entropy source
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <stdint.h>
+
+#ifdef ENTROPY_RTC
+#define ENTROPY_PREFIX_rtc
+#else
+#define ENTROPY_PREFIX_rtc __rtc_
+#endif
+
+/**
+ * min-entropy per sample
+ *
+ * @ret min_entropy	min-entropy of each sample
+ */
+static inline __always_inline min_entropy_t
+ENTROPY_INLINE ( rtc, min_entropy_per_sample ) ( void ) {
+
+	/* The min-entropy has been measured on several platforms
+	 * using the entropy_sample test code.  Modelling the samples
+	 * as independent, and using a confidence level of 99.99%, the
+	 * measurements were as follows:
+	 *
+	 *    qemu-kvm		: 7.38 bits
+	 *    VMware		: 7.46 bits
+	 *    Physical hardware	: 2.67 bits
+	 *
+	 * We choose the lowest of these (2.67 bits) and apply a 50%
+	 * safety margin to allow for some potential non-independence
+	 * of samples.
+	 */
+	return MIN_ENTROPY ( 1.3 );
+}
+
+extern uint8_t rtc_sample ( void );
+
+/**
+ * Get noise sample
+ *
+ * @ret noise		Noise sample
+ * @ret rc		Return status code
+ */
+static inline __always_inline int
+ENTROPY_INLINE ( rtc, get_noise ) ( noise_sample_t *noise ) {
+
+	/* Get sample */
+	*noise = rtc_sample();
+
+	/* Always successful */
+	return 0;
+}
+
+#endif /* _IPXE_RTC_ENTROPY_H */

src/arch/x86/include/ipxe/ucode.h

@@ -1,223 +0,0 @@
-#ifndef _IPXE_UCODE_H
-#define _IPXE_UCODE_H
-
-/** @file
- *
- * Microcode updates
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <stdint.h>
-#include <ipxe/mp.h>
-
-/** Platform ID MSR */
-#define MSR_PLATFORM_ID 0x00000017UL
-
-/** Extract platform ID from MSR value */
-#define MSR_PLATFORM_ID_VALUE( value ) ( ( (value) >> 50 ) & 0x7 )
-
-/** Intel microcode load trigger MSR */
-#define MSR_UCODE_TRIGGER_INTEL 0x00000079UL
-
-/** AMD microcode load trigger MSR */
-#define MSR_UCODE_TRIGGER_AMD 0xc0010020UL
-
-/** CPUID signature applicability mask
- *
- * We assume that only steppings may vary between the boot CPU and any
- * application processors.
- */
-#define UCODE_SIGNATURE_MASK 0xfffffff0UL
-
-/** Minimum possible microcode version */
-#define UCODE_VERSION_MIN -0x80000000L
-
-/** Maximum possible microcode version */
-#define UCODE_VERSION_MAX 0x7fffffffL
-
-/** A microcode update control
- *
- * This must match the layout as used by the assembly code in
- * ucode_mp.S.
- */
-struct ucode_control {
-	/** Microcode descriptor list physical address */
-	uint64_t desc;
-	/** Microcode status array physical address */
-	uint64_t status;
-	/** Microcode load trigger MSR */
-	uint32_t trigger_msr;
-	/** Maximum expected APIC ID */
-	uint32_t apic_max;
-	/** Unexpected APIC ID
-	 *
-	 * Any application processor may set this to indicate that its
-	 * APIC ID was higher than the maximum expected APIC ID.
-	 */
-	uint32_t apic_unexpected;
-	/** APIC ID eligibility mask bits */
-	uint32_t apic_mask;
-	/** APIC ID eligibility test bits */
-	uint32_t apic_test;
-	/** Microcode version requires manual clear */
-	uint8_t ver_clear;
-	/** Microcode version is reported via high dword */
-	uint8_t ver_high;
-} __attribute__ (( packed ));
-
-/** A microcode update descriptor
- *
- * This must match the layout as used by the assembly code in
- * ucode_mp.S.
- */
-struct ucode_descriptor {
-	/** CPUID signature (or 0 to terminate list) */
-	uint32_t signature;
-	/** Microcode version */
-	int32_t version;
-	/** Microcode physical address */
-	uint64_t address;
-} __attribute__ (( packed ));
-
-/** A microcode update status report
- *
- * This must match the layout as used by the assembly code in
- * ucode_mp.S.
- */
-struct ucode_status {
-	/** CPU signature */
-	uint32_t signature;
-	/** APIC ID (for sanity checking) */
-	uint32_t id;
-	/** Initial microcode version */
-	int32_t before;
-	/** Final microcode version */
-	int32_t after;
-} __attribute__ (( packed ));
-
-/** A microcode date */
-struct ucode_date {
-	/** Year (BCD) */
-	uint8_t year;
-	/** Century (BCD) */
-	uint8_t century;
-	/** Day (BCD) */
-	uint8_t day;
-	/** Month (BCD) */
-	uint8_t month;
-} __attribute__ (( packed ));
-
-/** An Intel microcode update file header */
-struct intel_ucode_header {
-	/** Header version number */
-	uint32_t hver;
-	/** Microcode version */
-	int32_t version;
-	/** Date */
-	struct ucode_date date;
-	/** CPUID signature */
-	uint32_t signature;
-	/** Checksum */
-	uint32_t checksum;
-	/** Loader version */
-	uint32_t lver;
-	/** Supported platforms */
-	uint32_t platforms;
-	/** Microcode data size (or 0 to indicate 2000 bytes) */
-	uint32_t data_len;
-	/** Total size (or 0 to indicate 2048 bytes) */
-	uint32_t len;
-	/** Reserved */
-	uint8_t reserved[12];
-} __attribute__ (( packed ));
-
-/** Intel microcode header version number */
-#define INTEL_UCODE_HVER 0x00000001UL
-
-/** Intel microcode loader version number */
-#define INTEL_UCODE_LVER 0x00000001UL
-
-/** Intel microcode default data length */
-#define INTEL_UCODE_DATA_LEN 2000
-
-/** Intel microcode file alignment */
-#define INTEL_UCODE_ALIGN 1024
-
-/** An Intel microcode update file extended header */
-struct intel_ucode_ext_header {
-	/** Extended signature count */
-	uint32_t count;
-	/** Extended checksum */
-	uint32_t checksum;
-	/** Reserved */
-	uint8_t reserved[12];
-} __attribute__ (( packed ));
-
-/** An Intel microcode extended signature */
-struct intel_ucode_ext {
-	/** CPUID signature */
-	uint32_t signature;
-	/** Supported platforms */
-	uint32_t platforms;
-	/** Checksum */
-	uint32_t checksum;
-} __attribute__ (( packed ));
-
-/** An AMD microcode update file header */
-struct amd_ucode_header {
-	/** Magic signature */
-	uint32_t magic;
-	/** Equivalence table type */
-	uint32_t type;
-	/** Equivalence table length */
-	uint32_t len;
-} __attribute__ (( packed ));
-
-/** AMD microcode magic signature */
-#define AMD_UCODE_MAGIC ( ( 'A' << 16 ) | ( 'M' << 8 ) | ( 'D' << 0 ) )
-
-/** AMD microcode equivalence table type */
-#define AMD_UCODE_EQUIV_TYPE 0x00000000UL
-
-/** An AMD microcode equivalence table entry */
-struct amd_ucode_equivalence {
-	/** CPU signature */
-	uint32_t signature;
-	/** Reserved */
-	uint8_t reserved_a[8];
-	/** Equivalence ID */
-	uint16_t id;
-	/** Reserved */
-	uint8_t reserved_b[2];
-} __attribute__ (( packed ));
-
-/** An AMD microcode patch header */
-struct amd_ucode_patch_header {
-	/** Patch type */
-	uint32_t type;
-	/** Patch length */
-	uint32_t len;
-} __attribute__ (( packed ));
-
-/** An AMD microcode patch */
-struct amd_ucode_patch {
-	/** Date */
-	struct ucode_date date;
-	/** Microcode version */
-	int32_t version;
-	/** Reserved */
-	uint8_t reserved_a[16];
-	/** Equivalence ID */
-	uint16_t id;
-	/** Reserved */
-	uint8_t reserved_b[14];
-} __attribute__ (( packed ));
-
-/** AMD patch type */
-#define AMD_UCODE_PATCH_TYPE 0x00000001UL
-
-extern mp_func_t ucode_update;
-
-#endif /* _IPXE_UCODE_H */

src/arch/x86/include/ipxe/x86_io.h

@@ -28,6 +28,9 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  *
  */
 
+/** Page shift */
+#define PAGE_SHIFT 12
+
 /*
  * Physical<->Bus address mappings
  *

src/arch/x86/include/librm.h

@@ -250,10 +250,8 @@ extern void remove_user_from_rm_stack ( userptr_t data, size_t size );
 /* CODE_DEFAULT: restore default .code32/.code64 directive */
 #ifdef __x86_64__
 #define CODE_DEFAULT ".code64"
-#define STACK_DEFAULT "q"
 #else
 #define CODE_DEFAULT ".code32"
-#define STACK_DEFAULT "l"
 #endif
 
 /* LINE_SYMBOL: declare a symbol for the current source code line */
@@ -270,7 +268,7 @@ extern void remove_user_from_rm_stack ( userptr_t data, size_t size );
 
 /* REAL_CODE: declare a fragment of code that executes in real mode */
 #define REAL_CODE( asm_code_str )			\
-	"push" STACK_DEFAULT " $1f\n\t"			\
+	"push $1f\n\t"					\
 	"call real_call\n\t"				\
 	TEXT16_CODE ( "\n1:\n\t"			\
 		      asm_code_str			\
@@ -279,7 +277,7 @@ extern void remove_user_from_rm_stack ( userptr_t data, size_t size );
 
 /* PHYS_CODE: declare a fragment of code that executes in flat physical mode */
 #define PHYS_CODE( asm_code_str )			\
-	"push" STACK_DEFAULT " $1f\n\t"			\
+	"push $1f\n\t"					\
 	"call phys_call\n\t"				\
 	".section \".text.phys\", \"ax\", @progbits\n\t"\
 	"\n" LINE_SYMBOL "\n\t"				\
@@ -474,26 +472,6 @@ extern struct page_table io_pages;
  */
 #define IO_BASE ( ( void * ) 0x100000000ULL )
 
-/** Startup IPI real-mode handler */
-extern char __text16_array ( sipi, [] );
-#define sipi __use_text16 ( sipi )
-
-/** Length of startup IPI real-mode handler */
-extern char sipi_len[];
-
-/** Startup IPI real-mode handler copy of real-mode data segment */
-extern uint16_t __text16 ( sipi_ds );
-#define sipi_ds __use_text16 ( sipi_ds )
-
-/** Startup IPI protected-mode handler (physical address) */
-extern uint32_t sipi_handler;
-
-/** Startup IPI register state */
-extern struct i386_regs sipi_regs;
-
-extern void setup_sipi ( unsigned int vector, uint32_t handler,
-			 struct i386_regs *regs );
-
 #endif /* ASSEMBLY */
 
 #endif /* LIBRM_H */

src/arch/x86/interface/efi/efix86_nap.c

@@ -46,12 +46,8 @@ static void efix86_cpu_nap ( void ) {
 	 * The EFI shell doesn't seem to bother sleeping the CPU; it
 	 * just sits there idly burning power.
 	 *
-	 * If a shutdown is in progess, there may be nothing to
-	 * generate an interrupt since the timer is disabled in the
-	 * first step of ExitBootServices().
 	 */
-	if ( ! efi_shutdown_in_progress )
-		__asm__ __volatile__ ( "hlt" );
+	__asm__ __volatile__ ( "hlt" );
 }
 
 PROVIDE_NAP ( efix86, cpu_nap, efix86_cpu_nap );

src/arch/x86/interface/pcbios/bios_console.c

@@ -290,38 +290,29 @@ static const char *bios_ansi_input = "";
 struct bios_key {
 	/** Scancode */
 	uint8_t scancode;
-	/** Relative key value */
-	uint16_t rkey;
+	/** Key code */
+	uint16_t key;
 } __attribute__ (( packed ));
 
-/**
- * Define a BIOS key mapping
- *
- * @v scancode		Scancode
- * @v key		iPXE key code
- * @v bioskey		BIOS key mapping
- */
-#define BIOS_KEY( scancode, key ) { scancode, KEY_REL ( key ) }
-
 /** Mapping from BIOS scan codes to iPXE key codes */
 static const struct bios_key bios_keys[] = {
-	BIOS_KEY ( 0x53, KEY_DC ),
-	BIOS_KEY ( 0x48, KEY_UP ),
-	BIOS_KEY ( 0x50, KEY_DOWN ),
-	BIOS_KEY ( 0x4b, KEY_LEFT ),
-	BIOS_KEY ( 0x4d, KEY_RIGHT ),
-	BIOS_KEY ( 0x47, KEY_HOME ),
-	BIOS_KEY ( 0x4f, KEY_END ),
-	BIOS_KEY ( 0x49, KEY_PPAGE ),
-	BIOS_KEY ( 0x51, KEY_NPAGE ),
-	BIOS_KEY ( 0x3f, KEY_F5 ),
-	BIOS_KEY ( 0x40, KEY_F6 ),
-	BIOS_KEY ( 0x41, KEY_F7 ),
-	BIOS_KEY ( 0x42, KEY_F8 ),
-	BIOS_KEY ( 0x43, KEY_F9 ),
-	BIOS_KEY ( 0x44, KEY_F10 ),
-	BIOS_KEY ( 0x85, KEY_F11 ),
-	BIOS_KEY ( 0x86, KEY_F12 ),
+	{ 0x53, KEY_DC },
+	{ 0x48, KEY_UP },
+	{ 0x50, KEY_DOWN },
+	{ 0x4b, KEY_LEFT },
+	{ 0x4d, KEY_RIGHT },
+	{ 0x47, KEY_HOME },
+	{ 0x4f, KEY_END },
+	{ 0x49, KEY_PPAGE },
+	{ 0x51, KEY_NPAGE },
+	{ 0x3f, KEY_F5 },
+	{ 0x40, KEY_F6 },
+	{ 0x41, KEY_F7 },
+	{ 0x42, KEY_F8 },
+	{ 0x43, KEY_F9 },
+	{ 0x44, KEY_F10 },
+	{ 0x85, KEY_F11 },
+	{ 0x86, KEY_F12 },
 };
 
 /**
@@ -332,7 +323,7 @@ static const struct bios_key bios_keys[] = {
  */
 static const char * bios_ansi_seq ( unsigned int scancode ) {
 	static char buf[ 5 /* "[" + two digits + terminator + NUL */ ];
-	unsigned int rkey;
+	unsigned int key;
 	unsigned int terminator;
 	unsigned int n;
 	unsigned int i;
@@ -347,9 +338,9 @@ static const char * bios_ansi_seq ( unsigned int scancode ) {
 			continue;
 
 		/* Construct escape sequence */
-		rkey = bios_keys[i].rkey;
-		n = KEY_ANSI_N ( rkey );
-		terminator = KEY_ANSI_TERMINATOR ( rkey );
+		key = bios_keys[i].key;
+		n = KEY_ANSI_N ( key );
+		terminator = KEY_ANSI_TERMINATOR ( key );
 		*(tmp++) = '[';
 		if ( n )
 			tmp += sprintf ( tmp, "%d", n );
@@ -488,7 +479,6 @@ struct console_driver bios_console __console_driver = {
 static __asmcall __used void bios_inject ( struct i386_all_regs *ix86 ) {
 	unsigned int discard_a;
 	unsigned int scancode;
-	unsigned int rkey;
 	unsigned int i;
 	uint16_t keypress;
 	int key;
@@ -531,10 +521,9 @@ static __asmcall __used void bios_inject ( struct i386_all_regs *ix86 ) {
 
 		/* Handle special keys */
 		if ( key >= KEY_MIN ) {
-			rkey = KEY_REL ( key );
 			for ( i = 0 ; i < ( sizeof ( bios_keys ) /
 					    sizeof ( bios_keys[0] ) ) ; i++ ) {
-				if ( bios_keys[i].rkey == rkey ) {
+				if ( bios_keys[i].key == key ) {
 					scancode = bios_keys[i].scancode;
 					keypress = ( scancode << 8 );
 					break;

src/arch/x86/interface/pcbios/bios_mp.c

@@ -1,173 +0,0 @@
-/*
- * Copyright (C) 2024 Michael Brown <mbrown@fensystems.co.uk>.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- *
- * You can also choose to distribute this program under the terms of
- * the Unmodified Binary Distribution Licence (as given in the file
- * COPYING.UBDL), provided that you have satisfied its requirements.
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-/** @file
- *
- * BIOS multiprocessor API implementation
- *
- */
-
-#include <registers.h>
-#include <ipxe/uaccess.h>
-#include <ipxe/timer.h>
-#include <ipxe/msr.h>
-#include <ipxe/mp.h>
-
-/** Local APIC base address MSR */
-#define MSR_APIC_BASE 0x0000001b
-
-/** Local APIC is in x2APIC mode */
-#define MSR_APIC_BASE_X2APIC 0x400
-
-/** Local APIC base address mask */
-#define MSR_APIC_BASE_MASK ( ~0xfffULL )
-
-/** Interrupt command register */
-#define APIC_ICR 0x0300
-
-/** Interrupt command register (x2APIC) */
-#define MSR_X2APIC_ICR 0x830
-
-/** Interrupt command register: send to all excluding self */
-#define APIC_ICR_ALL_NOT_SELF 0x000c0000
-
-/** Interrupt command register: level mode */
-#define APIC_ICR_LEVEL 0x00008000
-
-/** Interrupt command register: level asserted */
-#define APIC_ICR_LEVEL_ASSERT 0x00004000
-
-/** Interrupt command register: INIT */
-#define APIC_ICR_INIT 0x00000500
-
-/** Interrupt command register: SIPI */
-#define APIC_ICR_SIPI( vector ) ( 0x00000600 | (vector) )
-
-/** Time to wait for an IPI to complete */
-#define IPI_WAIT_MS 10
-
-/**
- * Startup IPI vector
- *
- * The real-mode startup IPI code must be copied to a page boundary in
- * base memory.  We fairly arbitrarily choose to place this at 0x8000.
- */
-#define SIPI_VECTOR 0x08
-
-/** Protected-mode startup IPI handler */
-extern void __asmcall mp_jump ( mp_addr_t func, mp_addr_t opaque );
-
-/**
- * Execute a multiprocessor function on the boot processor
- *
- * @v func		Multiprocessor function
- * @v opaque		Opaque data pointer
- */
-static void bios_mp_exec_boot ( mp_func_t func, void *opaque ) {
-
-	/* Call multiprocessor function with physical addressing */
-	__asm__ __volatile__ ( PHYS_CODE ( "pushl %k2\n\t"
-					   "pushl %k1\n\t"
-					   "call *%k0\n\t"
-					   "addl $8, %%esp\n\t" )
-			       : : "r" ( mp_address ( mp_call ) ),
-				   "r" ( mp_address ( func ) ),
-				   "r" ( mp_address ( opaque ) ) );
-}
-
-/**
- * Send an interprocessor interrupt
- *
- * @v apic		APIC base address
- * @v x2apic		x2APIC mode enabled
- * @v icr		Interrupt control register value
- */
-static void bios_mp_ipi ( void *apic, int x2apic, uint32_t icr ) {
-
-	/* Write ICR according to APIC/x2APIC mode */
-	DBGC ( MSR_APIC_BASE, "BIOSMP sending IPI %#08x\n", icr );
-	if ( x2apic ) {
-		wrmsr ( MSR_X2APIC_ICR, icr );
-	} else {
-		writel ( icr, ( apic + APIC_ICR ) );
-	}
-
-	/* Allow plenty of time for delivery to complete */
-	mdelay ( IPI_WAIT_MS );
-}
-
-/**
- * Start a multiprocessor function on all application processors
- *
- * @v func		Multiprocessor function
- * @v opaque		Opaque data pointer
- */
-static void bios_mp_start_all ( mp_func_t func, void *opaque ) {
-	struct i386_regs regs;
-	uint64_t base;
-	uint32_t ipi;
-	void *apic;
-	int x2apic;
-
-	/* Prepare SIPI handler */
-	regs.eax = mp_address ( func );
-	regs.edx = mp_address ( opaque );
-	setup_sipi ( SIPI_VECTOR, virt_to_phys ( mp_jump ), &regs );
-
-	/* Get local APIC base address and mode */
-	base = rdmsr ( MSR_APIC_BASE );
-	x2apic = ( base & MSR_APIC_BASE_X2APIC );
-	DBGC ( MSR_APIC_BASE, "BIOSMP local %sAPIC base %#llx\n",
-	       ( x2apic ? "x2" : "" ), ( ( unsigned long long ) base ) );
-
-	/* Map local APIC */
-	apic = ioremap ( ( base & MSR_APIC_BASE_MASK ), PAGE_SIZE );
-	if ( ! apic )
-		goto err_ioremap;
-
-	/* Assert INIT IPI */
-	ipi = ( APIC_ICR_ALL_NOT_SELF | APIC_ICR_LEVEL |
-		APIC_ICR_LEVEL_ASSERT | APIC_ICR_INIT );
-	bios_mp_ipi ( apic, x2apic, ipi );
-
-	/* Clear INIT IPI */
-	ipi &= ~APIC_ICR_LEVEL_ASSERT;
-	bios_mp_ipi ( apic, x2apic, ipi );
-
-	/* Send SIPI */
-	ipi = ( APIC_ICR_ALL_NOT_SELF | APIC_ICR_SIPI ( SIPI_VECTOR ) );
-	bios_mp_ipi ( apic, x2apic, ipi );
-
-	iounmap ( apic );
- err_ioremap:
-	/* No way to handle errors: caller must check that
-	 * multiprocessor function executed as expected.
-	 */
-	return;
-}
-
-PROVIDE_MPAPI_INLINE ( pcbios, mp_address );
-PROVIDE_MPAPI ( pcbios, mp_exec_boot, bios_mp_exec_boot );
-PROVIDE_MPAPI ( pcbios, mp_start_all, bios_mp_start_all );

src/arch/x86/interface/pcbios/bios_smbios.c

@@ -44,11 +44,11 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  * @v smbios		SMBIOS entry point descriptor structure to fill in
  * @ret rc		Return status code
  */
-static int bios_find_smbios2 ( struct smbios *smbios ) {
+static int bios_find_smbios ( struct smbios *smbios ) {
 	struct smbios_entry entry;
 	int rc;
 
-	/* Scan through BIOS segment to find SMBIOS 32-bit entry point */
+	/* Scan through BIOS segment to find SMBIOS entry point */
 	if ( ( rc = find_smbios_entry ( real_to_user ( BIOS_SEG, 0 ), 0x10000,
 					&entry ) ) != 0 )
 		return rc;
@@ -62,55 +62,4 @@ static int bios_find_smbios2 ( struct smbios *smbios ) {
 	return 0;
 }
 
-/**
- * Find SMBIOS
- *
- * @v smbios		SMBIOS entry point descriptor structure to fill in
- * @ret rc		Return status code
- */
-static int bios_find_smbios3 ( struct smbios *smbios ) {
-	struct smbios3_entry entry;
-	int rc;
-
-	/* Scan through BIOS segment to find SMBIOS 64-bit entry point */
-	if ( ( rc = find_smbios3_entry ( real_to_user ( BIOS_SEG, 0 ), 0x10000,
-					 &entry ) ) != 0 )
-		return rc;
-
-	/* Check that address is accessible */
-	if ( entry.smbios_address > ~( ( physaddr_t ) 0 ) ) {
-		DBG ( "SMBIOS3 at %08llx is inaccessible\n",
-		      ( ( unsigned long long ) entry.smbios_address ) );
-		return -ENOTSUP;
-	}
-
-	/* Fill in entry point descriptor structure */
-	smbios->address = phys_to_user ( entry.smbios_address );
-	smbios->len = entry.smbios_len;
-	smbios->count = 0;
-	smbios->version = SMBIOS_VERSION ( entry.major, entry.minor );
-
-	return 0;
-}
-
-/**
- * Find SMBIOS
- *
- * @v smbios		SMBIOS entry point descriptor structure to fill in
- * @ret rc		Return status code
- */
-static int bios_find_smbios ( struct smbios *smbios ) {
-	int rc;
-
-	/* Use 32-bit table if present */
-	if ( ( rc = bios_find_smbios2 ( smbios ) ) == 0 )
-		return 0;
-
-	/* Otherwise, use 64-bit table if present and accessible */
-	if ( ( rc = bios_find_smbios3 ( smbios ) ) == 0 )
-		return 0;
-
-	return rc;
-}
-
 PROVIDE_SMBIOS ( pcbios, find_smbios, bios_find_smbios );

src/arch/x86/interface/pcbios/e820mangler.S

@@ -23,9 +23,9 @@
 
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
 
-	.section ".note.GNU-stack", "", @progbits
-	.code16
+	.text
 	.arch i386
+	.code16
 
 #define SMAP 0x534d4150
 

src/arch/x86/interface/pcbios/int13.c

@@ -183,8 +183,8 @@ static int int13_parse_eltorito ( struct san_device *sandev, void *scratch ) {
 	/* Read boot record volume descriptor */
 	if ( ( rc = sandev_read ( sandev, ELTORITO_LBA, 1,
 				  virt_to_user ( boot ) ) ) != 0 ) {
-		DBGC ( sandev->drive, "INT13 drive %02x could not read El "
-		       "Torito boot record volume descriptor: %s\n",
+		DBGC ( sandev, "INT13 drive %02x could not read El Torito boot "
+		       "record volume descriptor: %s\n",
 		       sandev->drive, strerror ( rc ) );
 		return rc;
 	}
@@ -192,11 +192,10 @@ static int int13_parse_eltorito ( struct san_device *sandev, void *scratch ) {
 	/* Check for an El Torito boot catalog */
 	if ( memcmp ( boot, &boot_check, sizeof ( boot_check ) ) == 0 ) {
 		int13->boot_catalog = boot->sector;
-		DBGC ( sandev->drive, "INT13 drive %02x has an El Torito boot "
-		       "catalog at LBA %08x\n", sandev->drive,
-		       int13->boot_catalog );
+		DBGC ( sandev, "INT13 drive %02x has an El Torito boot catalog "
+		       "at LBA %08x\n", sandev->drive, int13->boot_catalog );
 	} else {
-		DBGC ( sandev->drive, "INT13 drive %02x has no El Torito boot "
+		DBGC ( sandev, "INT13 drive %02x has no El Torito boot "
 		       "catalog\n", sandev->drive );
 	}
 
@@ -229,14 +228,14 @@ static int int13_guess_geometry_hdd ( struct san_device *sandev, void *scratch,
 
 	/* Read partition table */
 	if ( ( rc = sandev_read ( sandev, 0, 1, virt_to_user ( mbr ) ) ) != 0 ) {
-		DBGC ( sandev->drive, "INT13 drive %02x could not read "
+		DBGC ( sandev, "INT13 drive %02x could not read "
 		       "partition table to guess geometry: %s\n",
 		       sandev->drive, strerror ( rc ) );
 		return rc;
 	}
-	DBGC2 ( sandev->drive, "INT13 drive %02x has MBR:\n", sandev->drive );
-	DBGC2_HDA ( sandev->drive, 0, mbr, sizeof ( *mbr ) );
-	DBGC ( sandev->drive, "INT13 drive %02x has signature %08x\n",
+	DBGC2 ( sandev, "INT13 drive %02x has MBR:\n", sandev->drive );
+	DBGC2_HDA ( sandev, 0, mbr, sizeof ( *mbr ) );
+	DBGC ( sandev, "INT13 drive %02x has signature %08x\n",
 	       sandev->drive, mbr->signature );
 
 	/* Scan through partition table and modify guesses for
@@ -261,8 +260,8 @@ static int int13_guess_geometry_hdd ( struct san_device *sandev, void *scratch,
 		if ( ( start_cylinder == 0 ) && ( start_head != 0 ) ) {
 			*sectors = ( ( partition->start + 1 - start_sector ) /
 				     start_head );
-			DBGC ( sandev->drive, "INT13 drive %02x guessing "
-			       "C/H/S xx/xx/%d based on partition %d\n",
+			DBGC ( sandev, "INT13 drive %02x guessing C/H/S "
+			       "xx/xx/%d based on partition %d\n",
 			       sandev->drive, *sectors, ( i + 1 ) );
 		}
 
@@ -273,14 +272,14 @@ static int int13_guess_geometry_hdd ( struct san_device *sandev, void *scratch,
 		end_sector = PART_SECTOR ( partition->chs_end );
 		if ( ( end_head + 1 ) > *heads ) {
 			*heads = ( end_head + 1 );
-			DBGC ( sandev->drive, "INT13 drive %02x guessing "
-			       "C/H/S xx/%d/xx based on partition %d\n",
+			DBGC ( sandev, "INT13 drive %02x guessing C/H/S "
+			       "xx/%d/xx based on partition %d\n",
 			       sandev->drive, *heads, ( i + 1 ) );
 		}
 		if ( end_sector > *sectors ) {
 			*sectors = end_sector;
-			DBGC ( sandev->drive, "INT13 drive %02x guessing "
-			       "C/H/S xx/xx/%d based on partition %d\n",
+			DBGC ( sandev, "INT13 drive %02x guessing C/H/S "
+			       "xx/xx/%d based on partition %d\n",
 			       sandev->drive, *sectors, ( i + 1 ) );
 		}
 	}
@@ -344,10 +343,9 @@ static int int13_guess_geometry_fdd ( struct san_device *sandev,
 		*heads = INT13_FDD_HEADS ( geometry );
 		*sectors = INT13_FDD_SECTORS ( geometry );
 		if ( ( cylinders * (*heads) * (*sectors) ) == blocks ) {
-			DBGC ( sandev->drive, "INT13 drive %02x guessing "
-			       "C/H/S %d/%d/%d based on size %dK\n",
-			       sandev->drive, cylinders, *heads, *sectors,
-			       ( blocks / 2 ) );
+			DBGC ( sandev, "INT13 drive %02x guessing C/H/S "
+			       "%d/%d/%d based on size %dK\n", sandev->drive,
+			       cylinders, *heads, *sectors, ( blocks / 2 ) );
 			return 0;
 		}
 	}
@@ -357,9 +355,8 @@ static int int13_guess_geometry_fdd ( struct san_device *sandev,
 	 */
 	*heads = 2;
 	*sectors = 18;
-	DBGC ( sandev->drive, "INT13 drive %02x guessing C/H/S xx/%d/%d "
-	       "based on size %dK\n", sandev->drive, *heads, *sectors,
-	       ( blocks / 2 ) );
+	DBGC ( sandev, "INT13 drive %02x guessing C/H/S xx/%d/%d based on size "
+	       "%dK\n", sandev->drive, *heads, *sectors, ( blocks / 2 ) );
 	return 0;
 }
 
@@ -434,8 +431,8 @@ static void int13_sync_num_drives ( void ) {
 		required = ( ( max_drive & 0x7f ) + 1 );
 		if ( *counter < required ) {
 			*counter = required;
-			DBGC ( sandev->drive, "INT13 drive %02x added to "
-			       "drive count: %d HDDs, %d FDDs\n",
+			DBGC ( sandev, "INT13 drive %02x added to drive count: "
+			       "%d HDDs, %d FDDs\n",
 			       sandev->drive, num_drives, num_fdds );
 		}
 	}
@@ -475,7 +472,7 @@ static int int13_reset ( struct san_device *sandev,
 			 struct i386_all_regs *ix86 __unused ) {
 	int rc;
 
-	DBGC2 ( sandev->drive, "Reset drive\n" );
+	DBGC2 ( sandev, "Reset drive\n" );
 
 	/* Reset SAN device */
 	if ( ( rc = sandev_reset ( sandev ) ) != 0 )
@@ -494,7 +491,7 @@ static int int13_get_last_status ( struct san_device *sandev,
 				   struct i386_all_regs *ix86 __unused ) {
 	struct int13_data *int13 = sandev->priv;
 
-	DBGC2 ( sandev->drive, "Get status of last operation\n" );
+	DBGC2 ( sandev, "Get status of last operation\n" );
 	return int13->last_status;
 }
 
@@ -527,8 +524,8 @@ static int int13_rw_sectors ( struct san_device *sandev,
 
 	/* Validate blocksize */
 	if ( sandev_blksize ( sandev ) != INT13_BLKSIZE ) {
-		DBGC ( sandev->drive, "\nINT 13 drive %02x invalid blocksize "
-		       "(%zd) for non-extended read/write\n",
+		DBGC ( sandev, "\nINT 13 drive %02x invalid blocksize (%zd) "
+		       "for non-extended read/write\n",
 		       sandev->drive, sandev_blksize ( sandev ) );
 		return -INT13_STATUS_INVALID;
 	}
@@ -540,10 +537,9 @@ static int int13_rw_sectors ( struct san_device *sandev,
 	if ( ( cylinder >= int13->cylinders ) ||
 	     ( head >= int13->heads ) ||
 	     ( sector < 1 ) || ( sector > int13->sectors_per_track ) ) {
-		DBGC ( sandev->drive, "C/H/S %d/%d/%d out of range for "
-		       "geometry %d/%d/%d\n", cylinder, head, sector,
-		       int13->cylinders, int13->heads,
-		       int13->sectors_per_track );
+		DBGC ( sandev, "C/H/S %d/%d/%d out of range for geometry "
+		       "%d/%d/%d\n", cylinder, head, sector, int13->cylinders,
+		       int13->heads, int13->sectors_per_track );
 		return -INT13_STATUS_INVALID;
 	}
 	lba = ( ( ( ( cylinder * int13->heads ) + head )
@@ -551,13 +547,13 @@ static int int13_rw_sectors ( struct san_device *sandev,
 	count = ix86->regs.al;
 	buffer = real_to_user ( ix86->segs.es, ix86->regs.bx );
 
-	DBGC2 ( sandev->drive, "C/H/S %d/%d/%d = LBA %08lx <-> %04x:%04x "
-		"(count %d)\n", cylinder, head, sector, lba, ix86->segs.es,
-		ix86->regs.bx, count );
+	DBGC2 ( sandev, "C/H/S %d/%d/%d = LBA %08lx <-> %04x:%04x (count %d)\n",
+		cylinder, head, sector, lba, ix86->segs.es, ix86->regs.bx,
+		count );
 
 	/* Read from / write to block device */
 	if ( ( rc = sandev_rw ( sandev, lba, count, buffer ) ) != 0 ){
-		DBGC ( sandev->drive, "INT13 drive %02x I/O failed: %s\n",
+		DBGC ( sandev, "INT13 drive %02x I/O failed: %s\n",
 		       sandev->drive, strerror ( rc ) );
 		return -INT13_STATUS_READ_ERROR;
 	}
@@ -581,7 +577,7 @@ static int int13_rw_sectors ( struct san_device *sandev,
 static int int13_read_sectors ( struct san_device *sandev,
 				struct i386_all_regs *ix86 ) {
 
-	DBGC2 ( sandev->drive, "Read: " );
+	DBGC2 ( sandev, "Read: " );
 	return int13_rw_sectors ( sandev, ix86, sandev_read );
 }
 
@@ -601,7 +597,7 @@ static int int13_read_sectors ( struct san_device *sandev,
 static int int13_write_sectors ( struct san_device *sandev,
 				 struct i386_all_regs *ix86 ) {
 
-	DBGC2 ( sandev->drive, "Write: " );
+	DBGC2 ( sandev, "Write: " );
 	return int13_rw_sectors ( sandev, ix86, sandev_write );
 }
 
@@ -623,12 +619,12 @@ static int int13_get_parameters ( struct san_device *sandev,
 	unsigned int max_head = int13->heads - 1;
 	unsigned int max_sector = int13->sectors_per_track; /* sic */
 
-	DBGC2 ( sandev->drive, "Get drive parameters\n" );
+	DBGC2 ( sandev, "Get drive parameters\n" );
 
 	/* Validate blocksize */
 	if ( sandev_blksize ( sandev ) != INT13_BLKSIZE ) {
-		DBGC ( sandev->drive, "\nINT 13 drive %02x invalid blocksize "
-		       "(%zd) for non-extended parameters\n",
+		DBGC ( sandev, "\nINT 13 drive %02x invalid blocksize (%zd) "
+		       "for non-extended parameters\n",
 		       sandev->drive, sandev_blksize ( sandev ) );
 		return -INT13_STATUS_INVALID;
 	}
@@ -661,7 +657,7 @@ static int int13_get_disk_type ( struct san_device *sandev,
 				 struct i386_all_regs *ix86 ) {
 	uint32_t blocks;
 
-	DBGC2 ( sandev->drive, "Get disk type\n" );
+	DBGC2 ( sandev, "Get disk type\n" );
 
 	if ( int13_is_fdd ( sandev ) ) {
 		return INT13_DISK_TYPE_FDD;
@@ -686,7 +682,7 @@ static int int13_extension_check ( struct san_device *sandev,
 				   struct i386_all_regs *ix86 ) {
 
 	if ( ( ix86->regs.bx == 0x55aa ) && ! int13_is_fdd ( sandev ) ) {
-		DBGC2 ( sandev->drive, "INT13 extensions check\n" );
+		DBGC2 ( sandev, "INT13 extensions installation check\n" );
 		ix86->regs.bx = 0xaa55;
 		ix86->regs.cx = ( INT13_EXTENSION_LINEAR |
 				  INT13_EXTENSION_EDD |
@@ -729,8 +725,7 @@ static int int13_extended_rw ( struct san_device *sandev,
 	get_real ( bufsize, ix86->segs.ds,
 		   ( ix86->regs.si + offsetof ( typeof ( addr ), bufsize ) ) );
 	if ( bufsize < offsetof ( typeof ( addr ), buffer_phys ) ) {
-		DBGC2 ( sandev->drive, "<invalid buffer size %#02x\n>\n",
-			bufsize );
+		DBGC2 ( sandev, "<invalid buffer size %#02x\n>\n", bufsize );
 		return -INT13_STATUS_INVALID;
 	}
 
@@ -738,18 +733,17 @@ static int int13_extended_rw ( struct san_device *sandev,
 	memset ( &addr, 0, sizeof ( addr ) );
 	copy_from_real ( &addr, ix86->segs.ds, ix86->regs.si, bufsize );
 	lba = addr.lba;
-	DBGC2 ( sandev->drive, "LBA %08llx <-> ",
-		( ( unsigned long long ) lba ) );
+	DBGC2 ( sandev, "LBA %08llx <-> ", ( ( unsigned long long ) lba ) );
 	if ( ( addr.count == 0xff ) ||
 	     ( ( addr.buffer.segment == 0xffff ) &&
 	       ( addr.buffer.offset == 0xffff ) ) ) {
 		buffer = phys_to_user ( addr.buffer_phys );
-		DBGC2 ( sandev->drive, "%08llx",
+		DBGC2 ( sandev, "%08llx",
 			( ( unsigned long long ) addr.buffer_phys ) );
 	} else {
 		buffer = real_to_user ( addr.buffer.segment,
 					addr.buffer.offset );
-		DBGC2 ( sandev->drive, "%04x:%04x", addr.buffer.segment,
+		DBGC2 ( sandev, "%04x:%04x", addr.buffer.segment,
 			addr.buffer.offset );
 	}
 	if ( addr.count <= 0x7f ) {
@@ -757,15 +751,15 @@ static int int13_extended_rw ( struct san_device *sandev,
 	} else if ( addr.count == 0xff ) {
 		count = addr.long_count;
 	} else {
-		DBGC2 ( sandev->drive, " <invalid count %#02x>\n", addr.count );
+		DBGC2 ( sandev, " <invalid count %#02x>\n", addr.count );
 		return -INT13_STATUS_INVALID;
 	}
-	DBGC2 ( sandev->drive, " (count %ld)\n", count );
+	DBGC2 ( sandev, " (count %ld)\n", count );
 
 	/* Read from / write to block device */
 	if ( ( rc = sandev_rw ( sandev, lba, count, buffer ) ) != 0 ) {
-		DBGC ( sandev->drive, "INT13 drive %02x extended I/O failed: "
-		       "%s\n", sandev->drive, strerror ( rc ) );
+		DBGC ( sandev, "INT13 drive %02x extended I/O failed: %s\n",
+		       sandev->drive, strerror ( rc ) );
 		/* Record that no blocks were transferred successfully */
 		addr.count = 0;
 		put_real ( addr.count, ix86->segs.ds,
@@ -787,7 +781,7 @@ static int int13_extended_rw ( struct san_device *sandev,
 static int int13_extended_read ( struct san_device *sandev,
 				 struct i386_all_regs *ix86 ) {
 
-	DBGC2 ( sandev->drive, "Extended read: " );
+	DBGC2 ( sandev, "Extended read: " );
 	return int13_extended_rw ( sandev, ix86, sandev_read );
 }
 
@@ -801,7 +795,7 @@ static int int13_extended_read ( struct san_device *sandev,
 static int int13_extended_write ( struct san_device *sandev,
 				  struct i386_all_regs *ix86 ) {
 
-	DBGC2 ( sandev->drive, "Extended write: " );
+	DBGC2 ( sandev, "Extended write: " );
 	return int13_extended_rw ( sandev, ix86, sandev_write );
 }
 
@@ -824,7 +818,7 @@ static int int13_extended_verify ( struct san_device *sandev,
 				 sizeof ( addr ));
 		lba = addr.lba;
 		count = addr.count;
-		DBGC2 ( sandev->drive, "Verify: LBA %08llx (count %ld)\n",
+		DBGC2 ( sandev, "Verify: LBA %08llx (count %ld)\n",
 			( ( unsigned long long ) lba ), count );
 	}
 
@@ -851,7 +845,7 @@ static int int13_extended_seek ( struct san_device *sandev,
 				 sizeof ( addr ));
 		lba = addr.lba;
 		count = addr.count;
-		DBGC2 ( sandev->drive, "Seek: LBA %08llx (count %ld)\n",
+		DBGC2 ( sandev, "Seek: LBA %08llx (count %ld)\n",
 			( ( unsigned long long ) lba ), count );
 	}
 
@@ -885,8 +879,8 @@ static int int13_device_path_info ( struct san_device *sandev,
 	/* Get underlying hardware device */
 	device = identify_device ( &sanpath->block );
 	if ( ! device ) {
-		DBGC ( sandev->drive, "INT13 drive %02x cannot identify "
-		       "hardware device\n", sandev->drive );
+		DBGC ( sandev, "INT13 drive %02x cannot identify hardware "
+		       "device\n", sandev->drive );
 		return -ENODEV;
 	}
 
@@ -901,16 +895,16 @@ static int int13_device_path_info ( struct san_device *sandev,
 		dpi->interface_path.pci.channel = 0xff; /* unused */
 		break;
 	default:
-		DBGC ( sandev->drive, "INT13 drive %02x unrecognised bus "
-		       "type %d\n", sandev->drive, desc->bus_type );
+		DBGC ( sandev, "INT13 drive %02x unrecognised bus type %d\n",
+		       sandev->drive, desc->bus_type );
 		return -ENOTSUP;
 	}
 
 	/* Get EDD block device description */
 	if ( ( rc = edd_describe ( &sanpath->block, &dpi->interface_type,
 				   &dpi->device_path ) ) != 0 ) {
-		DBGC ( sandev->drive, "INT13 drive %02x cannot identify "
-		       "block device: %s\n", sandev->drive, strerror ( rc ) );
+		DBGC ( sandev, "INT13 drive %02x cannot identify block device: "
+		       "%s\n", sandev->drive, strerror ( rc ) );
 		return rc;
 	}
 
@@ -944,8 +938,8 @@ static int int13_get_extended_parameters ( struct san_device *sandev,
 	get_real ( bufsize, ix86->segs.ds,
 		   ( ix86->regs.si + offsetof ( typeof ( params ), bufsize )));
 
-	DBGC2 ( sandev->drive, "Get extended drive parameters to "
-		"%04x:%04x+%02x\n", ix86->segs.ds, ix86->regs.si, bufsize );
+	DBGC2 ( sandev, "Get extended drive parameters to %04x:%04x+%02x\n",
+		ix86->segs.ds, ix86->regs.si, bufsize );
 
 	/* Build drive parameters */
 	memset ( &params, 0, sizeof ( params ) );
@@ -961,8 +955,8 @@ static int int13_get_extended_parameters ( struct san_device *sandev,
 	params.sector_size = sandev_blksize ( sandev );
 	memset ( &params.dpte, 0xff, sizeof ( params.dpte ) );
 	if ( ( rc = int13_device_path_info ( sandev, &params.dpi ) ) != 0 ) {
-		DBGC ( sandev->drive, "INT13 drive %02x could not provide "
-		       "device path information: %s\n",
+		DBGC ( sandev, "INT13 drive %02x could not provide device "
+		       "path information: %s\n",
 		       sandev->drive, strerror ( rc ) );
 		len = offsetof ( typeof ( params ), dpi );
 	}
@@ -979,11 +973,11 @@ static int int13_get_extended_parameters ( struct san_device *sandev,
 		params.bufsize = offsetof ( typeof ( params ), dpi );
 	}
 
-	DBGC ( sandev->drive, "INT 13 drive %02x described using extended "
+	DBGC ( sandev, "INT 13 drive %02x described using extended "
 	       "parameters:\n", sandev->drive );
 	address.segment = ix86->segs.ds;
 	address.offset = ix86->regs.si;
-	DBGC_HDA ( sandev->drive, address, &params, len );
+	DBGC_HDA ( sandev, address, &params, len );
 
 	/* Return drive parameters */
 	if ( len > bufsize )
@@ -1004,13 +998,13 @@ static int int13_cdrom_status_terminate ( struct san_device *sandev,
 					  struct i386_all_regs *ix86 ) {
 	struct int13_cdrom_specification specification;
 
-	DBGC2 ( sandev->drive, "Get CD-ROM emulation status to %04x:%04x%s\n",
+	DBGC2 ( sandev, "Get CD-ROM emulation status to %04x:%04x%s\n",
 		ix86->segs.ds, ix86->regs.si,
 		( ix86->regs.al ? "" : " and terminate" ) );
 
 	/* Fail if we are not a CD-ROM */
 	if ( ! sandev->is_cdrom ) {
-		DBGC ( sandev->drive, "INT13 drive %02x is not a CD-ROM\n",
+		DBGC ( sandev, "INT13 drive %02x is not a CD-ROM\n",
 		       sandev->drive );
 		return -INT13_STATUS_INVALID;
 	}
@@ -1045,12 +1039,11 @@ static int int13_cdrom_read_boot_catalog ( struct san_device *sandev,
 	/* Read parameters from command packet */
 	copy_from_real ( &command, ix86->segs.ds, ix86->regs.si,
 			 sizeof ( command ) );
-	DBGC2 ( sandev->drive, "Read CD-ROM boot catalog to %08x\n",
-		command.buffer );
+	DBGC2 ( sandev, "Read CD-ROM boot catalog to %08x\n", command.buffer );
 
 	/* Fail if we have no boot catalog */
 	if ( ! int13->boot_catalog ) {
-		DBGC ( sandev->drive, "INT13 drive %02x has no boot catalog\n",
+		DBGC ( sandev, "INT13 drive %02x has no boot catalog\n",
 		       sandev->drive );
 		return -INT13_STATUS_INVALID;
 	}
@@ -1059,8 +1052,8 @@ static int int13_cdrom_read_boot_catalog ( struct san_device *sandev,
 	/* Read from boot catalog */
 	if ( ( rc = sandev_read ( sandev, start, command.count,
 				  phys_to_user ( command.buffer ) ) ) != 0 ) {
-		DBGC ( sandev->drive, "INT13 drive %02x could not read boot "
-		       "catalog: %s\n", sandev->drive, strerror ( rc ) );
+		DBGC ( sandev, "INT13 drive %02x could not read boot catalog: "
+		       "%s\n", sandev->drive, strerror ( rc ) );
 		return -INT13_STATUS_READ_ERROR;
 	}
 
@@ -1087,8 +1080,8 @@ static __asmcall __used void int13 ( struct i386_all_regs *ix86 ) {
 		if ( bios_drive != sandev->drive ) {
 			/* Remap any accesses to this drive's natural number */
 			if ( bios_drive == int13->natural_drive ) {
-				DBGC2 ( sandev->drive, "INT13,%02x (%02x) "
-					"remapped to (%02x)\n", ix86->regs.ah,
+				DBGC2 ( sandev, "INT13,%02x (%02x) remapped to "
+					"(%02x)\n", ix86->regs.ah,
 					bios_drive, sandev->drive );
 				ix86->regs.dl = sandev->drive;
 				return;
@@ -1101,7 +1094,7 @@ static __asmcall __used void int13 ( struct i386_all_regs *ix86 ) {
 			}
 		}
 		
-		DBGC2 ( sandev->drive, "INT13,%02x (%02x): ",
+		DBGC2 ( sandev, "INT13,%02x (%02x): ",
 			ix86->regs.ah, bios_drive );
 
 		switch ( command ) {
@@ -1148,7 +1141,7 @@ static __asmcall __used void int13 ( struct i386_all_regs *ix86 ) {
 			status = int13_cdrom_read_boot_catalog ( sandev, ix86 );
 			break;
 		default:
-			DBGC2 ( sandev->drive, "*** Unrecognised INT13 ***\n" );
+			DBGC2 ( sandev, "*** Unrecognised INT13 ***\n" );
 			status = -INT13_STATUS_INVALID;
 			break;
 		}
@@ -1159,9 +1152,8 @@ static __asmcall __used void int13 ( struct i386_all_regs *ix86 ) {
 		/* Negative status indicates an error */
 		if ( status < 0 ) {
 			status = -status;
-			DBGC ( sandev->drive, "INT13,%02x (%02x) failed with "
-			       "status %02x\n", ix86->regs.ah, sandev->drive,
-			       status );
+			DBGC ( sandev, "INT13,%02x (%02x) failed with status "
+			       "%02x\n", ix86->regs.ah, sandev->drive, status );
 		} else {
 			ix86->flags &= ~CF;
 		}
@@ -1277,7 +1269,7 @@ static int int13_hook ( unsigned int drive, struct uri **uris,
 
 	/* Register SAN device */
 	if ( ( rc = register_sandev ( sandev, drive, flags ) ) != 0 ) {
-		DBGC ( drive, "INT13 drive %02x could not register: %s\n",
+		DBGC ( sandev, "INT13 drive %02x could not register: %s\n",
 		       drive, strerror ( rc ) );
 		goto err_register;
 	}
@@ -1297,9 +1289,10 @@ static int int13_hook ( unsigned int drive, struct uri **uris,
 	     ( ( rc = int13_guess_geometry ( sandev, scratch ) ) != 0 ) )
 		goto err_guess_geometry;
 
-	DBGC ( drive, "INT13 drive %02x (naturally %02x) registered with "
-	       "C/H/S geometry %d/%d/%d\n", drive, int13->natural_drive,
-	       int13->cylinders, int13->heads, int13->sectors_per_track );
+	DBGC ( sandev, "INT13 drive %02x (naturally %02x) registered with "
+	       "C/H/S geometry %d/%d/%d\n",
+	       sandev->drive, int13->natural_drive, int13->cylinders,
+	       int13->heads, int13->sectors_per_track );
 
 	/* Hook INT 13 vector if not already hooked */
 	if ( need_hook ) {
@@ -1339,7 +1332,7 @@ static void int13_unhook ( unsigned int drive ) {
 	/* Find drive */
 	sandev = sandev_find ( drive );
 	if ( ! sandev ) {
-		DBGC ( drive, "INT13 drive %02x is not a SAN drive\n", drive );
+		DBG ( "INT13 cannot find drive %02x\n", drive );
 		return;
 	}
 
@@ -1350,7 +1343,7 @@ static void int13_unhook ( unsigned int drive ) {
 	 * to do so reliably.
 	 */
 
-	DBGC ( drive, "INT13 drive %02x unregistered\n", drive );
+	DBGC ( sandev, "INT13 drive %02x unregistered\n", sandev->drive );
 
 	/* Unhook INT 13 vector if no more drives */
 	if ( ! have_sandevs() ) {
@@ -1394,8 +1387,8 @@ static int int13_load_mbr ( unsigned int drive, struct segoff *address ) {
 			       : "a" ( 0x0201 ), "b" ( *address ),
 				 "c" ( 1 ), "d" ( drive ) );
 	if ( status ) {
-		DBGC ( drive, "INT13 drive %02x could not read MBR (status "
-		       "%04x)\n", drive, status );
+		DBG ( "INT13 drive %02x could not read MBR (status %04x)\n",
+		      drive, status );
 		return -EIO;
 	}
 
@@ -1404,8 +1397,8 @@ static int int13_load_mbr ( unsigned int drive, struct segoff *address ) {
 		   ( address->offset +
 		     offsetof ( struct master_boot_record, magic ) ) );
 	if ( magic != INT13_MBR_MAGIC ) {
-		DBGC ( drive, "INT13 drive %02x does not contain a valid MBR\n",
-		       drive );
+		DBG ( "INT13 drive %02x does not contain a valid MBR\n",
+		      drive );
 		return -ENOEXEC;
 	}
 
@@ -1451,8 +1444,8 @@ static int int13_load_eltorito ( unsigned int drive, struct segoff *address ) {
 			       : "a" ( 0x4d00 ), "d" ( drive ),
 				 "S" ( __from_data16 ( &eltorito_cmd ) ) );
 	if ( status ) {
-		DBGC ( drive, "INT13 drive %02x could not read El Torito boot "
-		       "catalog (status %04x)\n", drive, status );
+		DBG ( "INT13 drive %02x could not read El Torito boot catalog "
+		      "(status %04x)\n", drive, status );
 		return -EIO;
 	}
 	copy_from_user ( &catalog, phys_to_user ( eltorito_cmd.buffer ), 0,
@@ -1460,27 +1453,26 @@ static int int13_load_eltorito ( unsigned int drive, struct segoff *address ) {
 
 	/* Sanity checks */
 	if ( catalog.valid.platform_id != ELTORITO_PLATFORM_X86 ) {
-		DBGC ( drive, "INT13 drive %02x El Torito specifies unknown "
-		       "platform %02x\n", drive, catalog.valid.platform_id );
+		DBG ( "INT13 drive %02x El Torito specifies unknown platform "
+		      "%02x\n", drive, catalog.valid.platform_id );
 		return -ENOEXEC;
 	}
 	if ( catalog.boot.indicator != ELTORITO_BOOTABLE ) {
-		DBGC ( drive, "INT13 drive %02x El Torito is not bootable\n",
-		       drive );
+		DBG ( "INT13 drive %02x El Torito is not bootable\n", drive );
 		return -ENOEXEC;
 	}
 	if ( catalog.boot.media_type != ELTORITO_NO_EMULATION ) {
-		DBGC ( drive, "INT13 drive %02x El Torito requires emulation "
+		DBG ( "INT13 drive %02x El Torito requires emulation "
 		       "type %02x\n", drive, catalog.boot.media_type );
 		return -ENOTSUP;
 	}
-	DBGC ( drive, "INT13 drive %02x El Torito boot image at LBA %08x "
-	       "(count %d)\n", drive, catalog.boot.start, catalog.boot.length );
+	DBG ( "INT13 drive %02x El Torito boot image at LBA %08x (count %d)\n",
+	      drive, catalog.boot.start, catalog.boot.length );
 	address->segment = ( catalog.boot.load_segment ?
 			     catalog.boot.load_segment : 0x7c0 );
 	address->offset = 0;
-	DBGC ( drive, "INT13 drive %02x El Torito boot image loads at "
-	       "%04x:%04x\n", drive, address->segment, address->offset );
+	DBG ( "INT13 drive %02x El Torito boot image loads at %04x:%04x\n",
+	      drive, address->segment, address->offset );
 
 	/* Use INT 13, 42 to read the boot image */
 	eltorito_address.bufsize =
@@ -1499,8 +1491,8 @@ static int int13_load_eltorito ( unsigned int drive, struct segoff *address ) {
 			       : "a" ( 0x4200 ), "d" ( drive ),
 				 "S" ( __from_data16 ( &eltorito_address ) ) );
 	if ( status ) {
-		DBGC ( drive, "INT13 drive %02x could not read El Torito boot "
-		       "image (status %04x)\n", drive, status );
+		DBG ( "INT13 drive %02x could not read El Torito boot image "
+		      "(status %04x)\n", drive, status );
 		return -EIO;
 	}
 
@@ -1511,7 +1503,7 @@ static int int13_load_eltorito ( unsigned int drive, struct segoff *address ) {
  * Attempt to boot from an INT 13 drive
  *
  * @v drive		Drive number
- * @v config		Boot configuration parameters
+ * @v filename		Filename (or NULL to use default)
  * @ret rc		Return status code
  *
  * This boots from the specified INT 13 drive by loading the Master
@@ -1521,8 +1513,7 @@ static int int13_load_eltorito ( unsigned int drive, struct segoff *address ) {
  *
  * Note that this function can never return success, by definition.
  */
-static int int13_boot ( unsigned int drive,
-			struct san_boot_config *config __unused ) {
+static int int13_boot ( unsigned int drive, const char *filename __unused ) {
 	struct memory_map memmap;
 	struct segoff address;
 	int rc;
@@ -1542,8 +1533,8 @@ static int int13_boot ( unsigned int drive,
 	/* Jump to boot sector */
 	if ( ( rc = call_bootsector ( address.segment, address.offset,
 				      drive ) ) != 0 ) {
-		DBGC ( drive, "INT13 drive %02x boot returned: %s\n",
-		       drive, strerror ( rc ) );
+		DBG ( "INT13 drive %02x boot returned: %s\n",
+		      drive, strerror ( rc ) );
 		return rc;
 	}
 

src/arch/x86/interface/pcbios/pcicloud.c

@@ -165,27 +165,24 @@ static void pcicloud_init ( void ) {
 	static struct pci_api *apis[] = {
 		&ecam_api, &pcibios_api, &pcidirect_api
 	};
-	struct pci_device pci;
-	uint32_t busdevfn;
+	struct pci_range range;
 	unsigned int i;
-	int rc;
 
-	/* Select first API that successfully discovers a PCI device */
+	/* Select first API that successfully discovers an address range */
 	for ( i = 0 ; i < ( sizeof ( apis ) / sizeof ( apis[0] ) ) ; i++ ) {
 		pcicloud = apis[i];
-		busdevfn = 0;
-		if ( ( rc = pci_find_next ( &pci, &busdevfn ) ) == 0 ) {
-			DBGC ( pcicloud, "PCICLOUD selected %s API (found "
-			       PCI_FMT ")\n", pcicloud->name,
-			       PCI_ARGS ( &pci ) );
-			return;
+		pcicloud_discover ( 0, &range );
+		if ( range.count != 0 ) {
+			DBGC ( pcicloud, "PCICLOUD selected %s API\n",
+			       pcicloud->name );
+			break;
 		}
 	}
 
-	/* Fall back to using final attempted API if no devices found */
-	pcicloud = apis[ i - 1 ];
-	DBGC ( pcicloud, "PCICLOUD selected %s API (nothing detected)\n",
-	       pcicloud->name );
+	/* The PCI direct API can never fail discovery since the range
+	 * is hardcoded.
+	 */
+	assert ( range.count != 0 );
 }
 
 /** Cloud VM PCI configuration space access initialisation function */

src/arch/x86/interface/pcbios/rtc_entropy.c

@@ -39,14 +39,9 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 #include <ipxe/cpuid.h>
 #include <ipxe/entropy.h>
 
-struct entropy_source rtc_entropy __entropy_source ( ENTROPY_NORMAL );
-
 /** Maximum time to wait for an RTC interrupt, in milliseconds */
 #define RTC_MAX_WAIT_MS 100
 
-/** Number of RTC interrupts to check for */
-#define RTC_CHECK_COUNT 3
-
 /** RTC interrupt handler */
 extern void rtc_isr ( void );
 
@@ -150,7 +145,6 @@ static void rtc_disable_int ( void ) {
  * @ret rc		Return status code
  */
 static int rtc_entropy_check ( void ) {
-	unsigned int count = 0;
 	unsigned int i;
 
 	/* Check that RTC interrupts are working */
@@ -164,18 +158,14 @@ static int rtc_entropy_check ( void ) {
 				       "cli\n\t" );
 
 		/* Check for RTC interrupt flag */
-		if ( rtc_flag ) {
-			rtc_flag = 0;
-			if ( ++count >= RTC_CHECK_COUNT )
-				return 0;
-		}
+		if ( rtc_flag )
+			return 0;
 
 		/* Delay */
 		mdelay ( 1 );
 	}
 
-	DBGC ( &rtc_flag, "RTC timed out waiting for interrupt %d/%d\n",
-	       ( count + 1 ), RTC_CHECK_COUNT );
+	DBGC ( &rtc_flag, "RTC timed out waiting for interrupt\n" );
 	return -ETIMEDOUT;
 }
 
@@ -205,21 +195,6 @@ static int rtc_entropy_enable ( void ) {
 	if ( ( rc = rtc_entropy_check() ) != 0 )
 		goto err_check;
 
-	/* The min-entropy has been measured on several platforms
-	 * using the entropy_sample test code.  Modelling the samples
-	 * as independent, and using a confidence level of 99.99%, the
-	 * measurements were as follows:
-	 *
-	 *    qemu-kvm		: 7.38 bits
-	 *    VMware		: 7.46 bits
-	 *    Physical hardware	: 2.67 bits
-	 *
-	 * We choose the lowest of these (2.67 bits) and apply a 50%
-	 * safety margin to allow for some potential non-independence
-	 * of samples.
-	 */
-	entropy_init ( &rtc_entropy, MIN_ENTROPY ( 1.3 ) );
-
 	return 0;
 
  err_check:
@@ -243,12 +218,11 @@ static void rtc_entropy_disable ( void ) {
 }
 
 /**
- * Get noise sample
+ * Measure a single RTC tick
  *
- * @ret noise		Noise sample
- * @ret rc		Return status code
+ * @ret delta		Length of RTC tick (in TSC units)
  */
-static int rtc_get_noise ( noise_sample_t *noise ) {
+uint8_t rtc_sample ( void ) {
 	uint32_t before;
 	uint32_t after;
 	uint32_t temp;
@@ -283,14 +257,10 @@ static int rtc_get_noise ( noise_sample_t *noise ) {
 		: "=a" ( after ), "=d" ( before ), "=Q" ( temp )
 		: "2" ( 0 ) );
 
-	*noise = ( after - before );
-	return 0;
+	return ( after - before );
 }
 
-/** RTC entropy source */
-struct entropy_source rtc_entropy __entropy_source ( ENTROPY_NORMAL ) = {
-	.name = "rtc",
-	.enable = rtc_entropy_enable,
-	.disable = rtc_entropy_disable,
-	.get_noise = rtc_get_noise,
-};
+PROVIDE_ENTROPY_INLINE ( rtc, min_entropy_per_sample );
+PROVIDE_ENTROPY ( rtc, entropy_enable, rtc_entropy_enable );
+PROVIDE_ENTROPY ( rtc, entropy_disable, rtc_entropy_disable );
+PROVIDE_ENTROPY_INLINE ( rtc, get_noise );

src/arch/x86/interface/pxe/pxe_call.c

@@ -375,10 +375,9 @@ int pxe_start_nbp ( void ) {
  * Notify BIOS of existence of network device
  *
  * @v netdev		Network device
- * @v priv		Private data
  * @ret rc		Return status code
  */
-static int pxe_notify ( struct net_device *netdev, void *priv __unused ) {
+static int pxe_notify ( struct net_device *netdev ) {
 
 	/* Do nothing if we already have a network device */
 	if ( pxe_netdev )