Sync ahc with NetBSD, which was in turn updated from FreeBSD by Pascal

Renauld of Network Storage Solutions, Inc. Many fixes, wider device
support. In particular, the notorious 'Target 0' problem seems to be
fixed.

Does *not* include any updates to isa or eisa code beyond what was
necessary to compile.

Known issues:

1) Tagged Queuing is probably not optimal.

2) PPR negotiation may not be fully functional.

3) No support yet for freezing devices or channels.

4) The mechanism for preventing 'A' and 'B' channel confusion during probe
can fail if scsibus > 254 found.

5) Requeuing I/O's not working. A workaround will be committed almost
immediately. At the moment timeouts, SCSI message rejects, aborting
SCB's and trying to freeze a device may cause incomplete i/o's to be
reported as complete.

6) Verbosity and probe messages need work.

7) Last disk on bus seems to go through an extra re-negotiation.

8) >16 devices on an adapter will trigger the usual problems of total
openings exceeding available SCB's under heavy load.

Tested by deraadt@, beck@, miod@, naddy@, drahn@, marc@ amoung
others.

ok deraadt@.

17 files changed, 1582 insertions, 1213 deletions

diff --git a/sys/dev/microcode/aic7xxx/Makefile b/sys/dev/microcode/aic7xxx/Makefile
index 727fca11b29..7e5ff7f1df3 100644
--- a/sys/dev/microcode/aic7xxx/Makefile
+++ b/sys/dev/microcode/aic7xxx/Makefile
@@ -1,4 +1,4 @@
-# $OpenBSD: Makefile,v 1.6 2003/12/24 22:40:16 krw Exp $
+# $OpenBSD: Makefile,v 1.7 2003/12/24 23:27:55 krw Exp $
 # $FreeBSD: src/sys/dev/aic7xxx/Makefile,v 1.6 1999/08/28 00:41:22 peter Exp $
 
 PROG=	aicasm
diff --git a/sys/dev/microcode/aic7xxx/aic79xx.reg b/sys/dev/microcode/aic7xxx/aic79xx.reg
index 927974e69ab..cf6cfbda8a6 100644
--- a/sys/dev/microcode/aic7xxx/aic79xx.reg
+++ b/sys/dev/microcode/aic7xxx/aic79xx.reg
@@ -1,4 +1,4 @@
-/*	$OpenBSD: aic79xx.reg,v 1.1 2003/12/24 22:40:16 krw Exp $	*/
+/*	$OpenBSD: aic79xx.reg,v 1.2 2003/12/24 23:27:55 krw Exp $	*/
 /*	$NetBSD: aic79xx.reg,v 1.8 2003/08/29 03:45:59 thorpej Exp $	*/
 
 /*
diff --git a/sys/dev/microcode/aic7xxx/aic79xx.seq b/sys/dev/microcode/aic7xxx/aic79xx.seq
index 456d9b07000..6a7842397cc 100644
--- a/sys/dev/microcode/aic7xxx/aic79xx.seq
+++ b/sys/dev/microcode/aic7xxx/aic79xx.seq
@@ -1,4 +1,4 @@
-/*	$OpenBSD: aic79xx.seq,v 1.1 2003/12/24 22:40:16 krw Exp $	*/
+/*	$OpenBSD: aic79xx.seq,v 1.2 2003/12/24 23:27:55 krw Exp $	*/
 /*	$NetBSD: aic79xx.seq,v 1.8 2003/08/29 03:54:06 thorpej Exp $	*/
 
 /*
diff --git a/sys/dev/microcode/aic7xxx/aic79xx_seq.h b/sys/dev/microcode/aic7xxx/aic79xx_seq.h
index a6458651968..fc60a06dc89 100644
--- a/sys/dev/microcode/aic7xxx/aic79xx_seq.h
+++ b/sys/dev/microcode/aic7xxx/aic79xx_seq.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: aic79xx_seq.h,v 1.1 2003/12/24 22:40:16 krw Exp $	*/
+/*	$OpenBSD: aic79xx_seq.h,v 1.2 2003/12/24 23:27:55 krw Exp $	*/
 /*
  * DO NOT EDIT - This file is automatically generated
  *		 from the following source files:
diff --git a/sys/dev/microcode/aic7xxx/aic7xxx.reg b/sys/dev/microcode/aic7xxx/aic7xxx.reg
index 65007a9ae77..4acf5382b77 100644
--- a/sys/dev/microcode/aic7xxx/aic7xxx.reg
+++ b/sys/dev/microcode/aic7xxx/aic7xxx.reg
@@ -1,4 +1,4 @@
-/* $OpenBSD: aic7xxx.reg,v 1.7 2003/12/24 22:40:16 krw Exp $ */
+/* $OpenBSD: aic7xxx.reg,v 1.8 2003/12/24 23:27:55 krw Exp $ */
 /*
  * Aic7xxx register and scratch ram definitions.
  *
diff --git a/sys/dev/microcode/aic7xxx/aic7xxx.seq b/sys/dev/microcode/aic7xxx/aic7xxx.seq
index b42d25c26d4..31c85be47d6 100644
--- a/sys/dev/microcode/aic7xxx/aic7xxx.seq
+++ b/sys/dev/microcode/aic7xxx/aic7xxx.seq
@@ -1,4 +1,4 @@
-/* $OpenBSD: aic7xxx.seq,v 1.14 2003/12/24 22:40:16 krw Exp $ */
+/* $OpenBSD: aic7xxx.seq,v 1.15 2003/12/24 23:27:55 krw Exp $ */
 /*
  * Adaptec 274x/284x/294x device driver firmware for Linux and FreeBSD.
  *
diff --git a/sys/dev/microcode/aic7xxx/aic7xxx_reg.h b/sys/dev/microcode/aic7xxx/aic7xxx_reg.h
index aa4a1fb6f61..f0eb6a8f8fe 100644
--- a/sys/dev/microcode/aic7xxx/aic7xxx_reg.h
+++ b/sys/dev/microcode/aic7xxx/aic7xxx_reg.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: aic7xxx_reg.h,v 1.5 2003/12/24 23:15:00 krw Exp $ */
+/* $OpenBSD: aic7xxx_reg.h,v 1.6 2003/12/24 23:27:55 krw Exp $ */
 /*
  * DO NOT EDIT - This file is automatically generated
  *		 from the following source files:
diff --git a/sys/dev/microcode/aic7xxx/aic7xxx_seq.h b/sys/dev/microcode/aic7xxx/aic7xxx_seq.h
index 6d90775b2d1..8ce02ad9e34 100644
--- a/sys/dev/microcode/aic7xxx/aic7xxx_seq.h
+++ b/sys/dev/microcode/aic7xxx/aic7xxx_seq.h
@@ -1,15 +1,15 @@
-/* $OpenBSD: aic7xxx_seq.h,v 1.12 2003/08/28 02:32:47 krw Exp $ */
+/* $OpenBSD: aic7xxx_seq.h,v 1.13 2003/12/24 23:27:55 krw Exp $ */
 /*
  * DO NOT EDIT - This file is automatically generated
  *		 from the following source files:
  *
- * $Id: aic7xxx_seq.h,v 1.12 2003/08/28 02:32:47 krw Exp $
- * $Id: aic7xxx_seq.h,v 1.12 2003/08/28 02:32:47 krw Exp $
+ * $NetBSD: aic7xxx.seq,v 1.15 2003/05/03 18:11:31 wiz Exp $
+ * $NetBSD: aic7xxx.reg,v 1.2 2003/04/19 19:26:10 fvdl Exp $
  */
-static const u_int8_t seqprog[] = {
+static uint8_t seqprog[] = {
 	0xb2, 0x00, 0x00, 0x08,
 	0xf7, 0x11, 0x22, 0x08,
-	0x00, 0x65, 0xe0, 0x59,
+	0x00, 0x65, 0xec, 0x59,
 	0xf7, 0x01, 0x02, 0x08,
 	0xff, 0x6a, 0x24, 0x08,
 	0x40, 0x00, 0x40, 0x68,
@@ -22,15 +22,15 @@ static const u_int8_t seqprog[] = {
 	0x01, 0x4d, 0xc8, 0x30,
 	0x00, 0x4c, 0x12, 0x70,
 	0x01, 0x39, 0xa2, 0x30,
-	0x00, 0x6a, 0xaa, 0x5e,
+	0x00, 0x6a, 0xd4, 0x5e,
 	0x01, 0x51, 0x20, 0x31,
 	0x01, 0x57, 0xae, 0x00,
 	0x0d, 0x6a, 0x76, 0x00,
-	0x00, 0x51, 0xfc, 0x5d,
+	0x00, 0x51, 0x26, 0x5e,
 	0x01, 0x51, 0xc8, 0x30,
-	0x00, 0x39, 0xda, 0x60,
+	0x00, 0x39, 0xc8, 0x60,
 	0x00, 0xbb, 0x30, 0x70,
-	0xc1, 0x6a, 0xc2, 0x5e,
+	0xc1, 0x6a, 0xec, 0x5e,
 	0x01, 0xbf, 0x72, 0x30,
 	0x01, 0x40, 0x7e, 0x31,
 	0x01, 0x90, 0x80, 0x30,
@@ -38,22 +38,22 @@ static const u_int8_t seqprog[] = {
 	0x01, 0x4d, 0x9a, 0x18,
 	0xfe, 0x57, 0xae, 0x08,
 	0x01, 0x40, 0x20, 0x31,
-	0x00, 0x65, 0xde, 0x58,
+	0x00, 0x65, 0xcc, 0x58,
 	0x60, 0x0b, 0x40, 0x78,
 	0x08, 0x6a, 0x18, 0x00,
 	0x08, 0x11, 0x22, 0x00,
 	0x60, 0x0b, 0x00, 0x78,
-	0x40, 0x0b, 0x0e, 0x69,
-	0x80, 0x0b, 0xc6, 0x78,
+	0x40, 0x0b, 0xfa, 0x68,
+	0x80, 0x0b, 0xb6, 0x78,
 	0x20, 0x6a, 0x16, 0x00,
 	0xa4, 0x6a, 0x06, 0x00,
-	0x08, 0x3c, 0x78, 0x00,
+	0x08, 0x6a, 0x78, 0x00,
 	0x01, 0x50, 0xc8, 0x30,
 	0xe0, 0x6a, 0xcc, 0x00,
-	0x48, 0x6a, 0xe6, 0x5d,
+	0x48, 0x6a, 0x10, 0x5e,
 	0x01, 0x6a, 0xdc, 0x01,
 	0x88, 0x6a, 0xcc, 0x00,
-	0x48, 0x6a, 0xe6, 0x5d,
+	0x48, 0x6a, 0x10, 0x5e,
 	0x01, 0x6a, 0x26, 0x01,
 	0xf0, 0x19, 0x7a, 0x08,
 	0x0f, 0x18, 0xc8, 0x08,
@@ -64,228 +64,234 @@ static const u_int8_t seqprog[] = {
 	0x80, 0x3d, 0x7a, 0x00,
 	0x01, 0x3d, 0xd8, 0x31,
 	0x01, 0x3d, 0x32, 0x31,
-	0x10, 0x03, 0x58, 0x79,
-	0x00, 0x65, 0x06, 0x59,
-	0x80, 0x66, 0xa2, 0x78,
+	0x10, 0x03, 0x4e, 0x79,
+	0x00, 0x65, 0xf2, 0x58,
+	0x80, 0x66, 0xae, 0x78,
 	0x01, 0x66, 0xd8, 0x31,
 	0x01, 0x66, 0x32, 0x31,
-	0x40, 0x66, 0x80, 0x68,
+	0x1f, 0x66, 0x7c, 0x08,
+	0x40, 0x66, 0x82, 0x68,
 	0x01, 0x3c, 0x78, 0x00,
-	0x10, 0x03, 0xaa, 0x78,
-	0x00, 0x65, 0x06, 0x59,
+	0x10, 0x03, 0x9e, 0x78,
+	0x00, 0x65, 0xf2, 0x58,
 	0xe0, 0x66, 0xc8, 0x18,
 	0x00, 0x65, 0xaa, 0x50,
 	0xdd, 0x66, 0xc8, 0x18,
 	0x00, 0x65, 0xaa, 0x48,
 	0x01, 0x66, 0xd8, 0x31,
 	0x01, 0x66, 0x32, 0x31,
-	0x10, 0x03, 0x58, 0x79,
-	0x00, 0x65, 0x06, 0x59,
+	0x10, 0x03, 0x4e, 0x79,
+	0x00, 0x65, 0xf2, 0x58,
 	0x01, 0x66, 0xd8, 0x31,
 	0x01, 0x66, 0x32, 0x31,
 	0x01, 0x66, 0xac, 0x30,
 	0x40, 0x3c, 0x78, 0x00,
-	0x10, 0x03, 0xa0, 0x78,
-	0x00, 0x65, 0x06, 0x59,
-	0x00, 0x65, 0xaa, 0x40,
-	0x61, 0x6a, 0xc2, 0x5e,
-	0x08, 0x51, 0x30, 0x71,
-	0x02, 0x0b, 0xa6, 0x78,
-	0x00, 0x65, 0xa2, 0x40,
-	0x80, 0x86, 0xc8, 0x08,
-	0x01, 0x4f, 0xc8, 0x30,
-	0x00, 0x50, 0xbc, 0x60,
-	0xc4, 0x6a, 0x58, 0x5d,
-	0x40, 0x3c, 0xb8, 0x78,
-	0x28, 0x6a, 0x6e, 0x5d,
-	0x00, 0x65, 0x56, 0x41,
-	0x08, 0x6a, 0x6e, 0x5d,
-	0x00, 0x65, 0x56, 0x41,
 	0xff, 0x6a, 0xd8, 0x01,
 	0xff, 0x6a, 0x32, 0x01,
-	0x90, 0x3c, 0x78, 0x00,
-	0x10, 0x03, 0x4c, 0x69,
-	0x00, 0x65, 0x30, 0x41,
-	0x08, 0x19, 0xd2, 0x69,
+	0x10, 0x3c, 0x78, 0x00,
+	0x02, 0x57, 0x40, 0x69,
+	0x10, 0x03, 0x3e, 0x69,
+	0x00, 0x65, 0x20, 0x41,
+	0x02, 0x57, 0xae, 0x00,
+	0x00, 0x65, 0x9e, 0x40,
+	0x61, 0x6a, 0xec, 0x5e,
+	0x08, 0x51, 0x20, 0x71,
+	0x02, 0x0b, 0xb2, 0x78,
+	0x00, 0x65, 0xae, 0x40,
 	0x1a, 0x01, 0x02, 0x00,
 	0xf0, 0x19, 0x7a, 0x08,
 	0x0f, 0x0f, 0xc8, 0x08,
 	0x0f, 0x05, 0xc8, 0x08,
 	0x00, 0x3d, 0x7a, 0x00,
-	0x08, 0x1f, 0xd6, 0x78,
+	0x08, 0x1f, 0xc4, 0x78,
 	0x80, 0x3d, 0x7a, 0x00,
 	0x20, 0x6a, 0x16, 0x00,
-	0x00, 0x65, 0xc0, 0x41,
-	0x00, 0x65, 0x9c, 0x5e,
+	0x00, 0x65, 0xcc, 0x41,
+	0x00, 0x65, 0xc6, 0x5e,
 	0x00, 0x65, 0x12, 0x40,
-	0x20, 0x11, 0xe4, 0x68,
+	0x20, 0x11, 0xd2, 0x68,
 	0x20, 0x6a, 0x18, 0x00,
 	0x20, 0x11, 0x22, 0x00,
 	0xf7, 0x1f, 0xca, 0x08,
-	0x80, 0xb9, 0xea, 0x78,
+	0x80, 0xb9, 0xd8, 0x78,
 	0x08, 0x65, 0xca, 0x00,
 	0x01, 0x65, 0x3e, 0x30,
 	0x01, 0xb9, 0x1e, 0x30,
 	0x7f, 0xb9, 0x0a, 0x08,
 	0x01, 0xb9, 0x0a, 0x30,
 	0x01, 0x54, 0xca, 0x30,
-	0x80, 0xb8, 0xf8, 0x78,
+	0x80, 0xb8, 0xe6, 0x78,
 	0x80, 0x65, 0xca, 0x00,
 	0x01, 0x65, 0x00, 0x34,
 	0x01, 0x54, 0x00, 0x34,
-	0x1a, 0x01, 0x02, 0x00,
-	0x08, 0xb8, 0x02, 0x79,
+	0x08, 0xb8, 0xee, 0x78,
 	0x20, 0x01, 0x02, 0x00,
 	0x02, 0xbd, 0x08, 0x34,
 	0x01, 0xbd, 0x08, 0x34,
 	0x08, 0x01, 0x02, 0x00,
-	0x02, 0x0b, 0x08, 0x79,
+	0x02, 0x0b, 0xf4, 0x78,
 	0xf7, 0x01, 0x02, 0x08,
 	0x01, 0x06, 0xcc, 0x34,
 	0xb2, 0x00, 0x00, 0x08,
-	0x40, 0x6a, 0x16, 0x00,
 	0x01, 0x40, 0x20, 0x31,
 	0x01, 0xbf, 0x80, 0x30,
 	0x01, 0xb9, 0x7a, 0x30,
 	0x01, 0xba, 0x7c, 0x30,
-	0x00, 0x65, 0xfc, 0x58,
-	0x80, 0x0b, 0xbc, 0x79,
-	0xe4, 0x6a, 0x58, 0x5d,
-	0x80, 0xba, 0x6e, 0x5d,
-	0x20, 0xb8, 0x28, 0x79,
-	0x20, 0x6a, 0x6e, 0x5d,
-	0x00, 0xa3, 0x6e, 0x5d,
-	0x01, 0xa0, 0x78, 0x30,
-	0x10, 0xb8, 0x30, 0x79,
-	0xe4, 0x6a, 0x58, 0x5d,
-	0x00, 0x65, 0xa2, 0x40,
-	0x10, 0x03, 0x48, 0x69,
-	0x08, 0x3c, 0x64, 0x69,
-	0x04, 0x3c, 0x8a, 0x69,
-	0x02, 0x3c, 0x90, 0x69,
-	0x01, 0x3c, 0x4e, 0x79,
-	0x01, 0x6a, 0xa2, 0x30,
-	0x00, 0x65, 0x9c, 0x59,
-	0x04, 0x51, 0x3e, 0x61,
-	0x00, 0x6a, 0xaa, 0x5e,
+	0x00, 0x65, 0xea, 0x58,
+	0x80, 0x0b, 0xc4, 0x79,
+	0x12, 0x01, 0x02, 0x00,
+	0x01, 0xab, 0xac, 0x30,
+	0xe4, 0x6a, 0x82, 0x5d,
+	0x40, 0x6a, 0x16, 0x00,
+	0x80, 0xba, 0x98, 0x5d,
+	0x20, 0xb8, 0x18, 0x79,
+	0x20, 0x6a, 0x98, 0x5d,
+	0x00, 0xab, 0x98, 0x5d,
+	0x01, 0xa9, 0x78, 0x30,
+	0x10, 0xb8, 0x20, 0x79,
+	0xe4, 0x6a, 0x82, 0x5d,
+	0x00, 0x65, 0xae, 0x40,
+	0x10, 0x03, 0x3c, 0x69,
+	0x08, 0x3c, 0x5a, 0x69,
+	0x04, 0x3c, 0x92, 0x69,
+	0x02, 0x3c, 0x98, 0x69,
+	0x01, 0x3c, 0x44, 0x79,
+	0xff, 0x6a, 0x70, 0x00,
+	0x00, 0x65, 0xa4, 0x59,
+	0x00, 0x6a, 0xd4, 0x5e,
+	0xff, 0x38, 0x30, 0x71,
 	0x0d, 0x6a, 0x76, 0x00,
-	0x00, 0xbb, 0xfc, 0x5d,
-	0x00, 0x65, 0x28, 0x41,
+	0x00, 0x38, 0x26, 0x5e,
+	0x00, 0x65, 0xea, 0x58,
+	0x12, 0x01, 0x02, 0x00,
+	0x00, 0x65, 0x18, 0x41,
 	0xa4, 0x6a, 0x06, 0x00,
-	0x00, 0x65, 0x06, 0x59,
-	0x00, 0x65, 0xa2, 0x40,
-	0xe4, 0x6a, 0x58, 0x5d,
-	0x20, 0x3c, 0x54, 0x79,
-	0x02, 0x6a, 0x6e, 0x5d,
-	0x04, 0x6a, 0x6e, 0x5d,
-	0x01, 0x03, 0x56, 0x69,
+	0x00, 0x65, 0xf2, 0x58,
+	0xfd, 0x57, 0xae, 0x08,
+	0x00, 0x65, 0xae, 0x40,
+	0xe4, 0x6a, 0x82, 0x5d,
+	0x20, 0x3c, 0x4a, 0x79,
+	0x02, 0x6a, 0x98, 0x5d,
+	0x04, 0x6a, 0x98, 0x5d,
+	0x01, 0x03, 0x4c, 0x69,
 	0xf7, 0x11, 0x22, 0x08,
 	0xff, 0x6a, 0x24, 0x08,
 	0xff, 0x6a, 0x06, 0x08,
 	0x01, 0x6a, 0x7e, 0x00,
-	0x00, 0x65, 0x9c, 0x59,
+	0x00, 0x65, 0xa4, 0x59,
 	0x00, 0x65, 0x04, 0x40,
-	0x84, 0x6a, 0x58, 0x5d,
-	0x00, 0x65, 0x06, 0x59,
+	0x80, 0x86, 0xc8, 0x08,
+	0x01, 0x4f, 0xc8, 0x30,
+	0x00, 0x50, 0x6c, 0x61,
+	0xc4, 0x6a, 0x82, 0x5d,
+	0x40, 0x3c, 0x68, 0x79,
+	0x28, 0x6a, 0x98, 0x5d,
+	0x00, 0x65, 0x4c, 0x41,
+	0x08, 0x6a, 0x98, 0x5d,
+	0x00, 0x65, 0x4c, 0x41,
+	0x84, 0x6a, 0x82, 0x5d,
+	0x00, 0x65, 0xf2, 0x58,
 	0x01, 0x66, 0xc8, 0x30,
 	0x01, 0x64, 0xd8, 0x31,
 	0x01, 0x64, 0x32, 0x31,
 	0x5b, 0x64, 0xc8, 0x28,
 	0x30, 0x64, 0xca, 0x18,
 	0x01, 0x6c, 0xc8, 0x30,
-	0xff, 0x64, 0x86, 0x79,
+	0xff, 0x64, 0x8e, 0x79,
 	0x08, 0x01, 0x02, 0x00,
-	0x02, 0x0b, 0x78, 0x79,
-	0x01, 0x64, 0x7e, 0x61,
+	0x02, 0x0b, 0x80, 0x79,
+	0x01, 0x64, 0x86, 0x61,
 	0xf7, 0x01, 0x02, 0x08,
 	0x01, 0x06, 0xd8, 0x31,
 	0x01, 0x06, 0x32, 0x31,
 	0xff, 0x64, 0xc8, 0x18,
-	0xff, 0x64, 0x78, 0x69,
+	0xff, 0x64, 0x80, 0x69,
 	0xf7, 0x3c, 0x78, 0x08,
-	0x00, 0x65, 0x30, 0x41,
-	0x40, 0xa1, 0x7e, 0x10,
-	0x04, 0xa1, 0x58, 0x5d,
-	0x00, 0x65, 0x52, 0x42,
-	0xc4, 0x6a, 0x58, 0x5d,
+	0x00, 0x65, 0x20, 0x41,
+	0x40, 0xaa, 0x7e, 0x10,
+	0x04, 0xaa, 0x82, 0x5d,
+	0x00, 0x65, 0x5e, 0x42,
+	0xc4, 0x6a, 0x82, 0x5d,
 	0xc0, 0x6a, 0x7e, 0x00,
-	0x00, 0xa2, 0x6e, 0x5d,
+	0x00, 0xa8, 0x98, 0x5d,
 	0xe4, 0x6a, 0x06, 0x00,
-	0x00, 0x6a, 0x6e, 0x5d,
-	0x00, 0x65, 0x56, 0x41,
-	0x10, 0x3c, 0xa0, 0x69,
-	0x00, 0xbb, 0x76, 0x44,
+	0x00, 0x6a, 0x98, 0x5d,
+	0x00, 0x65, 0x4c, 0x41,
+	0x10, 0x3c, 0xa8, 0x69,
+	0x00, 0xbb, 0x9e, 0x44,
 	0x18, 0x6a, 0xda, 0x01,
 	0x01, 0x69, 0xd8, 0x31,
 	0x1c, 0x6a, 0xd0, 0x01,
 	0x09, 0xee, 0xdc, 0x01,
-	0x80, 0xee, 0xa8, 0x79,
+	0x80, 0xee, 0xb0, 0x79,
 	0xff, 0x6a, 0xdc, 0x09,
 	0x01, 0x93, 0x26, 0x01,
 	0x03, 0x6a, 0x2a, 0x01,
 	0x01, 0x69, 0x32, 0x31,
-	0x1c, 0x6a, 0xca, 0x5d,
+	0x1c, 0x6a, 0xf4, 0x5d,
 	0x0a, 0x93, 0x26, 0x01,
-	0x00, 0x65, 0x92, 0x5e,
+	0x00, 0x65, 0xbc, 0x5e,
 	0x01, 0x50, 0xa0, 0x18,
 	0x02, 0x6a, 0x22, 0x05,
+	0x1a, 0x01, 0x02, 0x00,
 	0x80, 0x6a, 0x74, 0x00,
-	0x80, 0x3c, 0x78, 0x00,
-	0x00, 0x65, 0xc2, 0x5d,
+	0x40, 0x6a, 0x78, 0x00,
+	0x40, 0x6a, 0x16, 0x00,
+	0x00, 0x65, 0xec, 0x5d,
 	0x01, 0x3f, 0xc8, 0x30,
-	0xbf, 0x64, 0x52, 0x7a,
-	0x80, 0x64, 0x9c, 0x73,
-	0xa0, 0x64, 0xfa, 0x73,
-	0xc0, 0x64, 0xee, 0x73,
-	0xe0, 0x64, 0x2a, 0x74,
-	0x01, 0x6a, 0xc2, 0x5e,
-	0x00, 0x65, 0xc0, 0x41,
+	0xbf, 0x64, 0x5e, 0x7a,
+	0x80, 0x64, 0xb2, 0x73,
+	0xa0, 0x64, 0x14, 0x74,
+	0xc0, 0x64, 0x08, 0x74,
+	0xe0, 0x64, 0x44, 0x74,
+	0x01, 0x6a, 0xec, 0x5e,
+	0x00, 0x65, 0xcc, 0x41,
 	0xf7, 0x11, 0x22, 0x08,
 	0x01, 0x06, 0xd4, 0x30,
 	0xff, 0x6a, 0x24, 0x08,
 	0xf7, 0x01, 0x02, 0x08,
-	0x09, 0x0c, 0xda, 0x79,
+	0x09, 0x0c, 0xe6, 0x79,
 	0x08, 0x0c, 0x04, 0x68,
-	0xb1, 0x6a, 0xc2, 0x5e,
+	0xb1, 0x6a, 0xec, 0x5e,
 	0xff, 0x6a, 0x26, 0x09,
 	0x12, 0x01, 0x02, 0x00,
 	0x02, 0x6a, 0x08, 0x30,
 	0xff, 0x6a, 0x08, 0x08,
 	0xdf, 0x01, 0x02, 0x08,
 	0x01, 0x6a, 0x7e, 0x00,
-	0xff, 0x6a, 0x78, 0x0c,
+	0xc0, 0x6a, 0x78, 0x04,
 	0xff, 0x6a, 0xc8, 0x08,
 	0x08, 0xa4, 0x48, 0x19,
 	0x00, 0xa5, 0x4a, 0x21,
 	0x00, 0xa6, 0x4c, 0x21,
 	0x00, 0xa7, 0x4e, 0x25,
-	0x08, 0xeb, 0xc6, 0x7e,
-	0x80, 0xeb, 0xfa, 0x79,
+	0x08, 0xeb, 0xf0, 0x7e,
+	0x80, 0xeb, 0x06, 0x7a,
 	0xff, 0x6a, 0xd6, 0x09,
-	0x08, 0xeb, 0xfe, 0x69,
+	0x08, 0xeb, 0x0a, 0x6a,
 	0xff, 0x6a, 0xd4, 0x0c,
-	0x80, 0xa3, 0xc6, 0x6e,
-	0x88, 0xeb, 0x14, 0x72,
-	0x08, 0xeb, 0xc6, 0x6e,
-	0x04, 0xea, 0x18, 0xe2,
-	0x08, 0xee, 0xc6, 0x6e,
+	0x80, 0xa3, 0xf0, 0x6e,
+	0x88, 0xeb, 0x20, 0x72,
+	0x08, 0xeb, 0xf0, 0x6e,
+	0x04, 0xea, 0x24, 0xe2,
+	0x08, 0xee, 0xf0, 0x6e,
 	0x04, 0x6a, 0xd0, 0x81,
 	0x05, 0xa4, 0xc0, 0x89,
 	0x03, 0xa5, 0xc2, 0x31,
 	0x09, 0x6a, 0xd6, 0x05,
-	0x00, 0x65, 0xfc, 0x59,
+	0x00, 0x65, 0x08, 0x5a,
 	0x06, 0xa4, 0xd4, 0x89,
-	0x80, 0x94, 0xc6, 0x7e,
+	0x80, 0x94, 0xf0, 0x7e,
 	0x07, 0xe9, 0x10, 0x31,
-	0x01, 0x8c, 0x20, 0x7a,
+	0x01, 0x8c, 0x2c, 0x7a,
 	0x01, 0x55, 0xaa, 0x10,
 	0x01, 0xe9, 0x46, 0x31,
-	0x00, 0xa3, 0xa4, 0x5e,
-	0x00, 0x65, 0xee, 0x59,
+	0x00, 0xa3, 0xce, 0x5e,
+	0x00, 0x65, 0xfa, 0x59,
 	0x01, 0xa4, 0xca, 0x30,
-	0x01, 0x55, 0x2c, 0x7a,
+	0x01, 0x55, 0x38, 0x7a,
 	0x04, 0x65, 0xca, 0x00,
-	0x80, 0xa3, 0x30, 0x7a,
+	0x80, 0xa3, 0x3c, 0x7a,
 	0x02, 0x65, 0xca, 0x00,
 	0x01, 0x65, 0xf8, 0x31,
 	0x80, 0x93, 0x26, 0x01,
@@ -293,168 +299,168 @@ static const u_int8_t seqprog[] = {
 	0x01, 0x8c, 0xc8, 0x30,
 	0x00, 0x88, 0xc8, 0x18,
 	0x02, 0x64, 0xc8, 0x88,
-	0xff, 0x64, 0xc6, 0x7e,
-	0xff, 0x8d, 0x46, 0x6a,
-	0xff, 0x8e, 0x46, 0x6a,
+	0xff, 0x64, 0xf0, 0x7e,
+	0xff, 0x8d, 0x52, 0x6a,
+	0xff, 0x8e, 0x52, 0x6a,
 	0x03, 0x8c, 0xd4, 0x98,
-	0x00, 0x65, 0xc6, 0x56,
+	0x00, 0x65, 0xf0, 0x56,
 	0x01, 0x64, 0x70, 0x30,
 	0xff, 0x64, 0xc8, 0x10,
 	0x01, 0x64, 0xc8, 0x18,
 	0x00, 0x8c, 0x18, 0x19,
 	0xff, 0x8d, 0x1a, 0x21,
 	0xff, 0x8e, 0x1c, 0x25,
-	0x80, 0x3c, 0x56, 0x6a,
-	0x21, 0x6a, 0xc2, 0x46,
+	0xc0, 0x3c, 0x62, 0x7a,
+	0x21, 0x6a, 0xec, 0x5e,
 	0xa8, 0x6a, 0x76, 0x00,
 	0x79, 0x6a, 0x76, 0x00,
-	0x40, 0x3f, 0x5e, 0x6a,
+	0x40, 0x3f, 0x6a, 0x6a,
 	0x04, 0x3b, 0x76, 0x00,
 	0x04, 0x6a, 0xd4, 0x81,
-	0x20, 0x3c, 0x66, 0x7a,
-	0x51, 0x6a, 0xc2, 0x5e,
-	0x00, 0x65, 0x80, 0x42,
+	0x20, 0x3c, 0x72, 0x7a,
+	0x51, 0x6a, 0xec, 0x5e,
+	0x00, 0x65, 0x8c, 0x42,
 	0x20, 0x3c, 0x78, 0x00,
-	0x00, 0xb3, 0xa4, 0x5e,
+	0x00, 0xb3, 0xce, 0x5e,
 	0x07, 0xac, 0x10, 0x31,
 	0x05, 0xb3, 0x46, 0x31,
 	0x88, 0x6a, 0xcc, 0x00,
-	0xac, 0x6a, 0xd8, 0x5d,
+	0xac, 0x6a, 0x02, 0x5e,
 	0xa3, 0x6a, 0xcc, 0x00,
-	0xb3, 0x6a, 0xdc, 0x5d,
-	0x00, 0x65, 0x36, 0x5a,
+	0xb3, 0x6a, 0x06, 0x5e,
+	0x00, 0x65, 0x42, 0x5a,
 	0xfd, 0xa4, 0x48, 0x09,
 	0x01, 0x8c, 0xaa, 0x08,
 	0x03, 0x8c, 0x10, 0x30,
-	0x00, 0x65, 0xd0, 0x5d,
-	0x01, 0xa4, 0x92, 0x7a,
+	0x00, 0x65, 0xfa, 0x5d,
+	0x01, 0xa4, 0x9e, 0x7a,
 	0x04, 0x3b, 0x76, 0x08,
 	0x01, 0x3b, 0x26, 0x31,
 	0x80, 0x02, 0x04, 0x00,
-	0x10, 0x0c, 0x88, 0x7a,
-	0x03, 0x9e, 0x8a, 0x6a,
+	0x10, 0x0c, 0x94, 0x7a,
+	0x03, 0x9e, 0x96, 0x6a,
 	0x7f, 0x02, 0x04, 0x08,
-	0x91, 0x6a, 0xc2, 0x5e,
-	0x00, 0x65, 0xc0, 0x41,
+	0x91, 0x6a, 0xec, 0x5e,
+	0x00, 0x65, 0xcc, 0x41,
 	0x01, 0xa4, 0xca, 0x30,
-	0x80, 0xa3, 0x98, 0x7a,
+	0x80, 0xa3, 0xa4, 0x7a,
 	0x02, 0x65, 0xca, 0x00,
-	0x01, 0x55, 0x9c, 0x7a,
+	0x01, 0x55, 0xa8, 0x7a,
 	0x04, 0x65, 0xca, 0x00,
 	0x01, 0x65, 0xf8, 0x31,
 	0x01, 0x3b, 0x26, 0x31,
-	0x00, 0x65, 0x02, 0x5a,
-	0x01, 0xfc, 0xaa, 0x6a,
-	0x80, 0x0b, 0xa0, 0x6a,
-	0x10, 0x0c, 0xa0, 0x7a,
-	0x20, 0x93, 0xa0, 0x6a,
+	0x00, 0x65, 0x0e, 0x5a,
+	0x01, 0xfc, 0xb6, 0x6a,
+	0x80, 0x0b, 0xac, 0x6a,
+	0x10, 0x0c, 0xac, 0x7a,
+	0x20, 0x93, 0xac, 0x6a,
 	0x02, 0x93, 0x26, 0x01,
-	0x02, 0xfc, 0xb4, 0x7a,
-	0x40, 0x0d, 0xce, 0x6a,
+	0x02, 0xfc, 0xc0, 0x7a,
+	0x40, 0x0d, 0xda, 0x6a,
 	0x01, 0xa4, 0x48, 0x01,
-	0x00, 0x65, 0xce, 0x42,
-	0x40, 0x0d, 0xba, 0x6a,
-	0x00, 0x65, 0x02, 0x5a,
-	0x00, 0x65, 0xac, 0x42,
-	0x80, 0xfc, 0xc4, 0x7a,
-	0x80, 0xa4, 0xc4, 0x6a,
+	0x00, 0x65, 0xda, 0x42,
+	0x40, 0x0d, 0xc6, 0x6a,
+	0x00, 0x65, 0x0e, 0x5a,
+	0x00, 0x65, 0xb8, 0x42,
+	0x80, 0xfc, 0xd0, 0x7a,
+	0x80, 0xa4, 0xd0, 0x6a,
 	0xff, 0xa5, 0x4a, 0x19,
 	0xff, 0xa6, 0x4c, 0x21,
 	0xff, 0xa7, 0x4e, 0x21,
 	0xf8, 0xfc, 0x48, 0x09,
 	0xff, 0x6a, 0xaa, 0x08,
-	0x04, 0xfc, 0xcc, 0x7a,
+	0x04, 0xfc, 0xd8, 0x7a,
 	0x01, 0x55, 0xaa, 0x00,
 	0xff, 0x6a, 0x46, 0x09,
-	0x04, 0x3b, 0xe6, 0x6a,
+	0x04, 0x3b, 0xf2, 0x6a,
 	0x02, 0x93, 0x26, 0x01,
-	0x01, 0x94, 0xd0, 0x7a,
-	0x01, 0x94, 0xd0, 0x7a,
-	0x01, 0x94, 0xd0, 0x7a,
-	0x01, 0x94, 0xd0, 0x7a,
-	0x01, 0x94, 0xd0, 0x7a,
-	0x01, 0xa4, 0xe4, 0x7a,
-	0x01, 0xfc, 0xde, 0x7a,
-	0x01, 0x94, 0xe6, 0x6a,
-	0x00, 0x65, 0x80, 0x42,
-	0x01, 0x94, 0xe4, 0x7a,
-	0x10, 0x94, 0xe6, 0x6a,
+	0x01, 0x94, 0xdc, 0x7a,
+	0x01, 0x94, 0xdc, 0x7a,
+	0x01, 0x94, 0xdc, 0x7a,
+	0x01, 0x94, 0xdc, 0x7a,
+	0x01, 0x94, 0xdc, 0x7a,
+	0x01, 0xa4, 0xf0, 0x7a,
+	0x01, 0xfc, 0xea, 0x7a,
+	0x01, 0x94, 0xf2, 0x6a,
+	0x00, 0x65, 0x8c, 0x42,
+	0x01, 0x94, 0xf0, 0x7a,
+	0x10, 0x94, 0xf2, 0x6a,
 	0xd7, 0x93, 0x26, 0x09,
-	0x28, 0x93, 0xea, 0x6a,
+	0x28, 0x93, 0xf6, 0x6a,
 	0x01, 0x85, 0x0a, 0x01,
-	0x02, 0xfc, 0xf2, 0x6a,
+	0x02, 0xfc, 0xfe, 0x6a,
 	0x01, 0x14, 0x46, 0x31,
 	0xff, 0x6a, 0x10, 0x09,
 	0xfe, 0x85, 0x0a, 0x09,
-	0xff, 0x38, 0x00, 0x6b,
-	0x80, 0xa3, 0x00, 0x7b,
-	0x80, 0x0b, 0xfe, 0x7a,
-	0x04, 0x3b, 0x00, 0x7b,
+	0xff, 0x38, 0x0c, 0x6b,
+	0x80, 0xa3, 0x0c, 0x7b,
+	0x80, 0x0b, 0x0a, 0x7b,
+	0x04, 0x3b, 0x0c, 0x7b,
 	0xbf, 0x3b, 0x76, 0x08,
 	0x01, 0x3b, 0x26, 0x31,
-	0x00, 0x65, 0x02, 0x5a,
-	0x01, 0x0b, 0x0e, 0x6b,
-	0x10, 0x0c, 0x02, 0x7b,
-	0x04, 0x93, 0x0c, 0x6b,
-	0x01, 0x94, 0x0a, 0x7b,
-	0x10, 0x94, 0x0c, 0x6b,
+	0x00, 0x65, 0x0e, 0x5a,
+	0x01, 0x0b, 0x1a, 0x6b,
+	0x10, 0x0c, 0x0e, 0x7b,
+	0x04, 0x93, 0x18, 0x6b,
+	0x01, 0x94, 0x16, 0x7b,
+	0x10, 0x94, 0x18, 0x6b,
 	0xc7, 0x93, 0x26, 0x09,
 	0x01, 0x99, 0xd4, 0x30,
-	0x38, 0x93, 0x10, 0x6b,
-	0xff, 0x08, 0x62, 0x6b,
-	0xff, 0x09, 0x62, 0x6b,
-	0xff, 0x0a, 0x62, 0x6b,
-	0xff, 0x38, 0x2c, 0x7b,
+	0x38, 0x93, 0x1c, 0x6b,
+	0xff, 0x08, 0x6e, 0x6b,
+	0xff, 0x09, 0x6e, 0x6b,
+	0xff, 0x0a, 0x6e, 0x6b,
+	0xff, 0x38, 0x38, 0x7b,
 	0x04, 0x14, 0x10, 0x31,
 	0x01, 0x38, 0x18, 0x31,
 	0x02, 0x6a, 0x1a, 0x31,
 	0x88, 0x6a, 0xcc, 0x00,
-	0x14, 0x6a, 0xde, 0x5d,
-	0x00, 0x38, 0xca, 0x5d,
+	0x14, 0x6a, 0x08, 0x5e,
+	0x00, 0x38, 0xf4, 0x5d,
 	0xff, 0x6a, 0x70, 0x08,
-	0x00, 0x65, 0x58, 0x43,
-	0x80, 0xa3, 0x32, 0x7b,
+	0x00, 0x65, 0x64, 0x43,
+	0x80, 0xa3, 0x3e, 0x7b,
 	0x01, 0xa4, 0x48, 0x01,
-	0x00, 0x65, 0x62, 0x43,
-	0x08, 0xeb, 0x38, 0x7b,
-	0x00, 0x65, 0x02, 0x5a,
-	0x08, 0xeb, 0x34, 0x6b,
+	0x00, 0x65, 0x6e, 0x43,
+	0x08, 0xeb, 0x44, 0x7b,
+	0x00, 0x65, 0x0e, 0x5a,
+	0x08, 0xeb, 0x40, 0x6b,
 	0x07, 0xe9, 0x10, 0x31,
 	0x01, 0xe9, 0xca, 0x30,
 	0x01, 0x65, 0x46, 0x31,
-	0x00, 0x6a, 0xa4, 0x5e,
+	0x00, 0x6a, 0xce, 0x5e,
 	0x88, 0x6a, 0xcc, 0x00,
-	0xa4, 0x6a, 0xde, 0x5d,
-	0x08, 0x6a, 0xca, 0x5d,
+	0xa4, 0x6a, 0x08, 0x5e,
+	0x08, 0x6a, 0xf4, 0x5d,
 	0x0d, 0x93, 0x26, 0x01,
-	0x00, 0x65, 0x92, 0x5e,
+	0x00, 0x65, 0xbc, 0x5e,
 	0x88, 0x6a, 0xcc, 0x00,
-	0x00, 0x65, 0x74, 0x5e,
+	0x00, 0x65, 0x9e, 0x5e,
 	0x01, 0x99, 0x46, 0x31,
-	0x00, 0xa3, 0xa4, 0x5e,
+	0x00, 0xa3, 0xce, 0x5e,
 	0x01, 0x88, 0x10, 0x31,
-	0x00, 0x65, 0x36, 0x5a,
-	0x00, 0x65, 0xee, 0x59,
+	0x00, 0x65, 0x42, 0x5a,
+	0x00, 0x65, 0xfa, 0x59,
 	0x03, 0x8c, 0x10, 0x30,
-	0x00, 0x65, 0xd0, 0x5d,
-	0x01, 0x8c, 0x60, 0x7b,
+	0x00, 0x65, 0xfa, 0x5d,
+	0x01, 0x8c, 0x6c, 0x7b,
 	0x01, 0x55, 0xaa, 0x10,
-	0x80, 0x0b, 0x80, 0x6a,
-	0x80, 0x0b, 0x6a, 0x6b,
-	0x01, 0x0c, 0x64, 0x7b,
-	0x10, 0x0c, 0x80, 0x7a,
-	0x03, 0x9e, 0x80, 0x6a,
-	0x00, 0x65, 0xf8, 0x59,
-	0x00, 0x6a, 0xa4, 0x5e,
-	0x01, 0xa4, 0x8a, 0x6b,
-	0xff, 0x38, 0x80, 0x7b,
+	0x80, 0x0b, 0x8c, 0x6a,
+	0x80, 0x0b, 0x76, 0x6b,
+	0x01, 0x0c, 0x70, 0x7b,
+	0x10, 0x0c, 0x8c, 0x7a,
+	0x03, 0x9e, 0x8c, 0x6a,
+	0x00, 0x65, 0x04, 0x5a,
+	0x00, 0x6a, 0xce, 0x5e,
+	0x01, 0xa4, 0x96, 0x6b,
+	0xff, 0x38, 0x8c, 0x7b,
 	0x01, 0x38, 0xc8, 0x30,
 	0x00, 0x08, 0x40, 0x19,
 	0xff, 0x6a, 0xc8, 0x08,
 	0x00, 0x09, 0x42, 0x21,
 	0x00, 0x0a, 0x44, 0x21,
 	0xff, 0x6a, 0x70, 0x08,
-	0x00, 0x65, 0x82, 0x43,
+	0x00, 0x65, 0x8e, 0x43,
 	0x03, 0x08, 0x40, 0x31,
 	0x03, 0x08, 0x40, 0x31,
 	0x01, 0x08, 0x40, 0x31,
@@ -463,14 +469,19 @@ static const u_int8_t seqprog[] = {
 	0xfd, 0xb4, 0x68, 0x09,
 	0x12, 0x01, 0x02, 0x00,
 	0x12, 0x01, 0x02, 0x00,
-	0x04, 0x3c, 0xc0, 0x79,
+	0x04, 0x3c, 0xcc, 0x79,
 	0xfb, 0x3c, 0x78, 0x08,
-	0x04, 0x93, 0x30, 0x79,
-	0x01, 0x0c, 0x96, 0x6b,
-	0x00, 0x65, 0x30, 0x41,
-	0x00, 0x65, 0xc0, 0x41,
-	0x80, 0x3c, 0xa0, 0x6b,
-	0x21, 0x6a, 0xc2, 0x46,
+	0x04, 0x93, 0x20, 0x79,
+	0x01, 0x0c, 0xa2, 0x6b,
+	0x01, 0x55, 0x20, 0x79,
+	0x80, 0x04, 0x20, 0x79,
+	0xe4, 0x6a, 0x82, 0x5d,
+	0x23, 0x6a, 0x98, 0x5d,
+	0x01, 0x6a, 0x98, 0x5d,
+	0x00, 0x65, 0x20, 0x41,
+	0x00, 0x65, 0xcc, 0x41,
+	0x80, 0x3c, 0xb6, 0x7b,
+	0x21, 0x6a, 0xec, 0x5e,
 	0x01, 0xbc, 0x18, 0x31,
 	0x02, 0x6a, 0x1a, 0x31,
 	0x02, 0x6a, 0xf8, 0x01,
@@ -480,16 +491,16 @@ static const u_int8_t seqprog[] = {
 	0xff, 0x6a, 0x12, 0x08,
 	0xff, 0x6a, 0x14, 0x08,
 	0xf3, 0xbc, 0xd4, 0x18,
-	0xa0, 0x6a, 0xc6, 0x53,
+	0xa0, 0x6a, 0xdc, 0x53,
 	0x04, 0xa0, 0x10, 0x31,
 	0xac, 0x6a, 0x26, 0x01,
 	0x04, 0xa0, 0x10, 0x31,
 	0x03, 0x08, 0x18, 0x31,
 	0x88, 0x6a, 0xcc, 0x00,
-	0xa0, 0x6a, 0xde, 0x5d,
-	0x00, 0xbc, 0xca, 0x5d,
+	0xa0, 0x6a, 0x08, 0x5e,
+	0x00, 0xbc, 0xf4, 0x5d,
 	0x3d, 0x6a, 0x26, 0x01,
-	0x00, 0x65, 0xde, 0x43,
+	0x00, 0x65, 0xf4, 0x43,
 	0xff, 0x6a, 0x10, 0x09,
 	0xa4, 0x6a, 0x26, 0x01,
 	0x0c, 0xa0, 0x32, 0x31,
@@ -499,118 +510,128 @@ static const u_int8_t seqprog[] = {
 	0x36, 0x6a, 0x26, 0x01,
 	0x02, 0x93, 0x26, 0x01,
 	0x35, 0x6a, 0x26, 0x01,
-	0x00, 0x65, 0x86, 0x5e,
-	0x00, 0x65, 0x86, 0x5e,
+	0x00, 0x65, 0xb0, 0x5e,
+	0x00, 0x65, 0xb0, 0x5e,
 	0x02, 0x93, 0x26, 0x01,
-	0x04, 0x0b, 0xe2, 0x6b,
-	0x10, 0x0c, 0xde, 0x7b,
-	0x01, 0x03, 0xe2, 0x6b,
-	0x20, 0x93, 0xde, 0x6b,
+	0xbf, 0x3c, 0x78, 0x08,
+	0x04, 0x0b, 0xfa, 0x6b,
+	0x10, 0x0c, 0xf6, 0x7b,
+	0x01, 0x03, 0xfa, 0x6b,
+	0x20, 0x93, 0xfc, 0x6b,
+	0x04, 0x0b, 0x02, 0x6c,
+	0x40, 0x3c, 0x78, 0x00,
 	0xc7, 0x93, 0x26, 0x09,
-	0x38, 0x93, 0xe8, 0x6b,
-	0x10, 0x01, 0x02, 0x00,
-	0x00, 0x65, 0xc0, 0x41,
-	0x80, 0x3c, 0xf2, 0x6b,
-	0x21, 0x6a, 0xc2, 0x46,
+	0x38, 0x93, 0x04, 0x6c,
+	0x00, 0x65, 0xcc, 0x41,
+	0x80, 0x3c, 0x6a, 0x6c,
 	0x01, 0x06, 0x50, 0x31,
-	0x00, 0x65, 0xc0, 0x41,
+	0x80, 0xb8, 0x70, 0x01,
+	0x00, 0x65, 0xcc, 0x41,
 	0x10, 0x3f, 0x06, 0x00,
 	0x10, 0x6a, 0x06, 0x00,
 	0x01, 0x3a, 0xca, 0x30,
-	0x80, 0x65, 0x16, 0x64,
-	0x10, 0xb8, 0x3a, 0x6c,
+	0x80, 0x65, 0x30, 0x64,
+	0x10, 0xb8, 0x54, 0x6c,
 	0xc0, 0xba, 0xca, 0x00,
-	0x40, 0xb8, 0x06, 0x6c,
+	0x40, 0xb8, 0x20, 0x6c,
 	0xbf, 0x65, 0xca, 0x08,
-	0x20, 0xb8, 0x1a, 0x7c,
+	0x20, 0xb8, 0x34, 0x7c,
 	0x01, 0x65, 0x0c, 0x30,
-	0x00, 0x65, 0xc2, 0x5d,
-	0xa0, 0x3f, 0x22, 0x64,
+	0x00, 0x65, 0xec, 0x5d,
+	0xa0, 0x3f, 0x3c, 0x64,
 	0x23, 0xb8, 0x0c, 0x08,
-	0x00, 0x65, 0xc2, 0x5d,
-	0xa0, 0x3f, 0x22, 0x64,
-	0x00, 0xbb, 0x1a, 0x44,
-	0xff, 0x65, 0x1a, 0x64,
-	0x00, 0x65, 0x3a, 0x44,
+	0x00, 0x65, 0xec, 0x5d,
+	0xa0, 0x3f, 0x3c, 0x64,
+	0x00, 0xbb, 0x34, 0x44,
+	0xff, 0x65, 0x34, 0x64,
+	0x00, 0x65, 0x54, 0x44,
 	0x40, 0x6a, 0x18, 0x00,
 	0x01, 0x65, 0x0c, 0x30,
-	0x00, 0x65, 0xc2, 0x5d,
-	0xa0, 0x3f, 0xf6, 0x73,
+	0x00, 0x65, 0xec, 0x5d,
+	0xa0, 0x3f, 0x10, 0x74,
 	0x40, 0x6a, 0x18, 0x00,
 	0x01, 0x3a, 0xa6, 0x30,
 	0x08, 0x6a, 0x74, 0x00,
-	0x00, 0x65, 0xc0, 0x41,
-	0x64, 0x6a, 0x52, 0x5d,
-	0x80, 0x64, 0xc2, 0x6c,
-	0x04, 0x64, 0x86, 0x74,
-	0x02, 0x64, 0x96, 0x74,
-	0x00, 0x6a, 0x56, 0x74,
-	0x03, 0x64, 0xb4, 0x74,
-	0x23, 0x64, 0x42, 0x74,
-	0x08, 0x64, 0x52, 0x74,
-	0x61, 0x6a, 0xc2, 0x5e,
-	0x00, 0x65, 0xc2, 0x5d,
-	0x08, 0x51, 0xc2, 0x71,
-	0x00, 0x65, 0x3a, 0x44,
-	0x80, 0x04, 0x50, 0x7c,
-	0x51, 0x6a, 0x48, 0x5d,
-	0x01, 0x51, 0x50, 0x64,
-	0x01, 0xa4, 0x4c, 0x7c,
-	0x01, 0x55, 0x52, 0x7c,
-	0x41, 0x6a, 0xc2, 0x5e,
-	0x00, 0x65, 0x52, 0x44,
-	0x07, 0x6a, 0x3e, 0x5d,
+	0x00, 0x65, 0xcc, 0x41,
+	0x64, 0x6a, 0x7c, 0x5d,
+	0x80, 0x64, 0xec, 0x6c,
+	0x04, 0x64, 0xae, 0x74,
+	0x02, 0x64, 0xbe, 0x74,
+	0x00, 0x6a, 0x74, 0x74,
+	0x03, 0x64, 0xdc, 0x74,
+	0x23, 0x64, 0x5c, 0x74,
+	0x08, 0x64, 0x70, 0x74,
+	0x61, 0x6a, 0xec, 0x5e,
+	0x00, 0x65, 0xec, 0x5d,
+	0x08, 0x51, 0xce, 0x71,
+	0x00, 0x65, 0x54, 0x44,
+	0x80, 0x04, 0x6e, 0x7c,
+	0x51, 0x6a, 0x72, 0x5d,
+	0x01, 0x51, 0x6e, 0x64,
+	0x01, 0xa4, 0x66, 0x7c,
+	0x01, 0x55, 0x70, 0x7c,
+	0x41, 0x6a, 0xec, 0x5e,
+	0x00, 0x65, 0x70, 0x44,
+	0x21, 0x6a, 0xec, 0x5e,
+	0x00, 0x65, 0x70, 0x44,
+	0x07, 0x6a, 0x68, 0x5d,
 	0x01, 0x06, 0xd4, 0x30,
-	0x00, 0x65, 0xc0, 0x41,
-	0x10, 0xb8, 0x5a, 0x7c,
-	0xa1, 0x6a, 0xc2, 0x5e,
-	0x01, 0xb4, 0x60, 0x6c,
-	0x02, 0xb4, 0x62, 0x6c,
-	0x01, 0xa4, 0x62, 0x7c,
-	0xff, 0xa8, 0x72, 0x7c,
+	0x00, 0x65, 0xcc, 0x41,
+	0x80, 0xb8, 0x6a, 0x7c,
+	0xc0, 0x3c, 0x7e, 0x7c,
+	0x80, 0x3c, 0x6a, 0x6c,
+	0xff, 0xa8, 0x7e, 0x6c,
+	0x40, 0x3c, 0x6a, 0x6c,
+	0x10, 0xb8, 0x82, 0x7c,
+	0xa1, 0x6a, 0xec, 0x5e,
+	0x01, 0xb4, 0x88, 0x6c,
+	0x02, 0xb4, 0x8a, 0x6c,
+	0x01, 0xa4, 0x8a, 0x7c,
+	0xff, 0xa8, 0x9a, 0x7c,
 	0x04, 0xb4, 0x68, 0x01,
 	0x01, 0x6a, 0x76, 0x00,
-	0x00, 0xbb, 0xfc, 0x5d,
-	0xff, 0xa8, 0x72, 0x7c,
-	0x71, 0x6a, 0xc2, 0x5e,
-	0x40, 0x51, 0x72, 0x64,
-	0x00, 0x65, 0x9c, 0x5e,
-	0x00, 0x65, 0xd2, 0x41,
-	0x00, 0xbb, 0x76, 0x5c,
-	0x00, 0x65, 0xd2, 0x41,
-	0x00, 0x65, 0x9c, 0x5e,
+	0x00, 0xbb, 0x26, 0x5e,
+	0xff, 0xa8, 0x9a, 0x7c,
+	0x71, 0x6a, 0xec, 0x5e,
+	0x40, 0x51, 0x9a, 0x64,
+	0x00, 0x65, 0xc6, 0x5e,
+	0x00, 0x65, 0xde, 0x41,
+	0x00, 0xbb, 0x9e, 0x5c,
+	0x00, 0x65, 0xde, 0x41,
+	0x00, 0x65, 0xc6, 0x5e,
 	0x01, 0x65, 0xa2, 0x30,
 	0x01, 0xf8, 0xc8, 0x30,
 	0x01, 0x4e, 0xc8, 0x30,
-	0x00, 0x6a, 0xa0, 0xdd,
-	0x00, 0x51, 0xb2, 0x5d,
+	0x00, 0x6a, 0xca, 0xdd,
+	0x00, 0x51, 0xdc, 0x5d,
 	0x01, 0x4e, 0x9c, 0x18,
 	0x02, 0x6a, 0x22, 0x05,
-	0x10, 0x03, 0x52, 0x6c,
+	0xc0, 0x3c, 0x6a, 0x6c,
 	0x04, 0xb8, 0x70, 0x01,
-	0x00, 0x65, 0xbe, 0x5e,
-	0x20, 0xb8, 0xd2, 0x69,
+	0x00, 0x65, 0xe8, 0x5e,
+	0x20, 0xb8, 0xde, 0x69,
 	0x01, 0xbb, 0xa2, 0x30,
 	0x01, 0xba, 0x7c, 0x30,
-	0x00, 0xb9, 0xb8, 0x5c,
-	0x00, 0x65, 0xd2, 0x41,
+	0x00, 0xb9, 0xe2, 0x5c,
+	0x00, 0x65, 0xde, 0x41,
 	0x01, 0x06, 0xd4, 0x30,
-	0x20, 0x3c, 0xc0, 0x79,
-	0x20, 0x3c, 0x52, 0x7c,
-	0x01, 0xa4, 0xa4, 0x7c,
+	0x20, 0x3c, 0xcc, 0x79,
+	0x20, 0x3c, 0x70, 0x7c,
+	0x01, 0xa4, 0xcc, 0x7c,
 	0x01, 0xb4, 0x68, 0x01,
-	0x00, 0x65, 0xc0, 0x41,
-	0x00, 0x65, 0x52, 0x44,
+	0x00, 0x65, 0xcc, 0x41,
+	0x00, 0x65, 0x70, 0x44,
 	0x04, 0x14, 0x58, 0x31,
 	0x01, 0x06, 0xd4, 0x30,
 	0x08, 0xa0, 0x60, 0x31,
 	0xac, 0x6a, 0xcc, 0x00,
-	0x14, 0x6a, 0xde, 0x5d,
+	0x14, 0x6a, 0x08, 0x5e,
 	0x01, 0x06, 0xd4, 0x30,
-	0xa0, 0x6a, 0xd6, 0x5d,
-	0x00, 0x65, 0xc0, 0x41,
+	0xa0, 0x6a, 0x00, 0x5e,
+	0x00, 0x65, 0xcc, 0x41,
 	0xdf, 0x3c, 0x78, 0x08,
-	0x00, 0x65, 0x52, 0x44,
+	0x12, 0x01, 0x02, 0x00,
+	0x00, 0x65, 0x70, 0x44,
 	0x4c, 0x65, 0xcc, 0x28,
 	0x01, 0x3e, 0x20, 0x31,
 	0xd0, 0x66, 0xcc, 0x18,
@@ -621,102 +642,102 @@ static const u_int8_t seqprog[] = {
 	0xd0, 0x65, 0xca, 0x18,
 	0x01, 0x3e, 0x20, 0x31,
 	0x30, 0x65, 0xd4, 0x18,
-	0x00, 0x65, 0xd0, 0x4c,
+	0x00, 0x65, 0xfa, 0x4c,
 	0xe1, 0x6a, 0x22, 0x01,
 	0xff, 0x6a, 0xd4, 0x08,
 	0x20, 0x65, 0xd4, 0x18,
-	0x00, 0x65, 0xd8, 0x54,
+	0x00, 0x65, 0x02, 0x55,
 	0xe1, 0x6a, 0x22, 0x01,
 	0xff, 0x6a, 0xd4, 0x08,
 	0x20, 0x65, 0xca, 0x18,
 	0xe0, 0x65, 0xd4, 0x18,
-	0x00, 0x65, 0xe2, 0x4c,
+	0x00, 0x65, 0x0c, 0x4d,
 	0xe1, 0x6a, 0x22, 0x01,
 	0xff, 0x6a, 0xd4, 0x08,
 	0xd0, 0x65, 0xd4, 0x18,
-	0x00, 0x65, 0xea, 0x54,
+	0x00, 0x65, 0x14, 0x55,
 	0xe1, 0x6a, 0x22, 0x01,
 	0xff, 0x6a, 0xd4, 0x08,
 	0x01, 0x6c, 0xa2, 0x30,
-	0xff, 0x51, 0xfc, 0x74,
-	0x00, 0x51, 0x78, 0x5d,
+	0xff, 0x51, 0x26, 0x75,
+	0x00, 0x51, 0xa2, 0x5d,
 	0x01, 0x51, 0x20, 0x31,
-	0x00, 0x65, 0x1e, 0x45,
+	0x00, 0x65, 0x48, 0x45,
 	0x01, 0xba, 0xc8, 0x30,
-	0x00, 0x3e, 0x1e, 0x75,
-	0x00, 0x65, 0x9a, 0x5e,
+	0x00, 0x3e, 0x48, 0x75,
+	0x00, 0x65, 0xc4, 0x5e,
 	0x80, 0x3c, 0x78, 0x00,
 	0x01, 0x06, 0xd4, 0x30,
-	0x00, 0x65, 0xc2, 0x5d,
+	0x00, 0x65, 0xec, 0x5d,
 	0x01, 0x3c, 0x78, 0x00,
-	0xe0, 0x3f, 0x3a, 0x65,
+	0xe0, 0x3f, 0x64, 0x65,
 	0x02, 0x3c, 0x78, 0x00,
-	0x20, 0x12, 0x3a, 0x65,
-	0x51, 0x6a, 0x48, 0x5d,
-	0x00, 0x51, 0x78, 0x5d,
-	0x51, 0x6a, 0x48, 0x5d,
+	0x20, 0x12, 0x64, 0x65,
+	0x51, 0x6a, 0x72, 0x5d,
+	0x00, 0x51, 0xa2, 0x5d,
+	0x51, 0x6a, 0x72, 0x5d,
 	0x01, 0x51, 0x20, 0x31,
 	0x04, 0x3c, 0x78, 0x00,
 	0x01, 0xb9, 0xc8, 0x30,
-	0x00, 0x3d, 0x38, 0x65,
+	0x00, 0x3d, 0x62, 0x65,
 	0x08, 0x3c, 0x78, 0x00,
 	0x01, 0xba, 0xc8, 0x30,
-	0x00, 0x3e, 0x38, 0x65,
+	0x00, 0x3e, 0x62, 0x65,
 	0x10, 0x3c, 0x78, 0x00,
-	0x04, 0xb8, 0x38, 0x7d,
+	0x04, 0xb8, 0x62, 0x7d,
 	0xfb, 0xb8, 0x70, 0x09,
-	0x20, 0xb8, 0x2e, 0x6d,
+	0x20, 0xb8, 0x58, 0x6d,
 	0x01, 0x90, 0xc8, 0x30,
 	0xff, 0x6a, 0xa2, 0x00,
-	0x00, 0x3d, 0xb8, 0x5c,
+	0x00, 0x3d, 0xe2, 0x5c,
 	0x01, 0x64, 0x20, 0x31,
-	0x80, 0x6a, 0x78, 0x00,
-	0x00, 0x65, 0xfe, 0x58,
-	0x10, 0xb8, 0x52, 0x7c,
-	0xff, 0x6a, 0x3e, 0x5d,
-	0x00, 0x65, 0x52, 0x44,
-	0x00, 0x65, 0x9a, 0x5e,
-	0x31, 0x6a, 0xc2, 0x5e,
-	0x00, 0x65, 0x52, 0x44,
+	0xff, 0x6a, 0x78, 0x08,
+	0x00, 0x65, 0xea, 0x58,
+	0x10, 0xb8, 0x70, 0x7c,
+	0xff, 0x6a, 0x68, 0x5d,
+	0x00, 0x65, 0x70, 0x44,
+	0x00, 0x65, 0xc4, 0x5e,
+	0x31, 0x6a, 0xec, 0x5e,
+	0x00, 0x65, 0x70, 0x44,
 	0x10, 0x3f, 0x06, 0x00,
 	0x10, 0x6a, 0x06, 0x00,
 	0x01, 0x65, 0x74, 0x34,
-	0x81, 0x6a, 0xc2, 0x5e,
-	0x00, 0x65, 0x4a, 0x45,
+	0x81, 0x6a, 0xec, 0x5e,
+	0x00, 0x65, 0x74, 0x45,
 	0x01, 0x06, 0xd4, 0x30,
-	0x01, 0x0c, 0x4a, 0x7d,
-	0x04, 0x0c, 0x44, 0x6d,
+	0x01, 0x0c, 0x74, 0x7d,
+	0x04, 0x0c, 0x6e, 0x6d,
 	0xe0, 0x03, 0x7e, 0x08,
-	0xe0, 0x3f, 0xc0, 0x61,
+	0xe0, 0x3f, 0xcc, 0x61,
 	0x01, 0x65, 0xcc, 0x30,
 	0x01, 0x12, 0xda, 0x34,
 	0x01, 0x06, 0xd4, 0x34,
-	0x01, 0x03, 0x58, 0x6d,
+	0x01, 0x03, 0x82, 0x6d,
 	0x40, 0x03, 0xcc, 0x08,
 	0x01, 0x65, 0x06, 0x30,
 	0x40, 0x65, 0xc8, 0x08,
-	0x00, 0x66, 0x66, 0x75,
-	0x40, 0x65, 0x66, 0x7d,
-	0x00, 0x65, 0x66, 0x5d,
+	0x00, 0x66, 0x90, 0x75,
+	0x40, 0x65, 0x90, 0x7d,
+	0x00, 0x65, 0x90, 0x5d,
 	0xff, 0x6a, 0xd4, 0x08,
 	0xff, 0x6a, 0xd4, 0x08,
 	0xff, 0x6a, 0xd4, 0x08,
 	0xff, 0x6a, 0xd4, 0x0c,
 	0x08, 0x01, 0x02, 0x00,
-	0x02, 0x0b, 0x70, 0x7d,
+	0x02, 0x0b, 0x9a, 0x7d,
 	0x01, 0x65, 0x0c, 0x30,
-	0x02, 0x0b, 0x74, 0x7d,
+	0x02, 0x0b, 0x9e, 0x7d,
 	0xf7, 0x01, 0x02, 0x0c,
 	0x01, 0x65, 0xc8, 0x30,
-	0xff, 0x41, 0x98, 0x75,
+	0xff, 0x41, 0xc2, 0x75,
 	0x01, 0x41, 0x20, 0x31,
 	0xff, 0x6a, 0xa4, 0x00,
-	0x00, 0x65, 0x88, 0x45,
-	0xff, 0xbf, 0x98, 0x75,
+	0x00, 0x65, 0xb2, 0x45,
+	0xff, 0xbf, 0xc2, 0x75,
 	0x01, 0x90, 0xa4, 0x30,
 	0x01, 0xbf, 0x20, 0x31,
-	0x00, 0xbb, 0x82, 0x65,
-	0xff, 0x52, 0x96, 0x75,
+	0x00, 0xbb, 0xac, 0x65,
+	0xff, 0x52, 0xc0, 0x75,
 	0x01, 0xbf, 0xcc, 0x30,
 	0x01, 0x90, 0xca, 0x30,
 	0x01, 0x52, 0x20, 0x31,
@@ -724,28 +745,28 @@ static const u_int8_t seqprog[] = {
 	0x01, 0x65, 0x20, 0x35,
 	0x01, 0xbf, 0x82, 0x34,
 	0x01, 0x64, 0xa2, 0x30,
-	0x00, 0x6a, 0xaa, 0x5e,
+	0x00, 0x6a, 0xd4, 0x5e,
 	0x0d, 0x6a, 0x76, 0x00,
-	0x00, 0x51, 0xfc, 0x45,
+	0x00, 0x51, 0x26, 0x46,
 	0x01, 0x65, 0xa4, 0x30,
 	0xe0, 0x6a, 0xcc, 0x00,
-	0x48, 0x6a, 0xf0, 0x5d,
+	0x48, 0x6a, 0x1a, 0x5e,
 	0x01, 0x6a, 0xd0, 0x01,
 	0x01, 0x6a, 0xdc, 0x05,
 	0x88, 0x6a, 0xcc, 0x00,
-	0x48, 0x6a, 0xf0, 0x5d,
-	0x01, 0x6a, 0xca, 0x5d,
+	0x48, 0x6a, 0x1a, 0x5e,
+	0x01, 0x6a, 0xf4, 0x5d,
 	0x01, 0x6a, 0x26, 0x05,
 	0x01, 0x65, 0xd8, 0x31,
 	0x09, 0xee, 0xdc, 0x01,
-	0x80, 0xee, 0xb6, 0x7d,
+	0x80, 0xee, 0xe0, 0x7d,
 	0xff, 0x6a, 0xdc, 0x0d,
 	0x01, 0x65, 0x32, 0x31,
 	0x0a, 0x93, 0x26, 0x01,
-	0x00, 0x65, 0x92, 0x46,
-	0x81, 0x6a, 0xc2, 0x5e,
-	0x01, 0x0c, 0xc2, 0x7d,
-	0x04, 0x0c, 0xc0, 0x6d,
+	0x00, 0x65, 0xbc, 0x46,
+	0x81, 0x6a, 0xec, 0x5e,
+	0x01, 0x0c, 0xec, 0x7d,
+	0x04, 0x0c, 0xea, 0x6d,
 	0xe0, 0x03, 0x06, 0x08,
 	0xe0, 0x03, 0x7e, 0x0c,
 	0x01, 0x65, 0x18, 0x31,
@@ -764,7 +785,7 @@ static const u_int8_t seqprog[] = {
 	0x01, 0x6c, 0xda, 0x34,
 	0x3d, 0x64, 0xa4, 0x28,
 	0x55, 0x64, 0xc8, 0x28,
-	0x00, 0x65, 0xf0, 0x45,
+	0x00, 0x65, 0x1a, 0x46,
 	0x2e, 0x64, 0xa4, 0x28,
 	0x66, 0x64, 0xc8, 0x28,
 	0x00, 0x6c, 0xda, 0x18,
@@ -775,63 +796,63 @@ static const u_int8_t seqprog[] = {
 	0x00, 0x6c, 0xda, 0x24,
 	0x01, 0x65, 0xc8, 0x30,
 	0xe0, 0x6a, 0xcc, 0x00,
-	0x44, 0x6a, 0xec, 0x5d,
+	0x44, 0x6a, 0x16, 0x5e,
 	0x01, 0x90, 0xe2, 0x31,
-	0x04, 0x3b, 0x10, 0x7e,
+	0x04, 0x3b, 0x3a, 0x7e,
 	0x30, 0x6a, 0xd0, 0x01,
 	0x20, 0x6a, 0xd0, 0x01,
 	0x1d, 0x6a, 0xdc, 0x01,
-	0xdc, 0xee, 0x0c, 0x66,
-	0x00, 0x65, 0x28, 0x46,
+	0xdc, 0xee, 0x36, 0x66,
+	0x00, 0x65, 0x52, 0x46,
 	0x20, 0x6a, 0xd0, 0x01,
 	0x01, 0x6a, 0xdc, 0x01,
 	0x20, 0xa0, 0xd8, 0x31,
 	0x09, 0xee, 0xdc, 0x01,
-	0x80, 0xee, 0x18, 0x7e,
+	0x80, 0xee, 0x42, 0x7e,
 	0x11, 0x6a, 0xdc, 0x01,
-	0x50, 0xee, 0x1c, 0x66,
+	0x50, 0xee, 0x46, 0x66,
 	0x20, 0x6a, 0xd0, 0x01,
 	0x09, 0x6a, 0xdc, 0x01,
-	0x88, 0xee, 0x22, 0x66,
+	0x88, 0xee, 0x4c, 0x66,
 	0x19, 0x6a, 0xdc, 0x01,
-	0xd8, 0xee, 0x26, 0x66,
+	0xd8, 0xee, 0x50, 0x66,
 	0xff, 0x6a, 0xdc, 0x09,
-	0x18, 0xee, 0x2a, 0x6e,
+	0x18, 0xee, 0x54, 0x6e,
 	0xff, 0x6a, 0xd4, 0x0c,
 	0x88, 0x6a, 0xcc, 0x00,
-	0x44, 0x6a, 0xec, 0x5d,
-	0x20, 0x6a, 0xca, 0x5d,
+	0x44, 0x6a, 0x16, 0x5e,
+	0x20, 0x6a, 0xf4, 0x5d,
 	0x01, 0x3b, 0x26, 0x31,
-	0x04, 0x3b, 0x44, 0x6e,
+	0x04, 0x3b, 0x6e, 0x6e,
 	0xa0, 0x6a, 0xca, 0x00,
 	0x20, 0x65, 0xc8, 0x18,
-	0x00, 0x65, 0x82, 0x5e,
-	0x00, 0x65, 0x3c, 0x66,
+	0x00, 0x65, 0xac, 0x5e,
+	0x00, 0x65, 0x66, 0x66,
 	0x0a, 0x93, 0x26, 0x01,
-	0x00, 0x65, 0x92, 0x46,
+	0x00, 0x65, 0xbc, 0x46,
 	0xa0, 0x6a, 0xcc, 0x00,
 	0xff, 0x6a, 0xc8, 0x08,
-	0x20, 0x94, 0x48, 0x6e,
-	0x10, 0x94, 0x4a, 0x6e,
-	0x08, 0x94, 0x64, 0x6e,
-	0x08, 0x94, 0x64, 0x6e,
-	0x08, 0x94, 0x64, 0x6e,
+	0x20, 0x94, 0x72, 0x6e,
+	0x10, 0x94, 0x74, 0x6e,
+	0x08, 0x94, 0x8e, 0x6e,
+	0x08, 0x94, 0x8e, 0x6e,
+	0x08, 0x94, 0x8e, 0x6e,
 	0xff, 0x8c, 0xc8, 0x10,
 	0xc1, 0x64, 0xc8, 0x18,
 	0xf8, 0x64, 0xc8, 0x08,
 	0x01, 0x99, 0xda, 0x30,
-	0x00, 0x66, 0x58, 0x66,
-	0xc0, 0x66, 0x94, 0x76,
+	0x00, 0x66, 0x82, 0x66,
+	0xc0, 0x66, 0xbe, 0x76,
 	0x60, 0x66, 0xc8, 0x18,
 	0x3d, 0x64, 0xc8, 0x28,
-	0x00, 0x65, 0x48, 0x46,
+	0x00, 0x65, 0x72, 0x46,
 	0xf7, 0x93, 0x26, 0x09,
-	0x08, 0x93, 0x66, 0x6e,
+	0x08, 0x93, 0x90, 0x6e,
 	0x00, 0x62, 0xc4, 0x18,
-	0x00, 0x65, 0x92, 0x5e,
-	0x00, 0x65, 0x72, 0x5e,
-	0x00, 0x65, 0x72, 0x5e,
-	0x00, 0x65, 0x72, 0x5e,
+	0x00, 0x65, 0xbc, 0x5e,
+	0x00, 0x65, 0x9c, 0x5e,
+	0x00, 0x65, 0x9c, 0x5e,
+	0x00, 0x65, 0x9c, 0x5e,
 	0x01, 0x99, 0xda, 0x30,
 	0x01, 0x99, 0xda, 0x30,
 	0x01, 0x99, 0xda, 0x30,
@@ -848,11 +869,11 @@ static const u_int8_t seqprog[] = {
 	0x01, 0x6c, 0x32, 0x31,
 	0x01, 0x6c, 0x32, 0x31,
 	0x01, 0x6c, 0x32, 0x35,
-	0x08, 0x94, 0x92, 0x7e,
+	0x08, 0x94, 0xbc, 0x7e,
 	0xf7, 0x93, 0x26, 0x09,
-	0x08, 0x93, 0x96, 0x6e,
+	0x08, 0x93, 0xc0, 0x6e,
 	0xff, 0x6a, 0xd4, 0x0c,
-	0x04, 0xb8, 0xbe, 0x6e,
+	0x04, 0xb8, 0xe8, 0x6e,
 	0x01, 0x42, 0x7e, 0x31,
 	0xff, 0x6a, 0x76, 0x01,
 	0x01, 0x90, 0x84, 0x34,
@@ -860,14 +881,14 @@ static const u_int8_t seqprog[] = {
 	0x01, 0x85, 0x0a, 0x01,
 	0x7f, 0x65, 0x10, 0x09,
 	0xfe, 0x85, 0x0a, 0x0d,
-	0xff, 0x42, 0xba, 0x66,
-	0xff, 0x41, 0xb2, 0x66,
-	0xd1, 0x6a, 0xc2, 0x5e,
+	0xff, 0x42, 0xe4, 0x66,
+	0xff, 0x41, 0xdc, 0x66,
+	0xd1, 0x6a, 0xec, 0x5e,
 	0xff, 0x6a, 0xca, 0x04,
 	0x01, 0x41, 0x20, 0x31,
 	0x01, 0xbf, 0x82, 0x30,
 	0x01, 0x6a, 0x76, 0x00,
-	0x00, 0xbb, 0xfc, 0x45,
+	0x00, 0xbb, 0x26, 0x46,
 	0x01, 0x42, 0x20, 0x31,
 	0x01, 0xbf, 0x84, 0x34,
 	0x01, 0x41, 0x7e, 0x31,
@@ -877,421 +898,420 @@ static const u_int8_t seqprog[] = {
 	0xff, 0x6a, 0xd4, 0x0c
 };
 
-static int aic_patch23_func(struct ahc_softc *ahc);
+typedef int ahc_patch_func_t (struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch23_func;
 
 static int
-aic_patch23_func(struct ahc_softc *ahc)
+ahc_patch23_func(struct ahc_softc *ahc)
 {
 	return ((ahc->bugs & AHC_SCBCHAN_UPLOAD_BUG) != 0);
 }
 
-static int aic_patch22_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch22_func;
 
 static int
-aic_patch22_func(struct ahc_softc *ahc)
+ahc_patch22_func(struct ahc_softc *ahc)
 {
 	return ((ahc->features & AHC_CMD_CHAN) == 0);
 }
 
-static int aic_patch21_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch21_func;
 
 static int
-aic_patch21_func(struct ahc_softc *ahc)
+ahc_patch21_func(struct ahc_softc *ahc)
 {
 	return ((ahc->features & AHC_QUEUE_REGS) == 0);
 }
 
-static int aic_patch20_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch20_func;
 
 static int
-aic_patch20_func(struct ahc_softc *ahc)
+ahc_patch20_func(struct ahc_softc *ahc)
 {
 	return ((ahc->features & AHC_WIDE) != 0);
 }
 
-static int aic_patch19_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch19_func;
 
 static int
-aic_patch19_func(struct ahc_softc *ahc)
+ahc_patch19_func(struct ahc_softc *ahc)
 {
 	return ((ahc->flags & AHC_SCB_BTT) != 0);
 }
 
-static int aic_patch18_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch18_func;
 
 static int
-aic_patch18_func(struct ahc_softc *ahc)
+ahc_patch18_func(struct ahc_softc *ahc)
 {
 	return ((ahc->bugs & AHC_PCI_2_1_RETRY_BUG) != 0);
 }
 
-static int aic_patch17_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch17_func;
 
 static int
-aic_patch17_func(struct ahc_softc *ahc)
+ahc_patch17_func(struct ahc_softc *ahc)
 {
 	return ((ahc->flags & AHC_TMODE_WIDEODD_BUG) != 0);
 }
 
-static int aic_patch16_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch16_func;
 
 static int
-aic_patch16_func(struct ahc_softc *ahc)
+ahc_patch16_func(struct ahc_softc *ahc)
 {
 	return ((ahc->bugs & AHC_AUTOFLUSH_BUG) != 0);
 }
 
-static int aic_patch15_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch15_func;
 
 static int
-aic_patch15_func(struct ahc_softc *ahc)
+ahc_patch15_func(struct ahc_softc *ahc)
 {
 	return ((ahc->features & AHC_ULTRA2) == 0);
 }
 
-static int aic_patch14_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch14_func;
 
 static int
-aic_patch14_func(struct ahc_softc *ahc)
+ahc_patch14_func(struct ahc_softc *ahc)
 {
 	return ((ahc->bugs & AHC_PCI_MWI_BUG) != 0 && ahc->pci_cachesize != 0);
 }
 
-static int aic_patch13_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch13_func;
 
 static int
-aic_patch13_func(struct ahc_softc *ahc)
+ahc_patch13_func(struct ahc_softc *ahc)
 {
 	return ((ahc->flags & AHC_39BIT_ADDRESSING) != 0);
 }
 
-static int aic_patch12_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch12_func;
 
 static int
-aic_patch12_func(struct ahc_softc *ahc)
+ahc_patch12_func(struct ahc_softc *ahc)
 {
-	return ((ahc->features & AHC_ULTRA) != 0);
+	return ((ahc->features & AHC_HS_MAILBOX) != 0);
 }
 
-static int aic_patch11_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch11_func;
 
 static int
-aic_patch11_func(struct ahc_softc *ahc)
+ahc_patch11_func(struct ahc_softc *ahc)
 {
-	return ((ahc->features & AHC_HS_MAILBOX) != 0);
+	return ((ahc->features & AHC_ULTRA) != 0);
 }
 
-static int aic_patch10_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch10_func;
 
 static int
-aic_patch10_func(struct ahc_softc *ahc)
+ahc_patch10_func(struct ahc_softc *ahc)
 {
 	return ((ahc->features & AHC_MULTI_TID) != 0);
 }
 
-static int aic_patch9_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch9_func;
 
 static int
-aic_patch9_func(struct ahc_softc *ahc)
+ahc_patch9_func(struct ahc_softc *ahc)
 {
 	return ((ahc->features & AHC_CMD_CHAN) != 0);
 }
 
-static int aic_patch8_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch8_func;
 
 static int
-aic_patch8_func(struct ahc_softc *ahc)
+ahc_patch8_func(struct ahc_softc *ahc)
 {
 	return ((ahc->flags & AHC_INITIATORROLE) != 0);
 }
 
-static int aic_patch7_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch7_func;
 
 static int
-aic_patch7_func(struct ahc_softc *ahc)
+ahc_patch7_func(struct ahc_softc *ahc)
 {
 	return ((ahc->flags & AHC_TARGETROLE) != 0);
 }
 
-static int aic_patch6_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch6_func;
 
 static int
-aic_patch6_func(struct ahc_softc *ahc)
+ahc_patch6_func(struct ahc_softc *ahc)
 {
 	return ((ahc->features & AHC_DT) == 0);
 }
 
-static int aic_patch5_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch5_func;
 
 static int
-aic_patch5_func(struct ahc_softc *ahc)
+ahc_patch5_func(struct ahc_softc *ahc)
 {
 	return ((ahc->flags & AHC_SEQUENCER_DEBUG) != 0);
 }
 
-static int aic_patch4_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch4_func;
 
 static int
-aic_patch4_func(struct ahc_softc *ahc)
+ahc_patch4_func(struct ahc_softc *ahc)
 {
 	return ((ahc->flags & AHC_PAGESCBS) != 0);
 }
 
-static int aic_patch3_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch3_func;
 
 static int
-aic_patch3_func(struct ahc_softc *ahc)
+ahc_patch3_func(struct ahc_softc *ahc)
 {
 	return ((ahc->features & AHC_QUEUE_REGS) != 0);
 }
 
-static int aic_patch2_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch2_func;
 
 static int
-aic_patch2_func(struct ahc_softc *ahc)
+ahc_patch2_func(struct ahc_softc *ahc)
 {
 	return ((ahc->features & AHC_TWIN) != 0);
 }
 
-static int aic_patch1_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch1_func;
 
 static int
-aic_patch1_func(struct ahc_softc *ahc)
+ahc_patch1_func(struct ahc_softc *ahc)
 {
 	return ((ahc->features & AHC_ULTRA2) != 0);
 }
 
-static int aic_patch0_func(struct ahc_softc *ahc);
+static ahc_patch_func_t ahc_patch0_func;
 
 static int
-aic_patch0_func(struct ahc_softc *ahc)
+ahc_patch0_func(struct ahc_softc *ahc)
 {
 	return (0);
 }
 
-typedef int patch_func_t (struct ahc_softc *ahc);
 static struct patch {
-	patch_func_t	*patch_func;
-	uint32_t	begin	   :10,
-			skip_instr :10,
-			skip_patch :12;
-} const patches[] = {
-	{ aic_patch1_func, 4, 1, 1 },
-	{ aic_patch2_func, 6, 2, 1 },
-	{ aic_patch2_func, 9, 1, 1 },
-	{ aic_patch3_func, 11, 1, 2 },
-	{ aic_patch0_func, 12, 2, 1 },
-	{ aic_patch4_func, 15, 1, 2 },
-	{ aic_patch0_func, 16, 1, 1 },
-	{ aic_patch5_func, 22, 2, 1 },
-	{ aic_patch3_func, 27, 1, 2 },
-	{ aic_patch0_func, 28, 1, 1 },
-	{ aic_patch6_func, 34, 1, 1 },
-	{ aic_patch7_func, 37, 62, 21 },
-	{ aic_patch8_func, 37, 1, 1 },
-	{ aic_patch9_func, 42, 3, 2 },
-	{ aic_patch0_func, 45, 3, 1 },
-	{ aic_patch10_func, 49, 1, 2 },
-	{ aic_patch0_func, 50, 2, 3 },
-	{ aic_patch1_func, 50, 1, 2 },
-	{ aic_patch0_func, 51, 1, 1 },
-	{ aic_patch2_func, 53, 2, 1 },
-	{ aic_patch9_func, 55, 1, 2 },
-	{ aic_patch0_func, 56, 1, 1 },
-	{ aic_patch9_func, 60, 1, 2 },
-	{ aic_patch0_func, 61, 1, 1 },
-	{ aic_patch9_func, 70, 1, 2 },
-	{ aic_patch0_func, 71, 1, 1 },
-	{ aic_patch9_func, 74, 1, 2 },
-	{ aic_patch0_func, 75, 1, 1 },
-	{ aic_patch11_func, 85, 1, 2 },
-	{ aic_patch0_func, 86, 1, 1 },
-	{ aic_patch9_func, 94, 1, 2 },
-	{ aic_patch0_func, 95, 1, 1 },
-	{ aic_patch8_func, 99, 10, 4 },
-	{ aic_patch1_func, 102, 1, 2 },
-	{ aic_patch0_func, 103, 1, 1 },
-	{ aic_patch2_func, 105, 2, 1 },
-	{ aic_patch2_func, 114, 4, 1 },
-	{ aic_patch1_func, 118, 1, 2 },
-	{ aic_patch0_func, 119, 2, 3 },
-	{ aic_patch2_func, 119, 1, 2 },
-	{ aic_patch0_func, 120, 1, 1 },
-	{ aic_patch7_func, 121, 4, 2 },
-	{ aic_patch0_func, 125, 1, 1 },
-	{ aic_patch12_func, 127, 2, 1 },
-	{ aic_patch1_func, 129, 1, 2 },
-	{ aic_patch0_func, 130, 1, 1 },
-	{ aic_patch7_func, 131, 4, 1 },
-	{ aic_patch7_func, 142, 80, 9 },
-	{ aic_patch4_func, 160, 1, 1 },
-	{ aic_patch1_func, 173, 1, 1 },
-	{ aic_patch9_func, 181, 1, 2 },
-	{ aic_patch0_func, 182, 1, 1 },
-	{ aic_patch9_func, 191, 1, 2 },
-	{ aic_patch0_func, 192, 1, 1 },
-	{ aic_patch9_func, 208, 6, 2 },
-	{ aic_patch0_func, 214, 6, 1 },
-	{ aic_patch8_func, 222, 18, 2 },
-	{ aic_patch1_func, 235, 1, 1 },
-	{ aic_patch1_func, 242, 1, 2 },
-	{ aic_patch0_func, 243, 2, 2 },
-	{ aic_patch12_func, 244, 1, 1 },
-	{ aic_patch9_func, 252, 31, 3 },
-	{ aic_patch1_func, 268, 14, 2 },
-	{ aic_patch13_func, 273, 1, 1 },
-	{ aic_patch14_func, 283, 14, 1 },
-	{ aic_patch1_func, 299, 1, 2 },
-	{ aic_patch0_func, 300, 1, 1 },
-	{ aic_patch9_func, 303, 1, 1 },
-	{ aic_patch13_func, 308, 1, 1 },
-	{ aic_patch9_func, 309, 2, 2 },
-	{ aic_patch0_func, 311, 4, 1 },
-	{ aic_patch14_func, 315, 1, 1 },
-	{ aic_patch15_func, 318, 2, 3 },
-	{ aic_patch9_func, 318, 1, 2 },
-	{ aic_patch0_func, 319, 1, 1 },
-	{ aic_patch6_func, 324, 1, 2 },
-	{ aic_patch0_func, 325, 1, 1 },
-	{ aic_patch1_func, 329, 50, 11 },
-	{ aic_patch6_func, 338, 2, 4 },
-	{ aic_patch7_func, 338, 1, 1 },
-	{ aic_patch8_func, 339, 1, 1 },
-	{ aic_patch0_func, 340, 1, 1 },
-	{ aic_patch16_func, 341, 1, 1 },
-	{ aic_patch6_func, 360, 6, 3 },
-	{ aic_patch16_func, 360, 5, 1 },
-	{ aic_patch0_func, 366, 5, 1 },
-	{ aic_patch13_func, 374, 5, 1 },
-	{ aic_patch0_func, 379, 54, 17 },
-	{ aic_patch14_func, 379, 1, 1 },
-	{ aic_patch7_func, 381, 2, 2 },
-	{ aic_patch17_func, 382, 1, 1 },
-	{ aic_patch9_func, 385, 1, 1 },
-	{ aic_patch18_func, 392, 1, 1 },
-	{ aic_patch14_func, 397, 9, 3 },
-	{ aic_patch9_func, 398, 3, 2 },
-	{ aic_patch0_func, 401, 3, 1 },
-	{ aic_patch9_func, 409, 6, 2 },
-	{ aic_patch0_func, 415, 9, 2 },
-	{ aic_patch13_func, 415, 1, 1 },
-	{ aic_patch13_func, 424, 2, 1 },
-	{ aic_patch14_func, 426, 1, 1 },
-	{ aic_patch9_func, 428, 1, 2 },
-	{ aic_patch0_func, 429, 1, 1 },
-	{ aic_patch7_func, 432, 1, 1 },
-	{ aic_patch7_func, 433, 1, 1 },
-	{ aic_patch8_func, 434, 3, 3 },
-	{ aic_patch6_func, 435, 1, 2 },
-	{ aic_patch0_func, 436, 1, 1 },
-	{ aic_patch9_func, 437, 1, 1 },
-	{ aic_patch15_func, 438, 1, 2 },
-	{ aic_patch13_func, 438, 1, 1 },
-	{ aic_patch14_func, 440, 9, 4 },
-	{ aic_patch9_func, 440, 1, 1 },
-	{ aic_patch9_func, 447, 2, 1 },
-	{ aic_patch0_func, 449, 4, 3 },
-	{ aic_patch9_func, 449, 1, 2 },
-	{ aic_patch0_func, 450, 3, 1 },
-	{ aic_patch1_func, 454, 2, 1 },
-	{ aic_patch7_func, 456, 5, 2 },
-	{ aic_patch0_func, 461, 1, 1 },
-	{ aic_patch8_func, 462, 109, 23 },
-	{ aic_patch1_func, 464, 3, 2 },
-	{ aic_patch0_func, 467, 5, 3 },
-	{ aic_patch9_func, 467, 2, 2 },
-	{ aic_patch0_func, 469, 3, 1 },
-	{ aic_patch1_func, 474, 2, 2 },
-	{ aic_patch0_func, 476, 6, 3 },
-	{ aic_patch9_func, 476, 2, 2 },
-	{ aic_patch0_func, 478, 3, 1 },
-	{ aic_patch1_func, 484, 2, 2 },
-	{ aic_patch0_func, 486, 9, 7 },
-	{ aic_patch9_func, 486, 5, 6 },
-	{ aic_patch19_func, 486, 1, 2 },
-	{ aic_patch0_func, 487, 1, 1 },
-	{ aic_patch19_func, 489, 1, 2 },
-	{ aic_patch0_func, 490, 1, 1 },
-	{ aic_patch0_func, 491, 4, 1 },
-	{ aic_patch6_func, 495, 3, 2 },
-	{ aic_patch0_func, 498, 1, 1 },
-	{ aic_patch1_func, 501, 1, 1 },
-	{ aic_patch6_func, 507, 1, 2 },
-	{ aic_patch0_func, 508, 1, 1 },
-	{ aic_patch20_func, 545, 7, 1 },
-	{ aic_patch3_func, 573, 1, 2 },
-	{ aic_patch0_func, 574, 1, 1 },
-	{ aic_patch21_func, 577, 1, 1 },
-	{ aic_patch8_func, 579, 105, 33 },
-	{ aic_patch4_func, 581, 1, 1 },
-	{ aic_patch1_func, 587, 2, 2 },
-	{ aic_patch0_func, 589, 1, 1 },
-	{ aic_patch1_func, 592, 1, 2 },
-	{ aic_patch0_func, 593, 1, 1 },
-	{ aic_patch9_func, 594, 3, 3 },
-	{ aic_patch15_func, 595, 1, 1 },
-	{ aic_patch0_func, 597, 4, 1 },
-	{ aic_patch19_func, 605, 2, 2 },
-	{ aic_patch0_func, 607, 1, 1 },
-	{ aic_patch19_func, 611, 10, 3 },
-	{ aic_patch5_func, 613, 8, 1 },
-	{ aic_patch0_func, 621, 9, 2 },
-	{ aic_patch5_func, 622, 8, 1 },
-	{ aic_patch4_func, 632, 1, 2 },
-	{ aic_patch0_func, 633, 1, 1 },
-	{ aic_patch19_func, 634, 1, 2 },
-	{ aic_patch0_func, 635, 3, 2 },
-	{ aic_patch4_func, 637, 1, 1 },
-	{ aic_patch5_func, 638, 1, 1 },
-	{ aic_patch5_func, 641, 1, 1 },
-	{ aic_patch5_func, 643, 1, 1 },
-	{ aic_patch4_func, 645, 2, 2 },
-	{ aic_patch0_func, 647, 2, 1 },
-	{ aic_patch5_func, 649, 1, 1 },
-	{ aic_patch5_func, 652, 1, 1 },
-	{ aic_patch5_func, 655, 1, 1 },
-	{ aic_patch19_func, 659, 1, 1 },
-	{ aic_patch19_func, 662, 1, 1 },
-	{ aic_patch4_func, 668, 1, 1 },
-	{ aic_patch6_func, 671, 1, 2 },
-	{ aic_patch0_func, 672, 1, 1 },
-	{ aic_patch7_func, 684, 16, 1 },
-	{ aic_patch4_func, 700, 20, 1 },
-	{ aic_patch9_func, 721, 4, 2 },
-	{ aic_patch0_func, 725, 4, 1 },
-	{ aic_patch9_func, 729, 4, 2 },
-	{ aic_patch0_func, 733, 3, 1 },
-	{ aic_patch6_func, 739, 1, 1 },
-	{ aic_patch22_func, 741, 14, 1 },
-	{ aic_patch7_func, 755, 3, 1 },
-	{ aic_patch9_func, 767, 24, 8 },
-	{ aic_patch19_func, 771, 1, 2 },
-	{ aic_patch0_func, 772, 1, 1 },
-	{ aic_patch15_func, 777, 4, 2 },
-	{ aic_patch0_func, 781, 7, 3 },
-	{ aic_patch23_func, 781, 5, 2 },
-	{ aic_patch0_func, 786, 2, 1 },
-	{ aic_patch0_func, 791, 42, 3 },
-	{ aic_patch18_func, 803, 18, 2 },
-	{ aic_patch0_func, 821, 1, 1 },
-	{ aic_patch4_func, 845, 1, 1 },
-	{ aic_patch4_func, 846, 3, 2 },
-	{ aic_patch0_func, 849, 1, 1 },
-	{ aic_patch13_func, 850, 3, 1 },
-	{ aic_patch4_func, 853, 12, 1 }
+	ahc_patch_func_t		*patch_func;
+	uint32_t		 begin		:10,
+				 skip_instr	:10,
+				 skip_patch	:12;
+} patches[] = {
+	{ ahc_patch1_func, 4, 1, 1 },
+	{ ahc_patch2_func, 6, 2, 1 },
+	{ ahc_patch2_func, 9, 1, 1 },
+	{ ahc_patch3_func, 11, 1, 2 },
+	{ ahc_patch0_func, 12, 2, 1 },
+	{ ahc_patch4_func, 15, 1, 2 },
+	{ ahc_patch0_func, 16, 1, 1 },
+	{ ahc_patch5_func, 22, 2, 1 },
+	{ ahc_patch3_func, 27, 1, 2 },
+	{ ahc_patch0_func, 28, 1, 1 },
+	{ ahc_patch6_func, 34, 1, 1 },
+	{ ahc_patch7_func, 37, 54, 19 },
+	{ ahc_patch8_func, 37, 1, 1 },
+	{ ahc_patch9_func, 42, 3, 2 },
+	{ ahc_patch0_func, 45, 3, 1 },
+	{ ahc_patch10_func, 49, 1, 2 },
+	{ ahc_patch0_func, 50, 2, 3 },
+	{ ahc_patch1_func, 50, 1, 2 },
+	{ ahc_patch0_func, 51, 1, 1 },
+	{ ahc_patch2_func, 53, 2, 1 },
+	{ ahc_patch9_func, 55, 1, 2 },
+	{ ahc_patch0_func, 56, 1, 1 },
+	{ ahc_patch9_func, 60, 1, 2 },
+	{ ahc_patch0_func, 61, 1, 1 },
+	{ ahc_patch9_func, 71, 1, 2 },
+	{ ahc_patch0_func, 72, 1, 1 },
+	{ ahc_patch9_func, 75, 1, 2 },
+	{ ahc_patch0_func, 76, 1, 1 },
+	{ ahc_patch9_func, 79, 1, 2 },
+	{ ahc_patch0_func, 80, 1, 1 },
+	{ ahc_patch8_func, 91, 9, 4 },
+	{ ahc_patch1_func, 93, 1, 2 },
+	{ ahc_patch0_func, 94, 1, 1 },
+	{ ahc_patch2_func, 96, 2, 1 },
+	{ ahc_patch2_func, 105, 4, 1 },
+	{ ahc_patch1_func, 109, 1, 2 },
+	{ ahc_patch0_func, 110, 2, 3 },
+	{ ahc_patch2_func, 110, 1, 2 },
+	{ ahc_patch0_func, 111, 1, 1 },
+	{ ahc_patch7_func, 112, 4, 2 },
+	{ ahc_patch0_func, 116, 1, 1 },
+	{ ahc_patch11_func, 117, 2, 1 },
+	{ ahc_patch1_func, 119, 1, 2 },
+	{ ahc_patch0_func, 120, 1, 1 },
+	{ ahc_patch7_func, 121, 4, 1 },
+	{ ahc_patch7_func, 131, 95, 11 },
+	{ ahc_patch4_func, 151, 1, 1 },
+	{ ahc_patch1_func, 168, 1, 1 },
+	{ ahc_patch12_func, 173, 1, 2 },
+	{ ahc_patch0_func, 174, 1, 1 },
+	{ ahc_patch9_func, 185, 1, 2 },
+	{ ahc_patch0_func, 186, 1, 1 },
+	{ ahc_patch9_func, 195, 1, 2 },
+	{ ahc_patch0_func, 196, 1, 1 },
+	{ ahc_patch9_func, 212, 6, 2 },
+	{ ahc_patch0_func, 218, 6, 1 },
+	{ ahc_patch8_func, 226, 20, 2 },
+	{ ahc_patch1_func, 241, 1, 1 },
+	{ ahc_patch1_func, 248, 1, 2 },
+	{ ahc_patch0_func, 249, 2, 2 },
+	{ ahc_patch11_func, 250, 1, 1 },
+	{ ahc_patch9_func, 258, 31, 3 },
+	{ ahc_patch1_func, 274, 14, 2 },
+	{ ahc_patch13_func, 279, 1, 1 },
+	{ ahc_patch14_func, 289, 14, 1 },
+	{ ahc_patch1_func, 305, 1, 2 },
+	{ ahc_patch0_func, 306, 1, 1 },
+	{ ahc_patch9_func, 309, 1, 1 },
+	{ ahc_patch13_func, 314, 1, 1 },
+	{ ahc_patch9_func, 315, 2, 2 },
+	{ ahc_patch0_func, 317, 4, 1 },
+	{ ahc_patch14_func, 321, 1, 1 },
+	{ ahc_patch15_func, 324, 2, 3 },
+	{ ahc_patch9_func, 324, 1, 2 },
+	{ ahc_patch0_func, 325, 1, 1 },
+	{ ahc_patch6_func, 330, 1, 2 },
+	{ ahc_patch0_func, 331, 1, 1 },
+	{ ahc_patch1_func, 335, 50, 11 },
+	{ ahc_patch6_func, 344, 2, 4 },
+	{ ahc_patch7_func, 344, 1, 1 },
+	{ ahc_patch8_func, 345, 1, 1 },
+	{ ahc_patch0_func, 346, 1, 1 },
+	{ ahc_patch16_func, 347, 1, 1 },
+	{ ahc_patch6_func, 366, 6, 3 },
+	{ ahc_patch16_func, 366, 5, 1 },
+	{ ahc_patch0_func, 372, 5, 1 },
+	{ ahc_patch13_func, 380, 5, 1 },
+	{ ahc_patch0_func, 385, 54, 17 },
+	{ ahc_patch14_func, 385, 1, 1 },
+	{ ahc_patch7_func, 387, 2, 2 },
+	{ ahc_patch17_func, 388, 1, 1 },
+	{ ahc_patch9_func, 391, 1, 1 },
+	{ ahc_patch18_func, 398, 1, 1 },
+	{ ahc_patch14_func, 403, 9, 3 },
+	{ ahc_patch9_func, 404, 3, 2 },
+	{ ahc_patch0_func, 407, 3, 1 },
+	{ ahc_patch9_func, 415, 6, 2 },
+	{ ahc_patch0_func, 421, 9, 2 },
+	{ ahc_patch13_func, 421, 1, 1 },
+	{ ahc_patch13_func, 430, 2, 1 },
+	{ ahc_patch14_func, 432, 1, 1 },
+	{ ahc_patch9_func, 434, 1, 2 },
+	{ ahc_patch0_func, 435, 1, 1 },
+	{ ahc_patch7_func, 438, 1, 1 },
+	{ ahc_patch7_func, 439, 1, 1 },
+	{ ahc_patch8_func, 440, 3, 3 },
+	{ ahc_patch6_func, 441, 1, 2 },
+	{ ahc_patch0_func, 442, 1, 1 },
+	{ ahc_patch9_func, 443, 1, 1 },
+	{ ahc_patch15_func, 444, 1, 2 },
+	{ ahc_patch13_func, 444, 1, 1 },
+	{ ahc_patch14_func, 446, 9, 4 },
+	{ ahc_patch9_func, 446, 1, 1 },
+	{ ahc_patch9_func, 453, 2, 1 },
+	{ ahc_patch0_func, 455, 4, 3 },
+	{ ahc_patch9_func, 455, 1, 2 },
+	{ ahc_patch0_func, 456, 3, 1 },
+	{ ahc_patch1_func, 460, 2, 1 },
+	{ ahc_patch7_func, 462, 10, 2 },
+	{ ahc_patch0_func, 472, 1, 1 },
+	{ ahc_patch8_func, 473, 118, 22 },
+	{ ahc_patch1_func, 475, 3, 2 },
+	{ ahc_patch0_func, 478, 5, 3 },
+	{ ahc_patch9_func, 478, 2, 2 },
+	{ ahc_patch0_func, 480, 3, 1 },
+	{ ahc_patch1_func, 485, 2, 2 },
+	{ ahc_patch0_func, 487, 6, 3 },
+	{ ahc_patch9_func, 487, 2, 2 },
+	{ ahc_patch0_func, 489, 3, 1 },
+	{ ahc_patch1_func, 495, 2, 2 },
+	{ ahc_patch0_func, 497, 9, 7 },
+	{ ahc_patch9_func, 497, 5, 6 },
+	{ ahc_patch19_func, 497, 1, 2 },
+	{ ahc_patch0_func, 498, 1, 1 },
+	{ ahc_patch19_func, 500, 1, 2 },
+	{ ahc_patch0_func, 501, 1, 1 },
+	{ ahc_patch0_func, 502, 4, 1 },
+	{ ahc_patch6_func, 507, 3, 2 },
+	{ ahc_patch0_func, 510, 1, 1 },
+	{ ahc_patch6_func, 520, 1, 2 },
+	{ ahc_patch0_func, 521, 1, 1 },
+	{ ahc_patch20_func, 558, 7, 1 },
+	{ ahc_patch3_func, 593, 1, 2 },
+	{ ahc_patch0_func, 594, 1, 1 },
+	{ ahc_patch21_func, 597, 1, 1 },
+	{ ahc_patch8_func, 599, 106, 33 },
+	{ ahc_patch4_func, 601, 1, 1 },
+	{ ahc_patch1_func, 607, 2, 2 },
+	{ ahc_patch0_func, 609, 1, 1 },
+	{ ahc_patch1_func, 612, 1, 2 },
+	{ ahc_patch0_func, 613, 1, 1 },
+	{ ahc_patch9_func, 614, 3, 3 },
+	{ ahc_patch15_func, 615, 1, 1 },
+	{ ahc_patch0_func, 617, 4, 1 },
+	{ ahc_patch19_func, 626, 2, 2 },
+	{ ahc_patch0_func, 628, 1, 1 },
+	{ ahc_patch19_func, 632, 10, 3 },
+	{ ahc_patch5_func, 634, 8, 1 },
+	{ ahc_patch0_func, 642, 9, 2 },
+	{ ahc_patch5_func, 643, 8, 1 },
+	{ ahc_patch4_func, 653, 1, 2 },
+	{ ahc_patch0_func, 654, 1, 1 },
+	{ ahc_patch19_func, 655, 1, 2 },
+	{ ahc_patch0_func, 656, 3, 2 },
+	{ ahc_patch4_func, 658, 1, 1 },
+	{ ahc_patch5_func, 659, 1, 1 },
+	{ ahc_patch5_func, 662, 1, 1 },
+	{ ahc_patch5_func, 664, 1, 1 },
+	{ ahc_patch4_func, 666, 2, 2 },
+	{ ahc_patch0_func, 668, 2, 1 },
+	{ ahc_patch5_func, 670, 1, 1 },
+	{ ahc_patch5_func, 673, 1, 1 },
+	{ ahc_patch5_func, 676, 1, 1 },
+	{ ahc_patch19_func, 680, 1, 1 },
+	{ ahc_patch19_func, 683, 1, 1 },
+	{ ahc_patch4_func, 689, 1, 1 },
+	{ ahc_patch6_func, 692, 1, 2 },
+	{ ahc_patch0_func, 693, 1, 1 },
+	{ ahc_patch7_func, 705, 16, 1 },
+	{ ahc_patch4_func, 721, 20, 1 },
+	{ ahc_patch9_func, 742, 4, 2 },
+	{ ahc_patch0_func, 746, 4, 1 },
+	{ ahc_patch9_func, 750, 4, 2 },
+	{ ahc_patch0_func, 754, 3, 1 },
+	{ ahc_patch6_func, 760, 1, 1 },
+	{ ahc_patch22_func, 762, 14, 1 },
+	{ ahc_patch7_func, 776, 3, 1 },
+	{ ahc_patch9_func, 788, 24, 8 },
+	{ ahc_patch19_func, 792, 1, 2 },
+	{ ahc_patch0_func, 793, 1, 1 },
+	{ ahc_patch15_func, 798, 4, 2 },
+	{ ahc_patch0_func, 802, 7, 3 },
+	{ ahc_patch23_func, 802, 5, 2 },
+	{ ahc_patch0_func, 807, 2, 1 },
+	{ ahc_patch0_func, 812, 42, 3 },
+	{ ahc_patch18_func, 824, 18, 2 },
+	{ ahc_patch0_func, 842, 1, 1 },
+	{ ahc_patch4_func, 866, 1, 1 },
+	{ ahc_patch4_func, 867, 3, 2 },
+	{ ahc_patch0_func, 870, 1, 1 },
+	{ ahc_patch13_func, 871, 3, 1 },
+	{ ahc_patch4_func, 874, 12, 1 }
 };
 
 static struct cs {
-	u_int16_t	begin;
-	u_int16_t	end;
-} const critical_sections[] = {
+	uint16_t	begin;
+	uint16_t	end;
+} critical_sections[] = {
 	{ 11, 18 },
 	{ 21, 30 },
-	{ 700, 716 },
-	{ 846, 849 },
-	{ 853, 859 },
-	{ 861, 863 },
-	{ 863, 865 }
+	{ 721, 737 },
+	{ 867, 870 },
+	{ 874, 880 },
+	{ 882, 884 },
+	{ 884, 886 }
 };
 
 static const int num_critical_sections = sizeof(critical_sections)
diff --git a/sys/dev/microcode/aic7xxx/aicasm.c b/sys/dev/microcode/aic7xxx/aicasm.c
index c6a4c027b45..91f4314c61f 100644
--- a/sys/dev/microcode/aic7xxx/aicasm.c
+++ b/sys/dev/microcode/aic7xxx/aicasm.c
@@ -1,9 +1,11 @@
-/* $OpenBSD: aicasm.c,v 1.10 2003/08/12 20:27:02 mickey Exp $ */
+/* $OpenBSD: aicasm.c,v 1.11 2003/12/24 23:27:55 krw Exp $ */
+/*	$NetBSD: aicasm.c,v 1.5 2003/07/14 15:42:39 lukem Exp $	*/
+
 /*
  * Aic7xxx SCSI host adapter firmware asssembler
  *
  * Copyright (c) 1997, 1998, 2000, 2001 Justin T. Gibbs.
- * Copyright (c) 2001 Adaptec Inc.
+ * Copyright (c) 2001, 2002 Adaptec Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -38,10 +40,12 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: aicasm.c,v 1.10 2003/08/12 20:27:02 mickey Exp $
- *
- * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm.c,v 1.34 2002/06/05 22:51:54 gibbs Exp $
+ * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm.c,v 1.35 2002/08/31 06:39:40 gibbs Exp $
  */
+
+#include <sys/cdefs.h>
+/* __RCSID("$NetBSD: aicasm.c,v 1.5 2003/07/14 15:42:39 lukem Exp $"); */
+
 #include <sys/types.h>
 #include <sys/mman.h>
 
@@ -54,9 +58,15 @@
 #include <sysexits.h>
 #include <unistd.h>
 
+#if linux
+#include <endian.h>
+#else
+#include <machine/endian.h>
+#endif
+
 #include "aicasm.h"
 #include "aicasm_symbol.h"
-#include "sequencer.h"
+#include "aicasm_insformat.h"
 
 typedef struct patch {
 	TAILQ_ENTRY(patch) links;
@@ -80,12 +90,15 @@ static int check_patch(patch_t **start_patch, int start_instr,
 struct path_list search_path;
 int includes_search_curdir;
 char *appname;
+char *stock_include_file;
 FILE *ofile;
 char *ofilename;
 char *regfilename;
 FILE *regfile;
 char *listfilename;
 FILE *listfile;
+char *regdiagfilename;
+FILE *regdiagfile;
 int   src_mode;
 int   dst_mode;
 
@@ -103,10 +116,10 @@ extern int mmdebug;
 extern FILE *yyin;
 extern int yyparse(void);
 
+int main(int argc, char *argv[]);
+
 int
-main(argc, argv)
-	int argc;
-	char *argv[];
+main(int argc, char *argv[])
 {
 	extern char *optarg;
 	extern int optind;
@@ -118,7 +131,7 @@ main(argc, argv)
 	TAILQ_INIT(&patches);
 	SLIST_INIT(&search_path);
 	TAILQ_INIT(&seq_program);
-        TAILQ_INIT(&cs_tailq);
+	TAILQ_INIT(&cs_tailq);
 	SLIST_INIT(&scope_stack);
 
 	/* Set Sentinal scope node */
@@ -135,7 +148,7 @@ main(argc, argv)
 	yydebug = 0;
 	mmdebug = 0;
 #endif
-	while ((ch = getopt(argc, argv, "d:l:n:o:r:I:O:")) != -1) {
+	while ((ch = getopt(argc, argv, "d:i:l:n:o:p:r:I:")) != -1) {
 		switch(ch) {
 		case 'd':
 #if DEBUG
@@ -155,6 +168,9 @@ main(argc, argv)
 			     "information", EX_SOFTWARE);
 #endif
 			break;
+		case 'i':
+			stock_include_file = optarg;
+			break;
 		case 'l':
 			/* Create a program listing */
 			if ((listfile = fopen(optarg, "w")) == NULL) {
@@ -179,6 +195,14 @@ main(argc, argv)
 			}
 			ofilename = optarg;
 			break;
+		case 'p':
+			/* Create Register Diagnostic "printing" Functions */
+			if ((regdiagfile = fopen(optarg, "w")) == NULL) {
+				perror(optarg);
+				stop(NULL, EX_CANTCREAT);
+			}
+			regdiagfilename = optarg;
+			break;
 		case 'r':
 			if ((regfile = fopen(optarg, "w")) == NULL) {
 				perror(optarg);
@@ -197,15 +221,16 @@ main(argc, argv)
 							"times\n", appname);
 				}
 				includes_search_curdir = 0;
-				SLIST_FOREACH(include_dir, &search_path,
-				    links) {
+				for (include_dir = SLIST_FIRST(&search_path);
+				     include_dir != NULL;
+				     include_dir = SLIST_NEXT(include_dir,
+							      links))
 					/*
 					 * All entries before a '-I-' only
 					 * apply to includes specified with
 					 * quotes instead of "<>".
 					 */
 					include_dir->quoted_includes_only = 1;
-				}
 			} else {
 				include_dir =
 				    (path_entry_t)malloc(sizeof(*include_dir));
@@ -239,6 +264,14 @@ main(argc, argv)
 		/* NOTREACHED */
 	}
 
+	if (regdiagfile != NULL
+	 && (regfile == NULL || stock_include_file == NULL)) {
+		fprintf(stderr,
+			"%s: The -p option requires the -r and -i options.\n",
+			appname);
+		usage();
+		/* NOTREACHED */
+	}
 	symtable_open();
 	inputfilename = *argv;
 	include_file(*argv, SOURCE_FILE);
@@ -246,8 +279,7 @@ main(argc, argv)
 	if (retval == 0) {
 		if (SLIST_FIRST(&scope_stack) == NULL
 		 || SLIST_FIRST(&scope_stack)->type != SCOPE_ROOT) {
-			stop("Unterminated conditional expression",
-			     EX_DATAERR);
+			stop("Unterminated conditional expression", EX_DATAERR);
 			/* NOTREACHED */
 		}
 
@@ -266,9 +298,8 @@ main(argc, argv)
 
 		if (ofile != NULL)
 			output_code();
-		if (regfile != NULL) {
-			symtable_dump(regfile);
-		}
+		if (regfile != NULL)
+			symtable_dump(regfile, regdiagfile);
 		if (listfile != NULL)
 			output_listing(inputfilename);
 	}
@@ -284,9 +315,9 @@ usage()
 
 	(void)fprintf(stderr,
 "usage: %-16s [-nostdinc] [-I-] [-I directory] [-o output_file]\n"
-"			[-r register_output_file] [-l program_list_file]\n"
-"			input_file\n",
-			appname);
+"	[-r register_output_file [-p register_diag_file -i includefile]]\n"
+"	[-l program_list_file]\n"
+"	input_file\n", appname);
 	exit(EX_USAGE);
 }
 
@@ -295,9 +326,9 @@ back_patch()
 {
 	struct instruction *cur_instr;
 
-	for(cur_instr = seq_program.tqh_first;
-	    cur_instr != NULL;
-	    cur_instr = cur_instr->links.tqe_next) {
+	for (cur_instr = TAILQ_FIRST(&seq_program);
+	     cur_instr != NULL;
+	     cur_instr = TAILQ_NEXT(cur_instr, links)) {
 		if (cur_instr->patch_label != NULL) {
 			struct ins_format3 *f3_instr;
 			u_int address;
@@ -324,7 +355,7 @@ output_code()
 {
 	struct instruction *cur_instr;
 	patch_t *cur_patch;
-        critical_section_t *cs;
+	critical_section_t *cs;
 	symbol_node_t *cur_node;
 	int instrcount;
 
@@ -336,27 +367,27 @@ output_code()
 " *\n"
 "%s */\n", versions);
 
-	fprintf(ofile, "static const u_int8_t seqprog[] = {\n");
-	for(cur_instr = seq_program.tqh_first;
-	    cur_instr != NULL;
-	    cur_instr = cur_instr->links.tqe_next) {
+	fprintf(ofile, "static uint8_t seqprog[] = {\n");
+	for (cur_instr = TAILQ_FIRST(&seq_program);
+	     cur_instr != NULL;
+	     cur_instr = TAILQ_NEXT(cur_instr, links)) {
 
-                fprintf(ofile, "%s\t0x%02x, 0x%02x, 0x%02x, 0x%02x",
-                        cur_instr == seq_program.tqh_first ? "" : ",\n",
+		fprintf(ofile, "%s\t0x%02x, 0x%02x, 0x%02x, 0x%02x",
+			cur_instr == TAILQ_FIRST(&seq_program) ? "" : ",\n",
 #if BYTE_ORDER == LITTLE_ENDIAN
 			cur_instr->format.bytes[0],
 			cur_instr->format.bytes[1],
 			cur_instr->format.bytes[2],
 			cur_instr->format.bytes[3]);
 #else
-                        cur_instr->format.bytes[3],
-                        cur_instr->format.bytes[2],
-                        cur_instr->format.bytes[1],
-                        cur_instr->format.bytes[0]);
+			cur_instr->format.bytes[3],
+			cur_instr->format.bytes[2],
+			cur_instr->format.bytes[1],
+			cur_instr->format.bytes[0]);
 #endif
 		instrcount++;
 	}
-        fprintf(ofile, "\n};\n\n");
+	fprintf(ofile, "\n};\n\n");
 
 	if (patch_arg_list == NULL)
 		stop("Patch argument list not defined",
@@ -365,61 +396,66 @@ output_code()
 	/*
 	 *  Output patch information.  Patch functions first.
 	 */
-	for(cur_node = SLIST_FIRST(&patch_functions);
-	    cur_node != NULL;
-	    cur_node = SLIST_NEXT(cur_node,links)) {
+	fprintf(ofile,
+"typedef int %spatch_func_t (%s);\n", prefix, patch_arg_list);
+
+	for (cur_node = SLIST_FIRST(&patch_functions);
+	     cur_node != NULL;
+	     cur_node = SLIST_NEXT(cur_node,links)) {
 		fprintf(ofile,
-"static int aic_patch%d_func(%s);\n"
+"static %spatch_func_t %spatch%d_func;\n"
 "\n"
 "static int\n"
-"aic_patch%d_func(%s)\n"
+"%spatch%d_func(%s)\n"
 "{\n"
 "	return (%s);\n"
 "}\n\n",
+			prefix,
+			prefix,
 			cur_node->symbol->info.condinfo->func_num,
-			patch_arg_list,
+			prefix,
 			cur_node->symbol->info.condinfo->func_num,
 			patch_arg_list,
 			cur_node->symbol->name);
 	}
 
 	fprintf(ofile,
-"typedef int patch_func_t (%s);\n"
 "static struct patch {\n"
-"	patch_func_t	*patch_func;\n"
-"	uint32_t	begin	   :10,\n"
-"			skip_instr :10,\n"
-"			skip_patch :12;\n"
-"} const patches[] = {\n", patch_arg_list);
-
-	for(cur_patch = TAILQ_FIRST(&patches);
-	    cur_patch != NULL;
-            cur_patch = TAILQ_NEXT(cur_patch,links)) {
-		fprintf(ofile, "%s\t{ aic_patch%d_func, %d, %d, %d }",
-                        cur_patch == TAILQ_FIRST(&patches) ? "" : ",\n",
+"	%spatch_func_t		*patch_func;\n"
+"	uint32_t		 begin		:10,\n"
+"				 skip_instr	:10,\n"
+"				 skip_patch	:12;\n"
+"} patches[] = {\n", prefix);
+
+	for (cur_patch = TAILQ_FIRST(&patches);
+	     cur_patch != NULL;
+	     cur_patch = TAILQ_NEXT(cur_patch,links)) {
+		fprintf(ofile, "%s\t{ %spatch%d_func, %d, %d, %d }",
+			cur_patch == TAILQ_FIRST(&patches) ? "" : ",\n",
+			prefix,
 			cur_patch->patch_func, cur_patch->begin,
 			cur_patch->skip_instr, cur_patch->skip_patch);
-        }
+	}
 
 	fprintf(ofile, "\n};\n\n");
 
-        fprintf(ofile,
+	fprintf(ofile,
 "static struct cs {\n"
-"	u_int16_t	begin;\n"
-"	u_int16_t	end;\n"
-"} const critical_sections[] = {\n");
-
-        for(cs = TAILQ_FIRST(&cs_tailq);
-            cs != NULL;
-            cs = TAILQ_NEXT(cs, links)) {
-                fprintf(ofile, "%s\t{ %d, %d }",
-                        cs == TAILQ_FIRST(&cs_tailq) ? "" : ",\n",
-                        cs->begin_addr, cs->end_addr);
+"	uint16_t	begin;\n"
+"	uint16_t	end;\n"
+"} critical_sections[] = {\n");
+
+	for (cs = TAILQ_FIRST(&cs_tailq);
+	     cs != NULL;
+	     cs = TAILQ_NEXT(cs, links)) {
+		fprintf(ofile, "%s\t{ %d, %d }",
+			cs == TAILQ_FIRST(&cs_tailq) ? "" : ",\n",
+			cs->begin_addr, cs->end_addr);
 	}
 
 	fprintf(ofile, "\n};\n\n");
 
-        fprintf(ofile,
+	fprintf(ofile,
 "static const int num_critical_sections = sizeof(critical_sections)\n"
 "				       / sizeof(*critical_sections);\n");
 
@@ -517,7 +553,7 @@ output_listing(char *ifilename)
 	    cur_func = SLIST_NEXT(cur_func, links))
 		func_count++;
 
-        func_values = NULL;
+	func_values = NULL;
 	if (func_count != 0) {
 		func_values = (int *)malloc(func_count * sizeof(int));
 
@@ -564,9 +600,9 @@ output_listing(char *ifilename)
 
 	/* Now output the listing */
 	cur_patch = TAILQ_FIRST(&patches);
-	for(cur_instr = TAILQ_FIRST(&seq_program);
-	    cur_instr != NULL;
-	    cur_instr = TAILQ_NEXT(cur_instr, links), instrcount++) {
+	for (cur_instr = TAILQ_FIRST(&seq_program);
+	     cur_instr != NULL;
+	     cur_instr = TAILQ_NEXT(cur_instr, links), instrcount++) {
 
 		if (check_patch(&cur_patch, instrcount,
 				&skip_addr, func_values) == 0) {
@@ -588,10 +624,10 @@ output_listing(char *ifilename)
 			cur_instr->format.bytes[2],
 			cur_instr->format.bytes[3]);
 #else
-                        cur_instr->format.bytes[3],
-                        cur_instr->format.bytes[2],
-                        cur_instr->format.bytes[1],
-                        cur_instr->format.bytes[0]);
+			cur_instr->format.bytes[3],
+			cur_instr->format.bytes[2],
+			cur_instr->format.bytes[1],
+			cur_instr->format.bytes[0]);
 #endif
 		fgets(buf, sizeof(buf), ifile);
 		fprintf(listfile, "\t%s", buf);
@@ -645,9 +681,7 @@ check_patch(patch_t **start_patch, int start_instr,
  * terminating the program.
  */
 void
-stop(string, err_code)
-	const char *string;
-	int  err_code;
+stop(const char *string, int err_code)
 {
 	if (string != NULL) {
 		fprintf(stderr, "%s: ", appname);
@@ -708,15 +742,15 @@ seq_alloc()
 critical_section_t *
 cs_alloc()
 {
-        critical_section_t *new_cs;
-
-        new_cs= (critical_section_t *)malloc(sizeof(critical_section_t));
-        if (new_cs == NULL)
-                stop("Unable to malloc critical_section object", EX_SOFTWARE);
-        memset(new_cs, 0, sizeof(*new_cs));
-        
-        TAILQ_INSERT_TAIL(&cs_tailq, new_cs, links);
-        return new_cs;
+	critical_section_t *new_cs;
+
+	new_cs= (critical_section_t *)malloc(sizeof(critical_section_t));
+	if (new_cs == NULL)
+		stop("Unable to malloc critical_section object", EX_SOFTWARE);
+	memset(new_cs, 0, sizeof(*new_cs));
+	
+	TAILQ_INSERT_TAIL(&cs_tailq, new_cs, links);
+	return new_cs;
 }
 
 scope_t *
diff --git a/sys/dev/microcode/aic7xxx/aicasm.h b/sys/dev/microcode/aic7xxx/aicasm.h
index f20cae736c1..e647c180a78 100644
--- a/sys/dev/microcode/aic7xxx/aicasm.h
+++ b/sys/dev/microcode/aic7xxx/aicasm.h
@@ -1,9 +1,11 @@
-/* $OpenBSD: aicasm.h,v 1.5 2002/06/30 18:25:58 smurph Exp $ */
+/* $OpenBSD: aicasm.h,v 1.6 2003/12/24 23:27:55 krw Exp $ */
+/*	$NetBSD: aicasm.h,v 1.2 2003/04/19 19:26:10 fvdl Exp $	*/
+
 /*
  * Assembler for the sequencer program downloaded to Aic7xxx SCSI host adapters
  *
  * Copyright (c) 1997 Justin T. Gibbs.
- * Copyright (c) 2001 Adaptec Inc.
+ * Copyright (c) 2001, 2002 Adaptec Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -38,10 +40,14 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm.h,v 1.15 2002/06/05 22:51:54 gibbs Exp $
+ * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm.h,v 1.16 2002/08/31 06:39:40 gibbs Exp $
  */
 
+#ifdef __linux__
+#include "../queue.h"
+#else
 #include <sys/queue.h>
+#endif
 
 #ifndef TRUE
 #define TRUE 1
@@ -71,8 +77,10 @@ extern struct scope_list scope_stack;
 extern struct symlist patch_functions;
 extern int includes_search_curdir;		/* False if we've seen -I- */
 extern char *appname;
+extern char *stock_include_file;
 extern int yylineno;
 extern char *yyfilename;
+extern char *prefix;
 extern char *patch_arg_list;
 extern char *versions;
 extern int   src_mode;
diff --git a/sys/dev/microcode/aic7xxx/aicasm_gram.y b/sys/dev/microcode/aic7xxx/aicasm_gram.y
index 6b88e2c0372..2c84b9215b7 100644
--- a/sys/dev/microcode/aic7xxx/aicasm_gram.y
+++ b/sys/dev/microcode/aic7xxx/aicasm_gram.y
@@ -1,9 +1,12 @@
 %{
+/*	$OpenBSD: aicasm_gram.y,v 1.11 2003/12/24 23:27:55 krw Exp $	*/
+/*	$NetBSD: aicasm_gram.y,v 1.3 2003/04/19 19:26:11 fvdl Exp $	*/
+
 /*
  * Parser for the Aic7xxx SCSI Host adapter sequencer assembler.
  *
  * Copyright (c) 1997, 1998, 2000 Justin T. Gibbs.
- * Copyright (c) 2001 Adaptec Inc.
+ * Copyright (c) 2001, 2002 Adaptec Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -38,7 +41,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_gram.y,v 1.17 2002/06/05 22:51:54 gibbs Exp $
+ * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_gram.y,v 1.23 2003/01/20 18:02:11 gibbs Exp $
  */
 
 #include <sys/types.h>
@@ -50,19 +53,26 @@
 #include <string.h>
 #include <sysexits.h>
 
+#ifdef __linux__
+#include "../queue.h"
+#else
 #include <sys/queue.h>
+#endif
 
 #include "aicasm.h"
 #include "aicasm_symbol.h"
-#include "sequencer.h"
+#include "aicasm_insformat.h"
 
 int yylineno;
 char *yyfilename;
+char stock_prefix[] = "aic_";
+char *prefix = stock_prefix;
 char *patch_arg_list;
 char *versions;
 static char errbuf[255];
 static char regex_pattern[255];
 static symbol_t *cur_symbol;
+static symbol_t *field_symbol;
 static symbol_t *scb_or_sram_symbol;
 static symtype cur_symtype;
 static symbol_ref_t accumulator;
@@ -76,8 +86,10 @@ static int num_srams;
 static int sram_or_scb_offset;
 static int download_constant_count;
 static int in_critical_section;
+static u_int enum_increment;
+static u_int enum_next_value;
 
-static void process_bitmask(int mask_type, symbol_t *sym, int mask);
+static void process_field(int field_type, symbol_t *sym, int mask);
 static void initialize_symbol(symbol_t *symbol);
 static void add_macro_arg(const char *argtext, int position);
 static void add_macro_body(const char *bodytext);
@@ -146,7 +158,9 @@ static int  is_download_const(expression_t *immed);
 
 %token T_END_CS
 
-%token T_BIT
+%token T_FIELD
+
+%token T_ENUM
 
 %token T_MASK
 
@@ -156,7 +170,7 @@ static int  is_download_const(expression_t *immed);
 
 %token <sym> T_CEXPR
 
-%token T_EOF T_INCLUDE T_VERSION T_PATCH_ARG_LIST
+%token T_EOF T_INCLUDE T_VERSION T_PREFIX T_PATCH_ARG_LIST
 
 %token <value> T_SHR T_SHL T_ROR T_ROL
 
@@ -196,7 +210,7 @@ static int  is_download_const(expression_t *immed);
 
 %type <value> export ret f1_opcode f2_opcode jmp_jc_jnc_call jz_jnz je_jne
 
-%type <value> numerical_value mode_value mode_list macro_arglist
+%type <value> mode_value mode_list macro_arglist
 
 %left '|'
 %left '&'
@@ -210,10 +224,12 @@ static int  is_download_const(expression_t *immed);
 program:
 	include
 |	program include
+|	prefix
+|	program prefix
 |	patch_arg_list
 |	program patch_arg_list
-|       version
-|       program version
+|	version
+|	program version
 |	register
 |	program register
 |	constant
@@ -230,10 +246,10 @@ program:
 |	program set_src_mode
 |	set_dst_mode
 |	program set_dst_mode
-|       critical_section_start
-|       program critical_section_start
-|       critical_section_end
-|       program critical_section_end
+|	critical_section_start
+|	program critical_section_start
+|	critical_section_end
+|	program critical_section_end
 |	conditional
 |	program conditional
 |	code
@@ -242,13 +258,25 @@ program:
 
 include:
 	T_INCLUDE '<' T_PATH '>'
-        {
-                include_file($3, BRACKETED_INCLUDE);
-        }
+	{
+		include_file($3, BRACKETED_INCLUDE);
+	}
 |	T_INCLUDE '"' T_PATH '"'
-        {
-                include_file($3, QUOTED_INCLUDE);
-        }
+	{
+		include_file($3, QUOTED_INCLUDE);
+	}
+;
+
+prefix:
+	T_PREFIX '=' T_STRING
+	{
+		if (prefix != stock_prefix)
+			stop("Prefix multiply defined",
+			     EX_DATAERR);
+		prefix = strdup($3);
+		if (prefix == NULL)
+			stop("Unable to record prefix", EX_SOFTWARE);
+	}
 ;
 
 patch_arg_list:
@@ -264,8 +292,8 @@ patch_arg_list:
 ;
 
 version:
-        T_VERSION '=' T_STRING
-        { add_version($3); }
+	T_VERSION '=' T_STRING
+	{ add_version($3); }
 ;
 
 register:
@@ -320,7 +348,8 @@ reg_attribute:
 |	size
 |	access_mode
 |	modes
-|	bit_defn
+|	field_defn
+|	enum_defn
 |	mask_defn
 |	alias
 |	accumulator
@@ -412,17 +441,68 @@ mode_value:
 	}
 ;
 
-bit_defn:
-	T_BIT T_SYMBOL T_NUMBER
+field_defn:
+	T_FIELD
+		{
+			field_symbol = NULL;
+			enum_next_value = 0;
+			enum_increment = 1;
+		}
+	'{' enum_entry_list '}'
+|	T_FIELD T_SYMBOL expression
+		{
+			process_field(FIELD, $2, $3.value);
+			field_symbol = $2;
+			enum_next_value = 0;
+			enum_increment = 0x01 << (ffs($3.value) - 1);
+		}
+	'{' enum_entry_list '}'
+|	T_FIELD T_SYMBOL expression
 	{
-		process_bitmask(BIT, $2, $3);
+		process_field(FIELD, $2, $3.value);
+	}
+;
+
+enum_defn:
+	T_ENUM
+		{
+			field_symbol = NULL;
+			enum_next_value = 0;
+			enum_increment = 1;
+		}
+	'{' enum_entry_list '}'
+|	T_ENUM T_SYMBOL expression
+		{
+			process_field(ENUM, $2, $3.value);
+			field_symbol = $2;
+			enum_next_value = 0;
+			enum_increment = 0x01 << (ffs($3.value) - 1);
+		}
+	'{' enum_entry_list '}'
+;
+
+enum_entry_list:
+	enum_entry
+|	enum_entry_list ',' enum_entry
+;
+
+enum_entry:
+	T_SYMBOL
+	{
+		process_field(ENUM_ENTRY, $1, enum_next_value);
+		enum_next_value += enum_increment;
+	}
+|	T_SYMBOL expression
+	{
+		process_field(ENUM_ENTRY, $1, $2.value);
+		enum_next_value = $2.value + enum_increment;
 	}
 ;
 
 mask_defn:
 	T_MASK T_SYMBOL expression
 	{
-		process_bitmask(MASK, $2, $3.value);
+		process_field(MASK, $2, $3.value);
 	}
 ;
 
@@ -602,8 +682,10 @@ expression:
 			$$.value = symbol->info.rinfo->address;
 			break;
 		case MASK:
-		case BIT:
-			$$.value = symbol->info.minfo->mask;
+		case FIELD:
+		case ENUM:
+		case ENUM_ENTRY:
+			$$.value = symbol->info.finfo->value;
 			break;
 		case DOWNLOAD_CONST:
 		case CONST:
@@ -626,7 +708,7 @@ expression:
 ;
 
 constant:
-	T_CONST T_SYMBOL numerical_value
+	T_CONST T_SYMBOL expression 
 	{
 		if ($2->type != UNINITIALIZED) {
 			stop("Re-definition of symbol as a constant",
@@ -635,7 +717,7 @@ constant:
 		}
 		$2->type = CONST;
 		initialize_symbol($2);
-		$2->info.cinfo->value = $3;
+		$2->info.cinfo->value = $3.value;
 	}
 |	T_CONST T_SYMBOL T_DOWNLOAD
 	{
@@ -703,17 +785,6 @@ macro_arglist:
 	}
 ;
 
-numerical_value:
-	T_NUMBER
-	{
-		$$ = $1;
-	}
-|	'-' T_NUMBER
-	{
-		$$ = -$2;
-	}
-;
-
 scratch_ram:
 	T_SRAM '{'
 		{
@@ -752,8 +823,8 @@ scb:
 			}
 			cur_symbol->type = SCBLOC;
 			initialize_symbol(cur_symbol);
-                        /* 64 bytes of SCB space */
-                        cur_symbol->info.rinfo->size = 64;
+			/* 64 bytes of SCB space */
+			cur_symbol->info.rinfo->size = 64;
 		}
 		reg_address
 		{
@@ -790,21 +861,21 @@ reg_symbol:
 		$$.symbol = $1;
 		$$.offset = 0;
 	}
-|       T_SYMBOL '[' T_SYMBOL ']'
-        {
-                process_register(&$1);
-                if ($3->type != CONST) {
-                        stop("register offset must be a constant", EX_DATAERR);
-                        /* NOTREACHED */
-                }
-                if (($3->info.cinfo->value + 1) > $1->info.rinfo->size) {
-                        stop("Accessing offset beyond range of register",
-                             EX_DATAERR);
-                        /* NOTREACHED */
-                }
-                $$.symbol = $1;
-                $$.offset = $3->info.cinfo->value;
-        }
+|	T_SYMBOL '[' T_SYMBOL ']'
+	{
+		process_register(&$1);
+		if ($3->type != CONST) {
+			stop("register offset must be a constant", EX_DATAERR);
+			/* NOTREACHED */
+		}
+		if (($3->info.cinfo->value + 1) > $1->info.rinfo->size) {
+			stop("Accessing offset beyond range of register",
+			     EX_DATAERR);
+			/* NOTREACHED */
+		}
+		$$.symbol = $1;
+		$$.offset = $3->info.cinfo->value;
+	}
 |	T_SYMBOL '[' T_NUMBER ']'
 	{
 		process_register(&$1);
@@ -856,6 +927,8 @@ immediate_or_a:
 |	T_A
 	{
 		SLIST_INIT(&$$.referenced_syms);
+		symlist_add(&$$.referenced_syms, accumulator.symbol,
+			    SYMLIST_INSERT_HEAD);
 		$$.value = 0;
 	}
 ;
@@ -900,31 +973,33 @@ set_dst_mode:
 critical_section_start:
 	T_BEGIN_CS ';'
 	{
-                critical_section_t *cs;
+		critical_section_t *cs;
 
-                if (in_critical_section != FALSE) {
-                        stop("Critical Section within Critical Section",
-                             EX_DATAERR);
-                        /* NOTREACHED */
-                }
-                cs = cs_alloc();
-                cs->begin_addr = instruction_ptr;
-                in_critical_section = TRUE;
-        }
+		if (in_critical_section != FALSE) {
+			stop("Critical Section within Critical Section",
+			     EX_DATAERR);
+			/* NOTREACHED */
+		}
+		cs = cs_alloc();
+		cs->begin_addr = instruction_ptr;
+		in_critical_section = TRUE;
+	}
+;
 
 critical_section_end:
 	T_END_CS ';'
 	{
-                critical_section_t *cs;
+		critical_section_t *cs;
 
-                if (in_critical_section == FALSE) {
-                        stop("Unballanced 'end_cs'", EX_DATAERR);
-                        /* NOTREACHED */
-                }
-                cs = TAILQ_LAST(&cs_tailq, cs_tailq);
-                cs->end_addr = instruction_ptr;
-                in_critical_section = FALSE;
-        }
+		if (in_critical_section == FALSE) {
+			stop("Unballanced 'end_cs'", EX_DATAERR);
+			/* NOTREACHED */
+		}
+		cs = TAILQ_LAST(&cs_tailq, cs_tailq);
+		cs->end_addr = instruction_ptr;
+		in_critical_section = FALSE;
+	}
+;
 
 export:
 	{ $$ = 0; }
@@ -1149,25 +1224,38 @@ code:
 	{
 		expression_t immed;
 
-                make_expression(&immed, 1);
-                format_1_instr(AIC_OP_BMOV, &$2, &immed, &$4, $5);
+		make_expression(&immed, 1);
+		format_1_instr(AIC_OP_BMOV, &$2, &immed, &$4, $5);
 	}
 ;
 
 code:
-	T_MVI destination ',' immediate_or_a ret ';'
+	T_MVI destination ',' immediate ret ';'
 	{
-		format_1_instr(AIC_OP_OR, &$2, &$4, &allzeros, $5);
-        }
+		if ($4.value == 0
+		 && is_download_const(&$4) == 0) {
+			expression_t immed;
+
+			/*
+			 * Allow move immediates of 0 so that macros,
+			 * that can't know the immediate's value and
+			 * otherwise compensate, still work.
+			 */
+			make_expression(&immed, 1);
+			format_1_instr(AIC_OP_BMOV, &$2, &immed, &allzeros, $5);
+		} else {
+			format_1_instr(AIC_OP_OR, &$2, &$4, &allzeros, $5);
+		}
+	}
 ;
 
 code:
-        T_NOT destination opt_source ret ';'
-        {
-                expression_t immed;
+	T_NOT destination opt_source ret ';'
+	{
+		expression_t immed;
 
-                make_expression(&immed, 0xff);
-                format_1_instr(AIC_OP_XOR, &$2, &immed, &$3, $4);
+		make_expression(&immed, 0xff);
+		format_1_instr(AIC_OP_XOR, &$2, &immed, &$3, $4);
 	}
 ;
 
@@ -1292,7 +1380,7 @@ code:
 %%
 
 static void
-process_bitmask(int mask_type, symbol_t *sym, int mask)
+process_field(int field_type, symbol_t *sym, int value)
 {
 	/*
 	 * Add the current register to its
@@ -1302,52 +1390,54 @@ process_bitmask(int mask_type, symbol_t *sym, int mask)
 	 * the "allowed bits" of this register.
 	 */
 	if (sym->type == UNINITIALIZED) {
-		sym->type = mask_type;
+		sym->type = field_type;
 		initialize_symbol(sym);
-		if (mask_type == BIT) {
-			if (mask == 0) {
-				stop("Bitmask with no bits set", EX_DATAERR);
-				/* NOTREACHED */
-			}
-			if ((mask & ~(0x01 << (ffs(mask) - 1))) != 0) {
-				stop("Bitmask with more than one bit set",
-				     EX_DATAERR);
+		sym->info.finfo->value = value;
+		if (field_type != ENUM_ENTRY) {
+			if (field_type != MASK && value == 0) {
+				stop("Empty Field, or Enum", EX_DATAERR);
 				/* NOTREACHED */
 			}
+			sym->info.finfo->value = value;
+			sym->info.finfo->mask = value;
+		} else if (field_symbol != NULL) {
+			sym->info.finfo->mask = field_symbol->info.finfo->value;
+		} else {
+			sym->info.finfo->mask = 0xFF;
 		}
-		sym->info.minfo->mask = mask;
-	} else if (sym->type != mask_type) {
-		stop("Bit definition mirrors a definition of the same "
+	} else if (sym->type != field_type) {
+		stop("Field definition mirrors a definition of the same "
 		     " name, but a different type", EX_DATAERR);
 		/* NOTREACHED */
-	} else if (mask != sym->info.minfo->mask) {
-		stop("Bitmask redefined with a conflicting value", EX_DATAERR);
+	} else if (value != sym->info.finfo->value) {
+		stop("Field redefined with a conflicting value", EX_DATAERR);
 		/* NOTREACHED */
 	}
 	/* Fail if this symbol is already listed */
-	if (symlist_search(&(sym->info.minfo->symrefs),
+	if (symlist_search(&(sym->info.finfo->symrefs),
 			   cur_symbol->name) != NULL) {
-		stop("Bitmask defined multiple times for register", EX_DATAERR);
+		stop("Field defined multiple times for register", EX_DATAERR);
 		/* NOTREACHED */
 	}
-	symlist_add(&(sym->info.minfo->symrefs), cur_symbol,
+	symlist_add(&(sym->info.finfo->symrefs), cur_symbol,
 		    SYMLIST_INSERT_HEAD);
-	cur_symbol->info.rinfo->valid_bitmask |= mask;
+	cur_symbol->info.rinfo->valid_bitmask |= sym->info.finfo->mask;
 	cur_symbol->info.rinfo->typecheck_masks = TRUE;
+	symlist_add(&(cur_symbol->info.rinfo->fields), sym, SYMLIST_SORT);
 }
 
 static void
 initialize_symbol(symbol_t *symbol)
 {
 	switch (symbol->type) {
-        case UNINITIALIZED:
+	case UNINITIALIZED:
 		stop("Call to initialize_symbol with type field unset",
 		     EX_SOFTWARE);
 		/* NOTREACHED */
 		break;
-        case REGISTER:
-        case SRAMLOC:
-        case SCBLOC:
+	case REGISTER:
+	case SRAMLOC:
+	case SCBLOC:
 		symbol->info.rinfo =
 		    (struct reg_info *)malloc(sizeof(struct reg_info));
 		if (symbol->info.rinfo == NULL) {
@@ -1356,6 +1446,7 @@ initialize_symbol(symbol_t *symbol)
 		}
 		memset(symbol->info.rinfo, 0,
 		       sizeof(struct reg_info));
+		SLIST_INIT(&(symbol->info.rinfo->fields));
 		/*
 		 * Default to allowing access in all register modes
 		 * or to the mode specified by the SCB or SRAM space
@@ -1367,7 +1458,7 @@ initialize_symbol(symbol_t *symbol)
 		else
 			symbol->info.rinfo->modes = ~0;
 		break;
-        case ALIAS:
+	case ALIAS:
 		symbol->info.ainfo =
 		    (struct alias_info *)malloc(sizeof(struct alias_info));
 		if (symbol->info.ainfo == NULL) {
@@ -1377,19 +1468,21 @@ initialize_symbol(symbol_t *symbol)
 		memset(symbol->info.ainfo, 0,
 		       sizeof(struct alias_info));
 		break;
-        case MASK:
-        case BIT:
-		symbol->info.minfo =
-		    (struct mask_info *)malloc(sizeof(struct mask_info));
-		if (symbol->info.minfo == NULL) {
-			stop("Can't create bitmask info", EX_SOFTWARE);
+	case MASK:
+	case FIELD:
+	case ENUM:
+	case ENUM_ENTRY:
+		symbol->info.finfo =
+		    (struct field_info *)malloc(sizeof(struct field_info));
+		if (symbol->info.finfo == NULL) {
+			stop("Can't create field info", EX_SOFTWARE);
 			/* NOTREACHED */
 		}
-		memset(symbol->info.minfo, 0, sizeof(struct mask_info));
-		SLIST_INIT(&(symbol->info.minfo->symrefs));
+		memset(symbol->info.finfo, 0, sizeof(struct field_info));
+		SLIST_INIT(&(symbol->info.finfo->symrefs));
 		break;
-        case CONST:
-        case DOWNLOAD_CONST:
+	case CONST:
+	case DOWNLOAD_CONST:
 		symbol->info.cinfo =
 		    (struct const_info *)malloc(sizeof(struct const_info));
 		if (symbol->info.cinfo == NULL) {
@@ -1571,7 +1664,6 @@ format_1_instr(int opcode, symbol_ref_t *dest, expression_t *immed,
 		case AIC_OP_OR:
 			dst_value = src_value | immed->value;
 			break;
-			break;
 		case AIC_OP_BMOV:
 			dst_value = src_value;
 			break;
@@ -1580,9 +1672,9 @@ format_1_instr(int opcode, symbol_ref_t *dest, expression_t *immed,
 		}
 		src_mode = dst_value & 0xF;
 		dst_mode = (dst_value >> 4) & 0xF;
-cant_update:
 	}
 
+cant_update:
 	symlist_free(&immed->referenced_syms);
 	instruction_ptr++;
 }
@@ -1752,14 +1844,18 @@ type_check(symbol_t *symbol, expression_t *expression, int opcode)
 	 * Now make sure that all of the symbols referenced by the
 	 * expression are defined for this register.
 	 */
-	if(symbol->info.rinfo->typecheck_masks != FALSE) {
-		SLIST_FOREACH(node, &expression->referenced_syms, links) {
+	if (symbol->info.rinfo->typecheck_masks != FALSE) {
+		for(node = expression->referenced_syms.slh_first;
+		    node != NULL;
+		    node = node->links.sle_next) {
 			if ((node->symbol->type == MASK
-			  || node->symbol->type == BIT)
-			 && symlist_search(&node->symbol->info.minfo->symrefs,
+			  || node->symbol->type == FIELD
+			  || node->symbol->type == ENUM
+			  || node->symbol->type == ENUM_ENTRY)
+			 && symlist_search(&node->symbol->info.finfo->symrefs,
 					   symbol->name) == NULL) {
 				snprintf(errbuf, sizeof(errbuf),
-					 "Invalid bit or mask %s "
+					 "Invalid field or mask %s "
 					 "for register %s",
 					 node->symbol->name, symbol->name);
 				stop(errbuf, EX_DATAERR);
@@ -1816,18 +1912,21 @@ add_conditional(symbol_t *symbol)
 static void
 add_version(const char *verstring)
 {
-        const char prefix[] = " * ";
-        int newlen;
-        int oldlen;
-
-        newlen = strlen(verstring) + strlen(prefix);
-        oldlen = 0;
-        if (versions != NULL)
-                oldlen = strlen(versions);
-        versions = realloc(versions, newlen + oldlen + 2);
-        if (versions == NULL)
-                stop("Can't allocate version string", EX_SOFTWARE);
-	snprintf(&versions[oldlen], newlen + 2, "%s%s\n", prefix, verstring);
+	const char prefix[] = " * ";
+	int newlen;
+	int oldlen;
+
+	newlen = strlen(verstring) + strlen(prefix);
+	oldlen = 0;
+	if (versions != NULL)
+		oldlen = strlen(versions);
+	versions = realloc(versions, newlen + oldlen + 2);
+	if (versions == NULL)
+		stop("Can't allocate version string", EX_SOFTWARE);
+	strcpy(&versions[oldlen], prefix);
+	strcpy(&versions[oldlen + strlen(prefix)], verstring);
+	versions[newlen + oldlen] = '\n';
+	versions[newlen + oldlen + 1] = '\0';
 }
 
 void
@@ -1839,10 +1938,9 @@ yyerror(const char *string)
 static int
 is_download_const(expression_t *immed)
 {
-	if (SLIST_EMPTY(&immed->referenced_syms))
-		return (FALSE);
-	if (SLIST_FIRST(&immed->referenced_syms)->symbol->type ==
-	    DOWNLOAD_CONST)
+	if ((immed->referenced_syms.slh_first != NULL)
+	 && (immed->referenced_syms.slh_first->symbol->type == DOWNLOAD_CONST))
 		return (TRUE);
+
 	return (FALSE);
 }
diff --git a/sys/dev/microcode/aic7xxx/aicasm_insformat.h b/sys/dev/microcode/aic7xxx/aicasm_insformat.h
index 20371ef3ed4..62d738c055d 100644
--- a/sys/dev/microcode/aic7xxx/aicasm_insformat.h
+++ b/sys/dev/microcode/aic7xxx/aicasm_insformat.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: aicasm_insformat.h,v 1.3 2003/12/24 23:15:00 krw Exp $	*/
+/*	$OpenBSD: aicasm_insformat.h,v 1.4 2003/12/24 23:27:55 krw Exp $	*/
 /*	$NetBSD: aicasm_insformat.h,v 1.1 2003/04/19 19:26:11 fvdl Exp $	*/
 
 /*
diff --git a/sys/dev/microcode/aic7xxx/aicasm_macro_gram.y b/sys/dev/microcode/aic7xxx/aicasm_macro_gram.y
index be2e87c7983..04883dddd13 100644
--- a/sys/dev/microcode/aic7xxx/aicasm_macro_gram.y
+++ b/sys/dev/microcode/aic7xxx/aicasm_macro_gram.y
@@ -1,4 +1,7 @@
 %{
+/*	$OpenBSD: aicasm_macro_gram.y,v 1.2 2003/12/24 23:27:55 krw Exp $	*/
+/*	$NetBSD: aicasm_macro_gram.y,v 1.1 2003/04/19 19:26:11 fvdl Exp $	*/
+
 /*
  * Sub-parser for macro invocation in the Aic7xxx SCSI
  * Host adapter sequencer assembler.
@@ -38,9 +41,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: aicasm_macro_gram.y,v 1.1 2002/06/30 18:25:58 smurph Exp $
- *
- * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_macro_gram.y,v 1.1 2002/04/24 16:24:43 gibbs Exp $
+ * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_macro_gram.y,v 1.2 2002/08/31 06:39:40 gibbs Exp $
  */
 
 #include <sys/types.h>
@@ -52,11 +53,15 @@
 #include <string.h>
 #include <sysexits.h>
 
+#ifdef __linux__
+#include "../queue.h"
+#else
 #include <sys/queue.h>
+#endif
 
 #include "aicasm.h"
 #include "aicasm_symbol.h"
-#include "sequencer.h"
+#include "aicasm_insformat.h"
 
 static symbol_t *macro_symbol;
 
diff --git a/sys/dev/microcode/aic7xxx/aicasm_macro_scan.l b/sys/dev/microcode/aic7xxx/aicasm_macro_scan.l
index 6495fa73f48..a38ba14c0f4 100644
--- a/sys/dev/microcode/aic7xxx/aicasm_macro_scan.l
+++ b/sys/dev/microcode/aic7xxx/aicasm_macro_scan.l
@@ -1,4 +1,7 @@
 %{
+/*	$OpenBSD: aicasm_macro_scan.l,v 1.2 2003/12/24 23:27:55 krw Exp $	*/
+/*	$NetBSD: aicasm_macro_scan.l,v 1.1 2003/04/19 19:26:11 fvdl Exp $	*/
+
 /*
  * Sub-Lexical Analyzer for macro invokation in 
  * the Aic7xxx SCSI Host adapter sequencer assembler.
@@ -38,19 +41,22 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: aicasm_macro_scan.l,v 1.1 2002/06/30 18:25:58 smurph Exp $
- *
- * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_macro_scan.l,v 1.1 2002/04/24 16:24:43 gibbs Exp $
+ * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_macro_scan.l,v 1.4 2002/09/27 03:23:02 gibbs Exp $
  */
 
 #include <sys/types.h>
 
+#include <inttypes.h>
 #include <limits.h>
 #include <regex.h>
 #include <stdio.h>
 #include <string.h>
 #include <sysexits.h>
+#ifdef __linux__
+#include "../queue.h"
+#else
 #include <sys/queue.h>
+#endif
 
 #include "aicasm.h"
 #include "aicasm_symbol.h"
@@ -105,7 +111,7 @@ MCARG		[^(), \t]+
 <ARGLIST>{MCARG}	{
 				char *yptr;
 
-				yptr = mmtext;
+				yptr = yytext;
 				while (*yptr)
 					*string_buf_ptr++ = *yptr++;
 			}
@@ -126,7 +132,7 @@ MCARG		[^(), \t]+
 			}
 {WORD}[(]		{
 				/* May be a symbol or a macro invocation. */
-				mmlval.sym = symtable_get(mmtext);
+				mmlval.sym = symtable_get(yytext);
 				if (mmlval.sym->type != MACRO) {
 					stop("Expecting Macro Name",
 					     EX_DATAERR);
@@ -138,7 +144,7 @@ MCARG		[^(), \t]+
 			}
 .			{ 
 				snprintf(buf, sizeof(buf), "Invalid character "
-					 "'%c'", mmtext[0]);
+					 "'%c'", yytext[0]);
 				stop(buf, EX_DATAERR);
 			}
 %%
diff --git a/sys/dev/microcode/aic7xxx/aicasm_scan.l b/sys/dev/microcode/aic7xxx/aicasm_scan.l
index 7accfd699f7..0b84aceda95 100644
--- a/sys/dev/microcode/aic7xxx/aicasm_scan.l
+++ b/sys/dev/microcode/aic7xxx/aicasm_scan.l
@@ -1,9 +1,11 @@
 %{
+/*	$OpenBSD: aicasm_scan.l,v 1.7 2003/12/24 23:27:55 krw Exp $	*/
+/*	$NetBSD: aicasm_scan.l,v 1.3 2003/04/19 19:26:11 fvdl Exp $	*/
 /*
  * Lexical Analyzer for the Aic7xxx SCSI Host adapter sequencer assembler.
  *
  * Copyright (c) 1997, 1998, 2000 Justin T. Gibbs.
- * Copyright (c) 2001 Adaptec Inc.
+ * Copyright (c) 2001, 2002 Adaptec Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -38,17 +40,22 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_scan.l,v 1.18 2002/06/05 22:51:54 gibbs Exp $
+ * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_scan.l,v 1.21 2002/09/27 03:23:02 gibbs Exp $
  */
 
 #include <sys/types.h>
 
+#include <inttypes.h>
 #include <limits.h>
 #include <regex.h>
 #include <stdio.h>
 #include <string.h>
 #include <sysexits.h>
+#ifdef __linux__
+#include "../queue.h"
+#else
 #include <sys/queue.h>
+#endif
 
 #include "aicasm.h"
 #include "aicasm_symbol.h"
@@ -107,44 +114,45 @@ if[ \t]*\(		{
 				}
 			}
 <CEXPR>\n		{ ++yylineno; }
-<CEXPR>[^()\n]+		{
-                                char *yptr;
-
-                                yptr = yytext;
-                                while (*yptr != '\0') {
-                                        /* Remove duplicate spaces */
-                                        if (*yptr == '\t')
-                                                *yptr = ' ';
-                                        if (*yptr == ' '
-                                         && string_buf_ptr != string_buf
-                                         && string_buf_ptr[-1] == ' ')
-                                                yptr++;
-                                        else 
-					*string_buf_ptr++ = *yptr++;
-                                }
-                        }
+<CEXPR>[^()\n]+	{
+				char *yptr;
+
+				yptr = yytext;
+				while (*yptr != '\0') {
+					/* Remove duplicate spaces */
+					if (*yptr == '\t')
+						*yptr = ' ';
+					if (*yptr == ' '
+					 && string_buf_ptr != string_buf
+					 && string_buf_ptr[-1] == ' ')
+						yptr++;
+					else 
+						*string_buf_ptr++ = *yptr++;
+				}
+			}
 
-VERSION                 { return T_VERSION; }
+VERSION			{ return T_VERSION; }
+PREFIX			{ return T_PREFIX; }
 PATCH_ARG_LIST		{ return T_PATCH_ARG_LIST; }
-\"                      {
-                                string_buf_ptr = string_buf;
-                                BEGIN STRING;
+\"			{
+				string_buf_ptr = string_buf;
+				BEGIN STRING;
+			}
+<STRING>[^"]+		{
+				char *yptr;
+
+				yptr = yytext;
+				while (*yptr)
+					*string_buf_ptr++ = *yptr++;
+			}
+<STRING>\"		{
+				/* All done */
+				BEGIN INITIAL;
+				*string_buf_ptr = '\0';
+				yylval.str = string_buf;
+				return T_STRING;
 			}
-<STRING>[^"]+           {
-                                char *yptr;
-
-                                yptr = yytext;
-                                while (*yptr)
-                                        *string_buf_ptr++ = *yptr++;
-                        }
-<STRING>\"              {
-                                /* All done */
-                                BEGIN INITIAL;
-                                *string_buf_ptr = '\0';
-                                yylval.str = string_buf;
-                                return T_STRING;
-                        }
-{SPACE}			;
+{SPACE}			 ;
 
 	/* Register/SCB/SRAM definition keywords */
 export			{ return T_EXPORT; }
@@ -163,11 +171,12 @@ RW|RO|WO		{
 					yylval.value = WO;
 				 return T_MODE;
 			}
-BEGIN_CRITICAL          { return T_BEGIN_CS; }
-END_CRITICAL            { return T_END_CS; }
+BEGIN_CRITICAL		{ return T_BEGIN_CS; }
+END_CRITICAL		{ return T_END_CS; }
 SET_SRC_MODE		{ return T_SET_SRC_MODE; }
 SET_DST_MODE		{ return T_SET_DST_MODE; }
-bit			{ return T_BIT; }
+field			{ return T_FIELD; }
+enum			{ return T_ENUM; }
 mask			{ return T_MASK; }
 alias			{ return T_ALIAS; }
 size			{ return T_SIZE; }
@@ -205,7 +214,7 @@ dec			{ return T_DEC; }
 stc			{ return T_STC;	}
 clc			{ return T_CLC; }
 cmp			{ return T_CMP;	}
-not                     { return T_NOT; }
+not			{ return T_NOT;	}
 xor			{ return T_XOR;	}
 test			{ return T_TEST;}
 and			{ return T_AND;	}
@@ -235,30 +244,30 @@ else			{ return T_ELSE; }
 				return T_NUMBER;
 			}
 	/* Include Files */
-#include{SPACE}         {
-                                BEGIN INCLUDE;
-                                quote_count = 0;
-                                return T_INCLUDE;
-                        }
-<INCLUDE>[<]            { return yytext[0]; }
-<INCLUDE>[>]            { BEGIN INITIAL; return yytext[0]; }
-<INCLUDE>[\"]           {
-                                if (quote_count != 0)
-                                        BEGIN INITIAL;
-                                quote_count++;
-                                return yytext[0];
-                        }
+#include{SPACE}		{
+				BEGIN INCLUDE;
+				quote_count = 0;
+				return T_INCLUDE;
+			}
+<INCLUDE>[<]		{ return yytext[0]; }
+<INCLUDE>[>]		{ BEGIN INITIAL; return yytext[0]; }
+<INCLUDE>[\"]		{
+				if (quote_count != 0)
+					BEGIN INITIAL;
+				quote_count++;
+				return yytext[0];
+			}
 <INCLUDE>{PATH}		{
-                                char *yptr;
-
-                                yptr = yytext;
-                                string_buf_ptr = string_buf;
-                                while (*yptr)
-                                        *string_buf_ptr++ = *yptr++;
-                                yylval.str = string_buf;
-                                *string_buf_ptr = '\0';
-                                return T_PATH;
-                        }
+				char *yptr;
+
+				yptr = yytext;
+				string_buf_ptr = string_buf;
+				while (*yptr)
+					*string_buf_ptr++ = *yptr++;
+				yylval.str = string_buf;
+				*string_buf_ptr = '\0';
+				return T_PATH;
+			}
 <INCLUDE>.		{ stop("Invalid include line", EX_DATAERR); }
 #define{SPACE}		{
 				BEGIN MACRODEF;
@@ -439,7 +448,9 @@ include_file(char *file_name, include_type type)
 
 	if (newfile == NULL && type != SOURCE_FILE) {
                 path_entry_t include_dir;
-		SLIST_FOREACH(include_dir, &search_path, links) {
+                for (include_dir = search_path.slh_first;
+                     include_dir != NULL;                
+                     include_dir = include_dir->links.sle_next) {
 			char fullname[PATH_MAX];
 
 			if ((include_dir->quoted_includes_only == TRUE)
@@ -573,8 +584,8 @@ yywrap()
 	if (yyfilename != NULL)
 		free(yyfilename);
 	yyfilename = NULL;
-	include = SLIST_FIRST(&include_stack);
-	if (include != SLIST_END(&include_stack)) {
+	include = include_stack.slh_first;
+	if (include != NULL) {
 		yy_switch_to_buffer(include->buffer);
 		yylineno = include->lineno;
 		yyfilename = include->filename;
diff --git a/sys/dev/microcode/aic7xxx/aicasm_symbol.c b/sys/dev/microcode/aic7xxx/aicasm_symbol.c
index 32d793b5ef8..4b8884b30e4 100644
--- a/sys/dev/microcode/aic7xxx/aicasm_symbol.c
+++ b/sys/dev/microcode/aic7xxx/aicasm_symbol.c
@@ -1,8 +1,11 @@
-/* $OpenBSD: aicasm_symbol.c,v 1.8 2003/10/20 17:22:13 deraadt Exp $ */
+/* $OpenBSD: aicasm_symbol.c,v 1.9 2003/12/24 23:27:55 krw Exp $ */
+/*	$NetBSD: aicasm_symbol.c,v 1.4 2003/07/14 15:42:40 lukem Exp $	*/
+
 /*
  * Aic7xxx SCSI host adapter firmware asssembler symbol table implementation
  *
  * Copyright (c) 1997 Justin T. Gibbs.
+ * Copyright (c) 2002 Adaptec Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -37,13 +40,21 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_symbol.c,v 1.17 2002/06/06 16:07:18 gibbs Exp $
+ * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_symbol.c,v 1.23 2003/01/20 18:01:37 gibbs Exp $
  */
 
+#include <sys/cdefs.h>
+/* __RCSID("$NetBSD: aicasm_symbol.c,v 1.4 2003/07/14 15:42:40 lukem Exp $"); */
+
 #include <sys/types.h>
 
+#ifdef __linux__
+#include "aicdb.h"
+#else
 #include <db.h>
+#endif
 #include <fcntl.h>
+#include <inttypes.h>
 #include <regex.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -56,8 +67,7 @@
 static DB *symtable;
 
 symbol_t *
-symbol_create(name)
-	char *name;
+symbol_create(char *name)
 {
 	symbol_t *new_symbol;
 
@@ -67,15 +77,15 @@ symbol_create(name)
 		exit(EX_SOFTWARE);
 	}
 	memset(new_symbol, 0, sizeof(*new_symbol));
-	if ((new_symbol->name = strdup(name)) == NULL)
-		stop("strdup failed", EX_SOFTWARE);
+	new_symbol->name = strdup(name);
+	if (new_symbol->name == NULL)
+		 stop("Unable to strdup symbol name", EX_SOFTWARE);
 	new_symbol->type = UNINITIALIZED;
 	return (new_symbol);
 }
 
 void
-symbol_delete(symbol)
-	symbol_t *symbol;
+symbol_delete(symbol_t *symbol)
 {
 	if (symtable != NULL) {
 		DBT	 key;
@@ -96,10 +106,12 @@ symbol_delete(symbol)
 			free(symbol->info.ainfo);
 		break;
 	case MASK:
-	case BIT:
-		if (symbol->info.minfo != NULL) {
-			symlist_free(&symbol->info.minfo->symrefs);
-			free(symbol->info.minfo);
+	case FIELD:
+	case ENUM:
+	case ENUM_ENTRY:
+		if (symbol->info.finfo != NULL) {
+			symlist_free(&symbol->info.finfo->symrefs);
+			free(symbol->info.finfo);
 		}
 		break;
 	case DOWNLOAD_CONST:
@@ -155,8 +167,7 @@ symtable_close()
  * if a lookup fails.
  */
 symbol_t *
-symtable_get(name)
-	char *name;
+symtable_get(char *name)
 {
 	symbol_t *stored_ptr;
 	DBT	  key;
@@ -195,24 +206,21 @@ symtable_get(name)
 }
 
 symbol_node_t *
-symlist_search(symlist, symname)
-	symlist_t *symlist;
-	char	  *symname;
+symlist_search(symlist_t *symlist, char *symname)
 {
 	symbol_node_t *curnode;
 
-	SLIST_FOREACH(curnode, symlist, links) {
+	curnode = SLIST_FIRST(symlist);
+	while(curnode != NULL) {
 		if (strcmp(symname, curnode->symbol->name) == 0)
 			break;
+		curnode = SLIST_NEXT(curnode, links);
 	}
 	return (curnode);
 }
 
 void
-symlist_add(symlist, symbol, how)
-	symlist_t *symlist;
-	symbol_t  *symbol;
-	int	  how;
+symlist_add(symlist_t *symlist, symbol_t *symbol, int how)
 {
 	symbol_node_t *newnode;
 
@@ -224,17 +232,19 @@ symlist_add(symlist, symbol, how)
 	newnode->symbol = symbol;
 	if (how == SYMLIST_SORT) {
 		symbol_node_t *curnode;
-		int mask;
+		int field;
 
-		mask = FALSE;
+		field = FALSE;
 		switch(symbol->type) {
 		case REGISTER:
 		case SCBLOC:
 		case SRAMLOC:
 			break;
-		case BIT:
+		case FIELD:
 		case MASK:
-			mask = TRUE;
+		case ENUM:
+		case ENUM_ENTRY:
+			field = TRUE;
 			break;
 		default:
 			stop("symlist_add: Invalid symbol type for sorting",
@@ -244,16 +254,19 @@ symlist_add(symlist, symbol, how)
 
 		curnode = SLIST_FIRST(symlist);
 		if (curnode == NULL
-		 || (mask && (curnode->symbol->info.minfo->mask >
-		              newnode->symbol->info.minfo->mask))
-		 || (!mask && (curnode->symbol->info.rinfo->address >
+		 || (field
+		  && (curnode->symbol->type > newnode->symbol->type
+		   || (curnode->symbol->type == newnode->symbol->type
+		    && (curnode->symbol->info.finfo->value >
+			newnode->symbol->info.finfo->value))))
+		 || (!field && (curnode->symbol->info.rinfo->address >
 		               newnode->symbol->info.rinfo->address))) {
 			SLIST_INSERT_HEAD(symlist, newnode, links);
 			return;
 		}
 
 		while (1) {
-			if (SLIST_NEXT(curnode, links) == SLIST_END(symlist)) {
+			if (SLIST_NEXT(curnode, links) == NULL) {
 				SLIST_INSERT_AFTER(curnode, newnode,
 						   links);
 				break;
@@ -261,10 +274,14 @@ symlist_add(symlist, symbol, how)
 				symbol_t *cursymbol;
 
 				cursymbol = SLIST_NEXT(curnode, links)->symbol;
-				if ((mask && (cursymbol->info.minfo->mask >
-				              symbol->info.minfo->mask))
-				 || (!mask &&(cursymbol->info.rinfo->address >
-				              symbol->info.rinfo->address))){
+				if ((field
+		  		  && (cursymbol->type > symbol->type
+				   || (cursymbol->type == symbol->type
+				    && (cursymbol->info.finfo->value >
+					symbol->info.finfo->value))))
+				 || (!field
+				   && (cursymbol->info.rinfo->address >
+				       symbol->info.rinfo->address))) {
 					SLIST_INSERT_AFTER(curnode, newnode,
 							   links);
 					break;
@@ -278,23 +295,22 @@ symlist_add(symlist, symbol, how)
 }
 
 void
-symlist_free(symlist)
-	symlist_t *symlist;
+symlist_free(symlist_t *symlist)
 {
-	symbol_node_t *node;
+	symbol_node_t *node1, *node2;
 
-	while (!SLIST_EMPTY(symlist)) {
-		node = SLIST_FIRST(symlist);
-		SLIST_REMOVE_HEAD(symlist, links);
-		free(node);
+	node1 = SLIST_FIRST(symlist);
+	while (node1 != NULL) {
+		node2 = SLIST_NEXT(node1, links);
+		free(node1);
+		node1 = node2;
 	}
+	SLIST_INIT(symlist);
 }
 
 void
-symlist_merge(symlist_dest, symlist_src1, symlist_src2)
-	symlist_t *symlist_dest;
-	symlist_t *symlist_src1;
-	symlist_t *symlist_src2;
+symlist_merge(symlist_t *symlist_dest, symlist_t *symlist_src1,
+	      symlist_t *symlist_src2)
 {
 	symbol_node_t *node;
 
@@ -310,21 +326,160 @@ symlist_merge(symlist_dest, symlist_src1, symlist_src2)
 }
 
 void
-symtable_dump(ofile)
-	FILE *ofile;
+aic_print_file_prologue(FILE *ofile)
+{
+
+	if (ofile == NULL)
+		return;
+
+	fprintf(ofile,
+"/*\n"
+" * DO NOT EDIT - This file is automatically generated\n"
+" *		 from the following source files:\n"
+" *\n"
+"%s */\n",
+		versions);
+}
+
+void
+aic_print_include(FILE *dfile, char *include_file)
+{
+
+	if (dfile == NULL)
+		return;
+	fprintf(dfile, "\n#include \"%s\"\n\n", include_file);
+}
+
+void
+aic_print_reg_dump_types(FILE *ofile)
+{
+	if (ofile == NULL)
+		return;
+		
+	fprintf(ofile,
+"typedef int (%sreg_print_t)(u_int, u_int *, u_int);\n"
+"typedef struct %sreg_parse_entry {\n"
+"	char	*name;\n"
+"	uint8_t	 value;\n"
+"	uint8_t	 mask;\n"
+"} %sreg_parse_entry_t;\n"
+"\n",
+		prefix, prefix, prefix);
+}
+
+static void
+aic_print_reg_dump_start(FILE *dfile, symbol_node_t *regnode)
+{
+	if (dfile == NULL)
+		return;
+
+	fprintf(dfile,
+"static %sreg_parse_entry_t %s_parse_table[] = {\n",
+		prefix,
+		regnode->symbol->name);
+}
+
+static void
+aic_print_reg_dump_end(FILE *ofile, FILE *dfile,
+		       symbol_node_t *regnode, u_int num_entries)
+{
+	char *lower_name;
+	char *letter;
+
+	lower_name = strdup(regnode->symbol->name);
+	if (lower_name == NULL)
+		 stop("Unable to strdup symbol name", EX_SOFTWARE);
+	
+	for (letter = lower_name; *letter != '\0'; letter++)
+		*letter = tolower(*letter);
+
+	if (dfile != NULL) {
+		if (num_entries != 0)
+			fprintf(dfile,
+"\n"
+"};\n"
+"\n");
+
+		fprintf(dfile,
+"int\n"
+"%s%s_print(u_int regvalue, u_int *cur_col, u_int wrap)\n"
+"{\n"
+"	return (%sprint_register(%s%s, %d, \"%s\",\n"
+"	    0x%02x, regvalue, cur_col, wrap));\n"
+"}\n"
+"\n",
+			prefix,
+			lower_name,
+			prefix,
+			num_entries != 0 ? regnode->symbol->name : "NULL",
+			num_entries != 0 ? "_parse_table" : "",
+			num_entries,
+			regnode->symbol->name,
+			regnode->symbol->info.rinfo->address);
+	}
+
+	fprintf(ofile,
+"#if AIC_DEBUG_REGISTERS\n"
+"%sreg_print_t %s%s_print;\n"
+"#else\n"
+"#define %s%s_print(regvalue, cur_col, wrap) \\\n"
+"    %sprint_register(NULL, 0, \"%s\", 0x%02x, regvalue, cur_col, wrap)\n"
+"#endif\n"
+"\n",
+		prefix,
+		prefix,
+		lower_name,
+		prefix,
+		lower_name,
+		prefix,
+		regnode->symbol->name,
+		regnode->symbol->info.rinfo->address);
+}
+
+static void
+aic_print_reg_dump_entry(FILE *dfile, symbol_node_t *curnode)
+{
+	int num_tabs;
+
+	if (dfile == NULL)
+		return;
+
+	fprintf(dfile,
+"	{ \"%s\",",
+		curnode->symbol->name);
+
+	num_tabs = 3 - (strlen(curnode->symbol->name) + 5) / 8;
+
+	while (num_tabs-- > 0)
+		fputc('\t', dfile);
+	fprintf(dfile, "0x%02x, 0x%02x }",
+		curnode->symbol->info.finfo->value,
+		curnode->symbol->info.finfo->mask);
+}
+
+void
+symtable_dump(FILE *ofile, FILE *dfile)
 {
 	/*
 	 * Sort the registers by address with a simple insertion sort.
 	 * Put bitmasks next to the first register that defines them.
 	 * Put constants at the end.
 	 */
-	symlist_t registers;
-	symlist_t masks;
-	symlist_t constants;
-	symlist_t download_constants;
-	symlist_t aliases;
-	symlist_t exported_labels;
-	u_int	  i;
+	symlist_t	 registers;
+	symlist_t	 masks;
+	symlist_t	 constants;
+	symlist_t	 download_constants;
+	symlist_t	 aliases;
+	symlist_t	 exported_labels;
+	symbol_node_t	*curnode;
+	symbol_node_t	*regnode;
+	DBT		 key;
+	DBT		 data;
+	int		 flag;
+	u_int		 i;
+
+	if (symtable == NULL)
+		return;
 
 	SLIST_INIT(&registers);
 	SLIST_INIT(&masks);
@@ -332,174 +487,195 @@ symtable_dump(ofile)
 	SLIST_INIT(&download_constants);
 	SLIST_INIT(&aliases);
 	SLIST_INIT(&exported_labels);
+	flag = R_FIRST;
+	while (symtable->seq(symtable, &key, &data, flag) == 0) {
+		symbol_t *cursym;
 
-	if (symtable != NULL) {
-		DBT	 key;
-		DBT	 data;
-		int	 flag = R_FIRST;
+		memcpy(&cursym, data.data, sizeof(cursym));
+		switch(cursym->type) {
+		case REGISTER:
+		case SCBLOC:
+		case SRAMLOC:
+			symlist_add(&registers, cursym, SYMLIST_SORT);
+			break;
+		case MASK:
+		case FIELD:
+		case ENUM:
+		case ENUM_ENTRY:
+			symlist_add(&masks, cursym, SYMLIST_SORT);
+			break;
+		case CONST:
+			symlist_add(&constants, cursym,
+				    SYMLIST_INSERT_HEAD);
+			break;
+		case DOWNLOAD_CONST:
+			symlist_add(&download_constants, cursym,
+				    SYMLIST_INSERT_HEAD);
+			break;
+		case ALIAS:
+			symlist_add(&aliases, cursym,
+				    SYMLIST_INSERT_HEAD);
+			break;
+		case LABEL:
+			if (cursym->info.linfo->exported == 0)
+				break;
+			symlist_add(&exported_labels, cursym,
+				    SYMLIST_INSERT_HEAD);
+			break;
+		default:
+			break;
+		}
+		flag = R_NEXT;
+	}
 
-		while (symtable->seq(symtable, &key, &data, flag) == 0) {
-			symbol_t *cursym;
+	/* Register dianostic functions/declarations first. */
+	aic_print_file_prologue(ofile);
+	aic_print_reg_dump_types(ofile);
+	aic_print_file_prologue(dfile);
+	aic_print_include(dfile, stock_include_file);
+	SLIST_FOREACH(curnode, &registers, links) {
 
-			memcpy(&cursym, data.data, sizeof(cursym));
-			switch(cursym->type) {
-			case REGISTER:
-			case SCBLOC:
-			case SRAMLOC:
-				symlist_add(&registers, cursym, SYMLIST_SORT);
-				break;
-			case MASK:
-			case BIT:
-				symlist_add(&masks, cursym, SYMLIST_SORT);
-				break;
-			case CONST:
-				symlist_add(&constants, cursym,
-						    SYMLIST_INSERT_HEAD);
-				break;
-			case DOWNLOAD_CONST:
-				symlist_add(&download_constants, cursym,
-					    SYMLIST_INSERT_HEAD);
-				break;
-			case ALIAS:
-				symlist_add(&aliases, cursym,
-					    SYMLIST_INSERT_HEAD);
-				break;
-			case LABEL:
-				if (cursym->info.linfo->exported == 0)
-					break;
-				symlist_add(&exported_labels, cursym,
-					    SYMLIST_INSERT_HEAD);
-				break;
-			default:
-				break;
+		switch(curnode->symbol->type) {
+		case REGISTER:
+		case SCBLOC:
+		case SRAMLOC:
+		{
+			symlist_t	*fields;
+			symbol_node_t	*fieldnode;
+			int		 num_entries;
+
+			num_entries = 0;
+			fields = &curnode->symbol->info.rinfo->fields;
+			SLIST_FOREACH(fieldnode, fields, links) {
+				if (num_entries == 0)
+					aic_print_reg_dump_start(dfile,
+								 curnode);
+				else if (dfile != NULL)
+					fputs(",\n", dfile);
+				num_entries++;
+				aic_print_reg_dump_entry(dfile, fieldnode);
 			}
-			flag = R_NEXT;
+			aic_print_reg_dump_end(ofile, dfile,
+					       curnode, num_entries);
 		}
+		default:
+			break;
+		}
+	}
 
-		/* Put in the masks and bits */
-		while (SLIST_FIRST(&masks) != SLIST_END(&masks)) {
-			symbol_node_t *curnode;
-			symbol_node_t *regnode;
-			char *regname;
+	/* Fold in the masks and bits */
+	while (SLIST_FIRST(&masks) != NULL) {
+		char *regname;
 
-			curnode = SLIST_FIRST(&masks);
-			SLIST_REMOVE_HEAD(&masks, links);
+		curnode = SLIST_FIRST(&masks);
+		SLIST_REMOVE_HEAD(&masks, links);
 
-			regnode =
-			    SLIST_FIRST(&curnode->symbol->info.minfo->symrefs);
-			regname = regnode->symbol->name;
-			regnode = symlist_search(&registers, regname);
-			SLIST_INSERT_AFTER(regnode, curnode, links);
-		}
+		regnode = SLIST_FIRST(&curnode->symbol->info.finfo->symrefs);
+		regname = regnode->symbol->name;
+		regnode = symlist_search(&registers, regname);
+		SLIST_INSERT_AFTER(regnode, curnode, links);
+	}
 
-		/* Add the aliases */
-		while (SLIST_FIRST(&aliases) != SLIST_END(&aliases)) {
-			symbol_node_t *curnode;
-			symbol_node_t *regnode;
-			char *regname;
+	/* Add the aliases */
+	while (SLIST_FIRST(&aliases) != NULL) {
+		char *regname;
 
-			curnode = SLIST_FIRST(&aliases);
-			SLIST_REMOVE_HEAD(&aliases, links);
+		curnode = SLIST_FIRST(&aliases);
+		SLIST_REMOVE_HEAD(&aliases, links);
 
-			regname = curnode->symbol->info.ainfo->parent->name;
-			regnode = symlist_search(&registers, regname);
-			SLIST_INSERT_AFTER(regnode, curnode, links);
-		}
+		regname = curnode->symbol->info.ainfo->parent->name;
+		regnode = symlist_search(&registers, regname);
+		SLIST_INSERT_AFTER(regnode, curnode, links);
+	}
 
-		/* Output what we have */
-		fprintf(ofile,
-"/*\n"
-" * DO NOT EDIT - This file is automatically generated\n"
-" *		 from the following source files:\n"
-" *\n"
-"%s */\n", versions);
-                while (SLIST_FIRST(&registers) != SLIST_END(&registers)) {
-			symbol_node_t *curnode;
-			u_int value;
-			char *tab_str;
-			char *tab_str2;
-
-			curnode = SLIST_FIRST(&registers);
-			SLIST_REMOVE_HEAD(&registers, links);
-			switch(curnode->symbol->type) {
-			case REGISTER:
-			case SCBLOC:
-			case SRAMLOC:
-				fprintf(ofile, "\n");
-				value = curnode->symbol->info.rinfo->address;
-				tab_str = "\t";
-				tab_str2 = "\t\t";
-				break;
-			case ALIAS:
-			{
-				symbol_t *parent;
-
-				parent = curnode->symbol->info.ainfo->parent;
-				value = parent->info.rinfo->address;
-				tab_str = "\t";
-				tab_str2 = "\t\t";
-				break;
-			}
-			case MASK:
-			case BIT:
-				value = curnode->symbol->info.minfo->mask;
-				tab_str = "\t\t";
-				tab_str2 = "\t";
-				break;
-			default:
-				value = 0; /* Quiet compiler */
-				tab_str = NULL;
-				tab_str2 = NULL;
-				stop("symtable_dump: Invalid symbol type "
-				     "encountered", EX_SOFTWARE);
-				break;
-			}
-			fprintf(ofile, "#define%s%-16s%s0x%02x\n",
-				tab_str, curnode->symbol->name, tab_str2,
-				value);
-			free(curnode);
+	/* Output generated #defines. */
+	while (SLIST_FIRST(&registers) != NULL) {
+		symbol_node_t *curnode;
+		u_int value;
+		char *tab_str;
+		char *tab_str2;
+
+		curnode = SLIST_FIRST(&registers);
+		SLIST_REMOVE_HEAD(&registers, links);
+		switch(curnode->symbol->type) {
+		case REGISTER:
+		case SCBLOC:
+		case SRAMLOC:
+			fprintf(ofile, "\n");
+			value = curnode->symbol->info.rinfo->address;
+			tab_str = "\t";
+			tab_str2 = "\t\t";
+			break;
+		case ALIAS:
+		{
+			symbol_t *parent;
+
+			parent = curnode->symbol->info.ainfo->parent;
+			value = parent->info.rinfo->address;
+			tab_str = "\t";
+			tab_str2 = "\t\t";
+			break;
 		}
-		fprintf(ofile, "\n\n");
+		case MASK:
+		case FIELD:
+		case ENUM:
+		case ENUM_ENTRY:
+			value = curnode->symbol->info.finfo->value;
+			tab_str = "\t\t";
+			tab_str2 = "\t";
+			break;
+		default:
+			value = 0; /* Quiet compiler */
+			tab_str = NULL;
+			tab_str2 = NULL;
+			stop("symtable_dump: Invalid symbol type "
+			     "encountered", EX_SOFTWARE);
+			break;
+		}
+		fprintf(ofile, "#define%s%-16s%s0x%02x\n",
+			tab_str, curnode->symbol->name, tab_str2,
+			value);
+		free(curnode);
+	}
+	fprintf(ofile, "\n\n");
 
-		while (SLIST_FIRST(&constants) != SLIST_END(&constants)) {
-			symbol_node_t *curnode;
+	while (SLIST_FIRST(&constants) != NULL) {
+		symbol_node_t *curnode;
 
-			curnode = SLIST_FIRST(&constants);
-			SLIST_REMOVE_HEAD(&constants, links);
-			fprintf(ofile, "#define\t%-8s\t0x%02x\n",
-				curnode->symbol->name,
-				curnode->symbol->info.cinfo->value);
-			free(curnode);
-		}
+		curnode = SLIST_FIRST(&constants);
+		SLIST_REMOVE_HEAD(&constants, links);
+		fprintf(ofile, "#define\t%-8s\t0x%02x\n",
+			curnode->symbol->name,
+			curnode->symbol->info.cinfo->value);
+		free(curnode);
+	}
 
-		
-		fprintf(ofile, "\n\n/* Downloaded Constant Definitions */\n");
+	
+	fprintf(ofile, "\n\n/* Downloaded Constant Definitions */\n");
 
-		for (i = 0; SLIST_FIRST(&download_constants) != NULL; i++) {
-			symbol_node_t *curnode;
+	for (i = 0; SLIST_FIRST(&download_constants) != NULL; i++) {
+		symbol_node_t *curnode;
 
-			curnode = SLIST_FIRST(&download_constants);
-			SLIST_REMOVE_HEAD(&download_constants, links);
-			fprintf(ofile, "#define\t%-8s\t0x%02x\n",
-				curnode->symbol->name,
-				curnode->symbol->info.cinfo->value);
-			free(curnode);
-		}
-		fprintf(ofile, "#define\tDOWNLOAD_CONST_COUNT\t0x%02x\n", i);
+		curnode = SLIST_FIRST(&download_constants);
+		SLIST_REMOVE_HEAD(&download_constants, links);
+		fprintf(ofile, "#define\t%-8s\t0x%02x\n",
+			curnode->symbol->name,
+			curnode->symbol->info.cinfo->value);
+		free(curnode);
+	}
+	fprintf(ofile, "#define\tDOWNLOAD_CONST_COUNT\t0x%02x\n", i);
 
-		fprintf(ofile, "\n\n/* Exported Labels */\n");
+	fprintf(ofile, "\n\n/* Exported Labels */\n");
 
-		while (SLIST_FIRST(&exported_labels) !=
-		    SLIST_END(&exported_labels)) {
-			symbol_node_t *curnode;
+	while (SLIST_FIRST(&exported_labels) != NULL) {
+		symbol_node_t *curnode;
 
-			curnode = SLIST_FIRST(&exported_labels);
-			SLIST_REMOVE_HEAD(&exported_labels, links);
-			fprintf(ofile, "#define\tLABEL_%-8s\t0x%02x\n",
-				curnode->symbol->name,
-				curnode->symbol->info.linfo->address);
-			free(curnode);
-		}
+		curnode = SLIST_FIRST(&exported_labels);
+		SLIST_REMOVE_HEAD(&exported_labels, links);
+		fprintf(ofile, "#define\tLABEL_%-8s\t0x%02x\n",
+			curnode->symbol->name,
+			curnode->symbol->info.linfo->address);
+		free(curnode);
 	}
 }
 
diff --git a/sys/dev/microcode/aic7xxx/aicasm_symbol.h b/sys/dev/microcode/aic7xxx/aicasm_symbol.h
index 08f2acb2102..5eb293f56a6 100644
--- a/sys/dev/microcode/aic7xxx/aicasm_symbol.h
+++ b/sys/dev/microcode/aic7xxx/aicasm_symbol.h
@@ -1,8 +1,11 @@
-/* $OpenBSD: aicasm_symbol.h,v 1.7 2002/06/30 18:25:58 smurph Exp $ */
+/* $OpenBSD: aicasm_symbol.h,v 1.8 2003/12/24 23:27:55 krw Exp $ */
+/*	$NetBSD: aicasm_symbol.h,v 1.2 2003/04/19 19:26:11 fvdl Exp $	*/
+
 /*
  * Aic7xxx SCSI host adapter firmware asssembler symbol table definitions
  *
  * Copyright (c) 1997 Justin T. Gibbs.
+ * Copyright (c) 2002 Adaptec Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -37,10 +40,14 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_symbol.h,v 1.15 2002/06/05 22:51:54 gibbs Exp $
+ * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_symbol.h,v 1.16 2002/08/31 06:39:41 gibbs Exp $
  */
 
+#ifdef __linux__
+#include "../queue.h"
+#else
 #include <sys/queue.h>
+#endif
 
 typedef enum {
 	UNINITIALIZED,
@@ -48,14 +55,16 @@ typedef enum {
 	ALIAS,
 	SCBLOC,
 	SRAMLOC,
+	ENUM_ENTRY,
+	FIELD,
 	MASK,
-	BIT,
+	ENUM,
 	CONST,
 	DOWNLOAD_CONST,
 	LABEL,
 	CONDITIONAL,
 	MACRO
-}symtype;
+} symtype;
 
 typedef enum {
 	RO = 0x01,
@@ -63,25 +72,27 @@ typedef enum {
 	RW = 0x03
 }amode_t;
 
+typedef SLIST_HEAD(symlist, symbol_node) symlist_t;
+
 struct reg_info {
-	u_int	 address;
-	int	 size;
-	amode_t	 mode;
-	u_int8_t valid_bitmask;
-	u_int8_t modes;
-	int	 typecheck_masks;
+	u_int	  address;
+	int	  size;
+	amode_t	  mode;
+	symlist_t fields;
+	uint8_t	  valid_bitmask;
+	uint8_t	  modes;
+	int	  typecheck_masks;
 };
 
-typedef SLIST_HEAD(symlist, symbol_node) symlist_t;
-
-struct mask_info {
+struct field_info {
 	symlist_t symrefs;
-	u_int8_t mask;
+	uint8_t	  value;
+	uint8_t	  mask;
 };
 
 struct const_info {
 	u_int	value;
-	int	 define;
+	int	define;
 };
 
 struct alias_info {
@@ -119,12 +130,12 @@ typedef struct symbol {
 	char	*name;
 	symtype	type;
 	union	{
-		struct reg_info *rinfo;
-		struct mask_info *minfo;
+		struct reg_info	  *rinfo;
+		struct field_info *finfo;
 		struct const_info *cinfo;
 		struct alias_info *ainfo;
 		struct label_info *linfo;
-		struct cond_info *condinfo;
+		struct cond_info  *condinfo;
 		struct macro_info *macroinfo;
 	}info;
 } symbol_t;
@@ -137,12 +148,12 @@ typedef struct symbol_ref {
 typedef struct symbol_node {
 	SLIST_ENTRY(symbol_node) links;
 	symbol_t *symbol;
-}symbol_node_t;
+} symbol_node_t;
 
 typedef struct critical_section {
-        TAILQ_ENTRY(critical_section) links;
-        int begin_addr;
-        int end_addr;
+	TAILQ_ENTRY(critical_section) links;
+	int begin_addr;
+	int end_addr;
 } critical_section_t;
 
 typedef enum {
@@ -193,5 +204,5 @@ void
 void	symlist_free(symlist_t *symlist);
 
 void	symlist_merge(symlist_t *symlist_dest, symlist_t *symlist_src1,
-	    symlist_t *symlist_src2);
-void	symtable_dump(FILE *ofile);
+		      symlist_t *symlist_src2);
+void	symtable_dump(FILE *ofile, FILE *dfile);