Aic7xxx Driver Update:

  o Determine more conclusively that a BIOS has initialized the
    adapter before using "left over BIOS settings".
  o Adapt to upcoming removal of cmd->target/channel/lun/host in 2.5.X
  o Fix a memory leak on driver unload.
  o Enable the pci_parity command line option and default to pci parity
    error detection *disabled*.  There are just too many broken VIA
    chipsets out there.
  o Move more functionality into aiclib to share with the aic79xx driver.
  o Correct a few negotiation regressions.
  o Don't bother doing full DV on devices that only support async transfers.
    This should fix a few more of the reported problems with DV.

Aic79xx Driver Update
  o Add abort and bus device reset handlers.
  o Fix a memory leak on driver unload.
  o Adapt to upcoming removal of cmd->target/channel/lun/host in 2.5.X.
  o Correct a few negotiation regressions.

drivers/scsi/aic7xxx/aic79xx_core.c

@@ -2,7 +2,7 @@
  * Core routines and tables shareable across OS platforms.
  *
  * Copyright (c) 1994-2002 Justin T. Gibbs.
- * Copyright (c) 2000-2002 Adaptec Inc.
+ * Copyright (c) 2000-2003 Adaptec Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -37,7 +37,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.c#151 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.c#153 $
  *
  * $FreeBSD$
  */
@@ -171,8 +171,8 @@ static void		ahd_handle_ign_wide_residue(struct ahd_softc *ahd,
 static void		ahd_reinitialize_dataptrs(struct ahd_softc *ahd);
 static void		ahd_handle_devreset(struct ahd_softc *ahd,
 					    struct ahd_devinfo *devinfo,
-					    cam_status status, char *message,
-					    int verbose_level);
+					    u_int lun, cam_status status,
+					    char *message, int verbose_level);
 #if AHD_TARGET_MODE
 static void		ahd_setup_target_msgin(struct ahd_softc *ahd,
 					       struct ahd_devinfo *devinfo,
@@ -688,8 +688,7 @@ ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat)
 							&tstate);
 			tinfo = &targ_info->curr;
 			ahd_set_width(ahd, &devinfo, MSG_EXT_WDTR_BUS_8_BIT,
-				      AHD_TRANS_ACTIVE|AHD_TRANS_GOAL,
-				      /*paused*/TRUE);
+				      AHD_TRANS_ACTIVE, /*paused*/TRUE);
 			ahd_set_syncrate(ahd, &devinfo, /*period*/0,
 					 /*offset*/0, /*ppr_options*/0,
 					 AHD_TRANS_ACTIVE, /*paused*/TRUE);
@@ -1016,6 +1015,9 @@ ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat)
 			u_int	   tag;
 			cam_status error;
 
+			ahd_print_path(ahd, scb);
+			printf("Task Management Func 0x%x Complete\n",
+			       scb->hscb->task_management);
 			lun = CAM_LUN_WILDCARD;
 			tag = SCB_LIST_NULL;
 
@@ -1026,18 +1028,30 @@ ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat)
 			case SIU_TASKMGMT_CLEAR_TASK_SET:
 				lun = scb->hscb->lun;
 				error = CAM_REQ_ABORTED;
+				ahd_abort_scbs(ahd, SCB_GET_TARGET(ahd, scb),
+					       'A', lun, tag, ROLE_INITIATOR,
+					       error);
 				break;
 			case SIU_TASKMGMT_LUN_RESET:
 				lun = scb->hscb->lun;
 			case SIU_TASKMGMT_TARGET_RESET:
+			{
+				struct ahd_devinfo devinfo;
+
+				ahd_scb_devinfo(ahd, &devinfo, scb);
 				error = CAM_BDR_SENT;
+				ahd_handle_devreset(ahd, &devinfo, lun,
+						    CAM_BDR_SENT,
+						    lun != CAM_LUN_WILDCARD
+						    ? "Lun Reset"
+						    : "Target Reset",
+						    /*verbose_level*/0);
 				break;
+			}
 			default:
 				panic("Unexpected TaskMgmt Func\n");
 				break;
 			}
-			ahd_abort_scbs(ahd, SCB_GET_TARGET(ahd, scb),
-				       'A', lun, tag, ROLE_INITIATOR, error);
 		}
 		break;
 	}
@@ -1046,6 +1060,10 @@ ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat)
 		u_int	scbid;
 		struct	scb *scb;
 
+		/*
+		 * An ABORT TASK TMF failed to be delivered before
+		 * the targeted command completed normally.
+		 */
 		scbid = ahd_get_scbptr(ahd);
 		scb = ahd_lookup_scb(ahd, scbid);
 		if (scb != NULL) {
@@ -1053,6 +1071,20 @@ ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat)
 			 * Remove the second instance of this SCB from
 			 * the QINFIFO if it is still there.
                          */
+			ahd_print_path(ahd, scb);
+			printf("SCB completes before TMF\n");
+			/*
+			 * Handle losing the race.  Wait until any
+			 * current selection completes.  We will then
+			 * set the TMF back to zero in this SCB so that
+			 * the sequencer doesn't bother to issue another
+			 * sequencer interrupt for its completion.
+			 */
+			while ((ahd_inb(ahd, SCSISEQ0) & ENSELO) != 0
+			    && (ahd_inb(ahd, SSTAT0) & SELDO) == 0
+			    && (ahd_inb(ahd, SSTAT1) & SELTO) == 0)
+				;
+			ahd_outb(ahd, SCB_TASK_MANAGEMENT, 0);
 			ahd_search_qinfifo(ahd, SCB_GET_TARGET(ahd, scb),
 					   SCB_GET_CHANNEL(ahd, scb),  
 					   SCB_GET_LUN(scb), scb->hscb->tag, 
@@ -1784,8 +1816,8 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
 					  ROLE_INITIATOR))
 				ahd_set_transaction_status(scb, CAM_REQ_CMP);
 #endif
-			ahd_handle_devreset(ahd, &devinfo, CAM_BDR_SENT,
-					    "Bus Device Reset",
+			ahd_handle_devreset(ahd, &devinfo, CAM_LUN_WILDCARD,
+					    CAM_BDR_SENT, "Bus Device Reset",
 					    /*verbose_level*/0);
 			printerror = 0;
 		} else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_PPR, FALSE)
@@ -3692,8 +3724,8 @@ ahd_sent_msg(struct ahd_softc *ahd, ahd_msgtype type, u_int msgval, int full)
 			if (type == AHDMSG_1B
 			 && ahd->msgout_index > index
 			 && (ahd->msgout_buf[index] == msgval
-			  || ((ahd->msgout_buf[index] & MSG_IDENTIFYFLAG) != 0))
-			   && msgval == MSG_IDENTIFYFLAG)
+			  || ((ahd->msgout_buf[index] & MSG_IDENTIFYFLAG) != 0
+			   && msgval == MSG_IDENTIFYFLAG)))
 				found = TRUE;
 			index++;
 		}
@@ -4039,7 +4071,7 @@ ahd_parse_msg(struct ahd_softc *ahd, struct ahd_devinfo *devinfo)
 	}
 #ifdef AHD_TARGET_MODE
 	case MSG_BUS_DEV_RESET:
-		ahd_handle_devreset(ahd, devinfo,
+		ahd_handle_devreset(ahd, devinfo, CAM_LUN_WILDCARD,
 				    CAM_BDR_SENT,
 				    "Bus Device Reset Received",
 				    /*verbose_level*/0);
@@ -4538,16 +4570,16 @@ ahd_reinitialize_dataptrs(struct ahd_softc *ahd)
  */
 static void
 ahd_handle_devreset(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
-		    cam_status status, char *message, int verbose_level)
+		    u_int lun, cam_status status, char *message,
+		    int verbose_level)
 {
 #ifdef AHD_TARGET_MODE
 	struct ahd_tmode_tstate* tstate;
-	u_int lun;
 #endif
 	int found;
 
 	found = ahd_abort_scbs(ahd, devinfo->target, devinfo->channel,
-			       CAM_LUN_WILDCARD, SCB_LIST_NULL, devinfo->role,
+			       lun, SCB_LIST_NULL, devinfo->role,
 			       status);
 
 #ifdef AHD_TARGET_MODE
@@ -4557,10 +4589,20 @@ ahd_handle_devreset(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
 	 */
 	tstate = ahd->enabled_targets[devinfo->our_scsiid];
 	if (tstate != NULL) {
-		for (lun = 0; lun < AHD_NUM_LUNS; lun++) {
+		u_int cur_lun;
+		u_int max_lun;
+
+		if (lun != CAM_LUN_WILDCARD) {
+			cur_lun = 0;
+			max_lun = AHD_NUM_LUNS - 1;
+		} else {
+			cur_lun = lun;
+			max_lun = lun;
+		}
+		for (cur_lun <= max_lun; cur_lun++) {
 			struct ahd_tmode_lstate* lstate;
 
-			lstate = tstate->enabled_luns[lun];
+			lstate = tstate->enabled_luns[cur_lun];
 			if (lstate == NULL)
 				continue;
 
@@ -4580,7 +4622,7 @@ ahd_handle_devreset(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
 			 /*ppr_options*/0, AHD_TRANS_CUR, /*paused*/TRUE);
 	
 	ahd_send_async(ahd, devinfo->channel, devinfo->target,
-		       CAM_LUN_WILDCARD, AC_SENT_BDR, NULL);
+		       lun, AC_SENT_BDR, NULL);
 
 	if (message != NULL
 	 && (verbose_level <= bootverbose))

drivers/scsi/aic7xxx/aic79xx_inline.h

@@ -2,7 +2,7 @@
  * Inline routines shareable across OS platforms.
  *
  * Copyright (c) 1994-2001 Justin T. Gibbs.
- * Copyright (c) 2000-2002 Adaptec Inc.
+ * Copyright (c) 2000-2003 Adaptec Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -37,7 +37,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx_inline.h#40 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx_inline.h#41 $
  *
  * $FreeBSD$
  */
@@ -272,7 +272,6 @@ ahd_setup_scb_common(struct ahd_softc *ahd, struct scb *scb)
 	if ((scb->flags & SCB_PACKETIZED) != 0) {
 		/* XXX what about ACA??  It is type 4, but TAG_TYPE == 0x3. */
 		scb->hscb->task_attribute= scb->hscb->control & SCB_TAG_TYPE;
-		scb->hscb->task_management = 0;
 		/*
 		 * For Rev A short lun workaround.
 		 */

drivers/scsi/aic7xxx/aic79xx_osm.h

@@ -36,7 +36,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic79xx_osm.h#102 $
+ * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic79xx_osm.h#106 $
  *
  */
 #ifndef _AIC79XX_LINUX_H_
@@ -55,6 +55,7 @@
 #endif
 #include <linux/module.h>
 #include <asm/byteorder.h>
+#include <asm/io.h>
 
 #ifndef KERNEL_VERSION
 #define KERNEL_VERSION(x,y,z) (((x)<<16)+((y)<<8)+(z))
@@ -72,7 +73,6 @@
 #define AIC_LIB_PREFIX ahd
 #include "scsi.h"
 #include "hosts.h"
-#include "aiclib.h"
 
 /* Name space conflict with BSD queue macros */
 #ifdef LIST_HEAD
@@ -83,6 +83,7 @@
 #include "queue.h"
 #include "scsi_message.h"
 #include "scsi_iu.h"
+#include "aiclib.h"
 
 /*********************************** Debugging ********************************/
 #ifdef CONFIG_AIC79XX_DEBUG_ENABLE
@@ -288,7 +289,7 @@ ahd_scb_timer_reset(struct scb *scb, u_int usec)
 #include <linux/smp.h>
 #endif
 
-#define AIC79XX_DRIVER_VERSION "1.3.0.BETA2"
+#define AIC79XX_DRIVER_VERSION "1.3.0.RC1"
 
 /**************************** Front End Queues ********************************/
 /*
@@ -489,7 +490,7 @@ struct ahd_linux_target {
  * Per-SCB OSM storage.
  */
 typedef enum {
-	AHD_UP_EH_SEMAPHORE
+	AHD_UP_EH_SEMAPHORE = 0x1
 } ahd_linux_scb_flags;
 
 struct scb_platform_data {
@@ -543,6 +544,7 @@ struct ahd_platform_data {
 	struct semaphore	 dv_cmd_sem;	/* XXX This needs to be in
 						 * the target struct
 						 */
+	struct scsi_device	*dv_scsi_dev;
 	struct Scsi_Host        *host;		/* pointer to scsi host */
 #define AHD_LINUX_NOIRQ	((uint32_t)~0)
 	uint32_t		 irq;		/* IRQ for this adapter */

drivers/scsi/aic7xxx/aic79xx_reg.h_shipped

@@ -2,8 +2,8 @@
  * DO NOT EDIT - This file is automatically generated
  *		 from the following source files:
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#77 $
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#59 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#78 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#60 $
  */
 typedef int (ahd_reg_print_t)(u_int, u_int *, u_int);
 typedef struct ahd_reg_parse_entry {
@@ -2367,11 +2367,13 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define		SPLTINT         	0x01
 
 #define	SEQINTCODE      		0x02
-#define		SAW_HWERR       	0x17
-#define		TRACEPOINT3     	0x16
-#define		TRACEPOINT2     	0x15
-#define		TRACEPOINT1     	0x14
-#define		TRACEPOINT0     	0x13
+#define		SAW_HWERR       	0x19
+#define		TRACEPOINT3     	0x18
+#define		TRACEPOINT2     	0x17
+#define		TRACEPOINT1     	0x16
+#define		TRACEPOINT0     	0x15
+#define		TASKMGMT_CMD_CMPLT_OKAY	0x14
+#define		TASKMGMT_FUNC_COMPLETE	0x13
 #define		ENTERING_NONPACK	0x12
 #define		CFG4OVERRUN     	0x11
 #define		STATUS_OVERRUN  	0x10
@@ -3772,5 +3774,5 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 
 /* Exported Labels */
-#define	LABEL_seq_isr 	0x25a
-#define	LABEL_timer_isr	0x256
+#define	LABEL_seq_isr 	0x263
+#define	LABEL_timer_isr	0x25f

drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped

@@ -2,8 +2,8 @@
  * DO NOT EDIT - This file is automatically generated
  *		 from the following source files:
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#77 $
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#59 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#78 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#60 $
  */
 
 #include "aic79xx_osm.h"
@@ -59,17 +59,19 @@ static ahd_reg_parse_entry_t SEQINTCODE_parse_table[] = {
 	{ "STATUS_OVERRUN",	0x10, 0xff },
 	{ "CFG4OVERRUN",	0x11, 0xff },
 	{ "ENTERING_NONPACK",	0x12, 0xff },
-	{ "TRACEPOINT0",	0x13, 0xff },
-	{ "TRACEPOINT1",	0x14, 0xff },
-	{ "TRACEPOINT2",	0x15, 0xff },
-	{ "TRACEPOINT3",	0x16, 0xff },
-	{ "SAW_HWERR",		0x17, 0xff }
+	{ "TASKMGMT_FUNC_COMPLETE",0x13, 0xff },
+	{ "TASKMGMT_CMD_CMPLT_OKAY",0x14, 0xff },
+	{ "TRACEPOINT0",	0x15, 0xff },
+	{ "TRACEPOINT1",	0x16, 0xff },
+	{ "TRACEPOINT2",	0x17, 0xff },
+	{ "TRACEPOINT3",	0x18, 0xff },
+	{ "SAW_HWERR",		0x19, 0xff }
 };
 
 int
 ahd_seqintcode_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-	return (ahd_print_register(SEQINTCODE_parse_table, 24, "SEQINTCODE",
+	return (ahd_print_register(SEQINTCODE_parse_table, 26, "SEQINTCODE",
 	    0x02, regvalue, cur_col, wrap));
 }
 

drivers/scsi/aic7xxx/aic79xx_seq.h_shipped

@@ -2,92 +2,97 @@
  * DO NOT EDIT - This file is automatically generated
  *		 from the following source files:
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#77 $
- * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#59 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#78 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#60 $
  */
 static uint8_t seqprog[] = {
 	0xff, 0x02, 0x06, 0x78,
-	0x00, 0xea, 0x3c, 0x59,
+	0x00, 0xea, 0x46, 0x59,
 	0x01, 0xea, 0x04, 0x30,
 	0xff, 0x04, 0x0c, 0x78,
-	0x17, 0xea, 0x3c, 0x59,
-	0x17, 0xea, 0x04, 0x00,
-	0x33, 0xea, 0x30, 0x59,
+	0x19, 0xea, 0x46, 0x59,
+	0x19, 0xea, 0x04, 0x00,
+	0x33, 0xea, 0x3a, 0x59,
 	0x33, 0xea, 0x00, 0x00,
 	0x60, 0x3a, 0x1a, 0x68,
 	0x04, 0x47, 0x1b, 0x68,
 	0xff, 0x21, 0x1b, 0x70,
-	0x40, 0x4b, 0x7e, 0x69,
-	0x00, 0xe2, 0x40, 0x59,
-	0x40, 0x4b, 0x7e, 0x69,
-	0x20, 0x4b, 0x6e, 0x69,
+	0x40, 0x4b, 0x88, 0x69,
+	0x00, 0xe2, 0x4a, 0x59,
+	0x40, 0x4b, 0x88, 0x69,
+	0x20, 0x4b, 0x78, 0x69,
 	0xfc, 0x42, 0x24, 0x78,
 	0x10, 0x40, 0x24, 0x78,
-	0x00, 0xe2, 0x8c, 0x5d,
+	0x00, 0xe2, 0xa4, 0x5d,
 	0x20, 0x4d, 0x28, 0x78,
-	0x00, 0xe2, 0x8c, 0x5d,
+	0x00, 0xe2, 0xa4, 0x5d,
 	0x00, 0xe2, 0x34, 0x58,
-	0x00, 0xe2, 0x5c, 0x58,
-	0x00, 0xe2, 0x6c, 0x58,
+	0x00, 0xe2, 0x66, 0x58,
+	0x00, 0xe2, 0x76, 0x58,
 	0x00, 0xe2, 0x06, 0x40,
-	0x33, 0xea, 0x30, 0x59,
+	0x33, 0xea, 0x3a, 0x59,
 	0x33, 0xea, 0x00, 0x00,
-	0x01, 0x52, 0x4e, 0x7d,
+	0x01, 0x52, 0x66, 0x7d,
 	0x02, 0x58, 0x50, 0x31,
 	0xff, 0xea, 0x10, 0x0b,
+	0xff, 0x93, 0x45, 0x78,
+	0x50, 0x4b, 0x40, 0x68,
+	0xbf, 0x3a, 0x74, 0x08,
+	0x14, 0xea, 0x46, 0x59,
+	0x14, 0xea, 0x04, 0x00,
 	0x08, 0xa8, 0x51, 0x03,
-	0x01, 0xa4, 0x43, 0x78,
-	0x00, 0xe2, 0x32, 0x5b,
+	0x01, 0xa4, 0x4d, 0x78,
+	0x00, 0xe2, 0x44, 0x5b,
 	0x00, 0xe2, 0x34, 0x40,
 	0xff, 0xea, 0xd4, 0x19,
 	0x02, 0xa8, 0x84, 0x32,
-	0x00, 0xea, 0x30, 0x59,
+	0x00, 0xea, 0x3a, 0x59,
 	0x01, 0xea, 0x00, 0x30,
-	0x00, 0xe2, 0x80, 0x5d,
-	0x00, 0xe2, 0x4e, 0x4d,
-	0x11, 0xea, 0x30, 0x59,
+	0x00, 0xe2, 0x98, 0x5d,
+	0x00, 0xe2, 0x66, 0x4d,
+	0x11, 0xea, 0x3a, 0x59,
 	0x11, 0xea, 0x00, 0x00,
-	0x00, 0xe2, 0x80, 0x5d,
-	0x00, 0xe2, 0x4e, 0x4d,
-	0x33, 0xea, 0x30, 0x59,
+	0x00, 0xe2, 0x98, 0x5d,
+	0x00, 0xe2, 0x66, 0x4d,
+	0x33, 0xea, 0x3a, 0x59,
 	0x33, 0xea, 0x00, 0x00,
-	0x00, 0xe2, 0x28, 0x43,
-	0x00, 0xea, 0x30, 0x59,
+	0x00, 0xe2, 0x3a, 0x43,
+	0x00, 0xea, 0x3a, 0x59,
 	0x01, 0xea, 0x00, 0x30,
-	0x80, 0xf9, 0x64, 0x68,
-	0x00, 0xe2, 0x2e, 0x59,
-	0x11, 0xea, 0x30, 0x59,
+	0x80, 0xf9, 0x6e, 0x68,
+	0x00, 0xe2, 0x38, 0x59,
+	0x11, 0xea, 0x3a, 0x59,
 	0x11, 0xea, 0x00, 0x00,
-	0x80, 0xf9, 0x2e, 0x79,
+	0x80, 0xf9, 0x38, 0x79,
 	0xff, 0xea, 0xd4, 0x0d,
-	0x22, 0xea, 0x30, 0x59,
+	0x22, 0xea, 0x3a, 0x59,
 	0x22, 0xea, 0x00, 0x00,
-	0x10, 0x16, 0x76, 0x78,
+	0x10, 0x16, 0x80, 0x78,
 	0x01, 0x0b, 0xa2, 0x32,
 	0x10, 0x16, 0x2c, 0x00,
-	0x18, 0xad, 0xe4, 0x78,
-	0x04, 0xad, 0xb2, 0x68,
-	0x80, 0xad, 0x4e, 0x7d,
-	0x10, 0xad, 0x80, 0x78,
+	0x18, 0xad, 0xee, 0x78,
+	0x04, 0xad, 0xbc, 0x68,
+	0x80, 0xad, 0x66, 0x7d,
+	0x10, 0xad, 0x8a, 0x78,
 	0xe7, 0xad, 0x5a, 0x0d,
 	0xe7, 0xad, 0x5a, 0x09,
-	0x00, 0xe2, 0x8e, 0x58,
+	0x00, 0xe2, 0x98, 0x58,
 	0xff, 0xea, 0x56, 0x02,
 	0x04, 0x7c, 0x78, 0x32,
-	0x20, 0x16, 0x4e, 0x7d,
+	0x20, 0x16, 0x66, 0x7d,
 	0x04, 0x38, 0x79, 0x32,
 	0x80, 0x37, 0x6f, 0x16,
-	0xff, 0x2d, 0x9d, 0x60,
-	0xff, 0x29, 0x9d, 0x60,
-	0x40, 0x51, 0xad, 0x78,
-	0xff, 0x4f, 0x9d, 0x68,
+	0xff, 0x2d, 0xa7, 0x60,
+	0xff, 0x29, 0xa7, 0x60,
+	0x40, 0x51, 0xb7, 0x78,
+	0xff, 0x4f, 0xa7, 0x68,
 	0xff, 0x4d, 0xc1, 0x19,
 	0x00, 0x4e, 0xd5, 0x19,
-	0x00, 0xe2, 0xac, 0x50,
+	0x00, 0xe2, 0xb6, 0x50,
 	0x01, 0x4c, 0xc1, 0x31,
 	0x00, 0x50, 0xd5, 0x19,
-	0x00, 0xe2, 0xac, 0x48,
-	0x80, 0x18, 0x4e, 0x7d,
+	0x00, 0xe2, 0xb6, 0x48,
+	0x80, 0x18, 0x66, 0x7d,
 	0x02, 0x4a, 0x1d, 0x30,
 	0x10, 0xea, 0x18, 0x00,
 	0x60, 0x18, 0x30, 0x00,
@@ -95,7 +100,7 @@ static uint8_t seqprog[] = {
 	0x02, 0xea, 0x02, 0x00,
 	0xff, 0xea, 0xa0, 0x0a,
 	0x80, 0x18, 0x30, 0x04,
-	0x40, 0xad, 0x4e, 0x7d,
+	0x40, 0xad, 0x66, 0x7d,
 	0xe7, 0xad, 0x5a, 0x09,
 	0x02, 0xa8, 0x40, 0x31,
 	0xff, 0xea, 0xc0, 0x09,
@@ -105,25 +110,25 @@ static uint8_t seqprog[] = {
 	0xff, 0xea, 0x2a, 0x03,
 	0xff, 0xea, 0x2e, 0x03,
 	0x01, 0x10, 0xd4, 0x31,
-	0x10, 0xa8, 0xd9, 0x68,
+	0x10, 0xa8, 0xe3, 0x68,
 	0x3d, 0xa9, 0xc5, 0x29,
 	0xfe, 0xe2, 0xc4, 0x09,
 	0x01, 0xea, 0xc6, 0x01,
 	0x02, 0xe2, 0xc8, 0x31,
 	0x02, 0xec, 0x50, 0x31,
 	0x02, 0xa0, 0xda, 0x31,
-	0xff, 0xa9, 0xd8, 0x70,
+	0xff, 0xa9, 0xe2, 0x70,
 	0x02, 0xa0, 0x28, 0x37,
-	0xff, 0x21, 0xe1, 0x70,
+	0xff, 0x21, 0xeb, 0x70,
 	0x02, 0x22, 0x51, 0x31,
 	0x02, 0xa0, 0x2c, 0x33,
 	0x02, 0xa0, 0x44, 0x36,
 	0x02, 0xa0, 0x40, 0x32,
 	0x02, 0xa0, 0x44, 0x36,
-	0x04, 0x47, 0xe9, 0x68,
-	0x40, 0x16, 0x14, 0x69,
-	0xff, 0x2d, 0x19, 0x61,
-	0xff, 0x29, 0x4f, 0x75,
+	0x04, 0x47, 0xf3, 0x68,
+	0x40, 0x16, 0x1e, 0x69,
+	0xff, 0x2d, 0x23, 0x61,
+	0xff, 0x29, 0x67, 0x75,
 	0x01, 0x37, 0xc1, 0x31,
 	0x02, 0x28, 0x55, 0x32,
 	0x01, 0xea, 0x5a, 0x01,
@@ -135,20 +140,20 @@ static uint8_t seqprog[] = {
 	0x01, 0x50, 0xa1, 0x1a,
 	0xff, 0x4e, 0x9d, 0x1a,
 	0xff, 0x4f, 0x9f, 0x22,
-	0xff, 0x8d, 0x0d, 0x71,
-	0x80, 0xac, 0x0c, 0x71,
-	0x20, 0x16, 0x0c, 0x69,
+	0xff, 0x8d, 0x17, 0x71,
+	0x80, 0xac, 0x16, 0x71,
+	0x20, 0x16, 0x16, 0x69,
 	0x02, 0x8c, 0x51, 0x31,
-	0x00, 0xe2, 0xf6, 0x40,
+	0x00, 0xe2, 0x00, 0x41,
 	0x01, 0xac, 0x08, 0x31,
 	0x09, 0xea, 0x5a, 0x01,
 	0x02, 0x8c, 0x51, 0x32,
 	0xff, 0xea, 0x1a, 0x07,
 	0x04, 0x24, 0xf9, 0x30,
-	0x1d, 0xea, 0x24, 0x41,
+	0x1d, 0xea, 0x2e, 0x41,
 	0x02, 0x2c, 0x51, 0x31,
 	0x04, 0xac, 0xf9, 0x30,
-	0x19, 0xea, 0x24, 0x59,
+	0x19, 0xea, 0x2e, 0x59,
 	0x02, 0x8c, 0x59, 0x32,
 	0x02, 0x28, 0x19, 0x33,
 	0x02, 0xa8, 0x50, 0x36,
@@ -170,23 +175,23 @@ static uint8_t seqprog[] = {
 	0x02, 0x20, 0xb9, 0x30,
 	0x02, 0x20, 0x51, 0x31,
 	0x4c, 0xa9, 0xd7, 0x28,
-	0x10, 0xa8, 0x4f, 0x79,
+	0x10, 0xa8, 0x59, 0x79,
 	0x01, 0x6b, 0xc0, 0x30,
 	0x02, 0x64, 0xc8, 0x00,
 	0x40, 0x3a, 0x74, 0x04,
-	0x00, 0xe2, 0x5c, 0x58,
-	0x33, 0xea, 0x30, 0x59,
+	0x00, 0xe2, 0x66, 0x58,
+	0x33, 0xea, 0x3a, 0x59,
 	0x33, 0xea, 0x00, 0x00,
 	0x30, 0x3f, 0xc0, 0x09,
-	0x30, 0xe0, 0x50, 0x61,
-	0x20, 0x3f, 0x66, 0x69,
-	0x10, 0x3f, 0x50, 0x79,
+	0x30, 0xe0, 0x5a, 0x61,
+	0x20, 0x3f, 0x70, 0x69,
+	0x10, 0x3f, 0x5a, 0x79,
 	0x02, 0xea, 0x7e, 0x00,
-	0x00, 0xea, 0x30, 0x59,
+	0x00, 0xea, 0x3a, 0x59,
 	0x01, 0xea, 0x00, 0x30,
 	0x02, 0x48, 0x51, 0x35,
 	0x01, 0xea, 0x7e, 0x00,
-	0x11, 0xea, 0x30, 0x59,
+	0x11, 0xea, 0x3a, 0x59,
 	0x11, 0xea, 0x00, 0x00,
 	0x02, 0x48, 0x51, 0x35,
 	0x08, 0xea, 0x98, 0x00,
@@ -196,11 +201,11 @@ static uint8_t seqprog[] = {
 	0x0f, 0x67, 0xc0, 0x09,
 	0x00, 0x34, 0x69, 0x02,
 	0x20, 0xea, 0x96, 0x00,
-	0x00, 0xe2, 0xdc, 0x41,
-	0x40, 0x3a, 0x9a, 0x69,
+	0x00, 0xe2, 0xee, 0x41,
+	0x40, 0x3a, 0xa4, 0x69,
 	0x02, 0x55, 0x06, 0x68,
-	0x02, 0x56, 0x9a, 0x69,
-	0xff, 0x5b, 0x9a, 0x61,
+	0x02, 0x56, 0xa4, 0x69,
+	0xff, 0x5b, 0xa4, 0x61,
 	0x02, 0x20, 0x51, 0x31,
 	0x80, 0xea, 0xb2, 0x01,
 	0x44, 0xea, 0x00, 0x00,
@@ -208,140 +213,144 @@ static uint8_t seqprog[] = {
 	0x33, 0xea, 0x00, 0x00,
 	0xff, 0xea, 0xb2, 0x09,
 	0xff, 0xe0, 0xc0, 0x19,
-	0xff, 0xe0, 0x9c, 0x79,
+	0xff, 0xe0, 0xa6, 0x79,
 	0x02, 0x94, 0x51, 0x31,
-	0x00, 0xe2, 0x92, 0x41,
+	0x00, 0xe2, 0x9c, 0x41,
 	0x02, 0x5e, 0x50, 0x31,
 	0x02, 0xa8, 0xb8, 0x30,
 	0x02, 0x5c, 0x50, 0x31,
-	0xff, 0x95, 0xad, 0x71,
+	0xff, 0x95, 0xb7, 0x71,
 	0x02, 0x94, 0x41, 0x31,
 	0x02, 0x22, 0x51, 0x31,
 	0x02, 0xa0, 0x2c, 0x33,
 	0x02, 0xa0, 0x44, 0x32,
-	0x00, 0xe2, 0xb6, 0x41,
-	0x10, 0xa8, 0xb7, 0x69,
+	0x00, 0xe2, 0xc0, 0x41,
+	0x10, 0xa8, 0xc1, 0x69,
 	0x3d, 0xa9, 0xc9, 0x29,
 	0x01, 0xe4, 0xc8, 0x01,
 	0x01, 0xea, 0xca, 0x01,
 	0xff, 0xea, 0xda, 0x01,
 	0x02, 0x20, 0x51, 0x31,
 	0x02, 0x96, 0x41, 0x32,
-	0xff, 0x21, 0xbf, 0x61,
+	0xff, 0x21, 0xc9, 0x61,
 	0xff, 0xea, 0x46, 0x02,
 	0x02, 0x5c, 0x50, 0x31,
 	0x40, 0xea, 0x96, 0x00,
-	0x02, 0x56, 0x94, 0x6d,
-	0x01, 0x55, 0x94, 0x6d,
-	0x10, 0xa8, 0xcb, 0x79,
-	0x10, 0x40, 0xcc, 0x69,
-	0x01, 0x56, 0x06, 0x68,
+	0x02, 0x56, 0xac, 0x6d,
+	0x01, 0x55, 0xac, 0x6d,
+	0x10, 0xa8, 0xd5, 0x79,
+	0x10, 0x40, 0xde, 0x69,
+	0x01, 0x56, 0xde, 0x79,
+	0xff, 0x93, 0x07, 0x78,
+	0x13, 0xea, 0x46, 0x59,
+	0x13, 0xea, 0x04, 0x00,
+	0x00, 0xe2, 0x06, 0x40,
 	0xbf, 0x3a, 0x74, 0x08,
 	0x08, 0xea, 0x98, 0x00,
 	0x08, 0x57, 0xae, 0x00,
 	0x01, 0xa9, 0x69, 0x32,
 	0x01, 0xaa, 0x6b, 0x32,
+	0x40, 0xea, 0x66, 0x02,
 	0x08, 0x3c, 0x78, 0x00,
 	0x80, 0xea, 0x62, 0x02,
-	0x40, 0xea, 0x66, 0x02,
-	0x00, 0xe2, 0x92, 0x5b,
+	0x00, 0xe2, 0xa4, 0x5b,
 	0x01, 0x36, 0xc1, 0x31,
-	0x9f, 0xe0, 0x26, 0x7c,
-	0x80, 0xe0, 0xf0, 0x71,
-	0xa0, 0xe0, 0x28, 0x72,
-	0xc0, 0xe0, 0x1e, 0x72,
-	0xe0, 0xe0, 0x58, 0x72,
-	0x01, 0xea, 0x3c, 0x59,
+	0x9f, 0xe0, 0x38, 0x7c,
+	0x80, 0xe0, 0x02, 0x72,
+	0xa0, 0xe0, 0x3a, 0x72,
+	0xc0, 0xe0, 0x30, 0x72,
+	0xe0, 0xe0, 0x6a, 0x72,
+	0x01, 0xea, 0x46, 0x59,
 	0x01, 0xea, 0x04, 0x00,
-	0x00, 0xe2, 0xdc, 0x41,
-	0x80, 0x33, 0xf7, 0x79,
-	0x03, 0xea, 0x3c, 0x59,
+	0x00, 0xe2, 0xee, 0x41,
+	0x80, 0x33, 0x09, 0x7a,
+	0x03, 0xea, 0x46, 0x59,
 	0x03, 0xea, 0x04, 0x00,
-	0xee, 0x00, 0xfe, 0x69,
+	0xee, 0x00, 0x10, 0x6a,
 	0x05, 0xea, 0xb4, 0x00,
-	0x33, 0xea, 0x30, 0x59,
+	0x33, 0xea, 0x3a, 0x59,
 	0x33, 0xea, 0x00, 0x00,
 	0x02, 0xa8, 0x90, 0x32,
-	0x00, 0xe2, 0x56, 0x59,
+	0x00, 0xe2, 0x60, 0x59,
 	0xef, 0x92, 0xd5, 0x19,
-	0x00, 0xe2, 0x0e, 0x52,
+	0x00, 0xe2, 0x20, 0x52,
 	0x0b, 0x84, 0xe1, 0x30,
 	0x02, 0xea, 0x36, 0x00,
 	0xa8, 0xea, 0x32, 0x00,
-	0x00, 0xe2, 0x14, 0x42,
+	0x00, 0xe2, 0x26, 0x42,
 	0x01, 0x92, 0xd1, 0x30,
 	0x10, 0x80, 0x89, 0x31,
 	0x20, 0xea, 0x32, 0x00,
 	0xbf, 0x33, 0x67, 0x0a,
-	0x20, 0x19, 0x16, 0x6a,
-	0x02, 0x4d, 0xdc, 0x69,
+	0x20, 0x19, 0x28, 0x6a,
+	0x02, 0x4d, 0xee, 0x69,
 	0x40, 0x33, 0x67, 0x02,
-	0x00, 0xe2, 0xdc, 0x41,
-	0x80, 0x33, 0x95, 0x6a,
+	0x00, 0xe2, 0xee, 0x41,
+	0x80, 0x33, 0xa7, 0x6a,
 	0x01, 0x44, 0x10, 0x33,
 	0x08, 0xa8, 0x51, 0x03,
-	0x00, 0xe2, 0xdc, 0x41,
+	0x00, 0xe2, 0xee, 0x41,
 	0x10, 0xea, 0x80, 0x00,
 	0x01, 0x31, 0xc5, 0x31,
-	0x80, 0xe2, 0x44, 0x62,
-	0x10, 0xa8, 0x69, 0x6a,
+	0x80, 0xe2, 0x56, 0x62,
+	0x10, 0xa8, 0x7b, 0x6a,
 	0xc0, 0xaa, 0xc5, 0x01,
-	0x40, 0xa8, 0x35, 0x6a,
+	0x40, 0xa8, 0x47, 0x6a,
 	0xbf, 0xe2, 0xc4, 0x09,
-	0x20, 0xa8, 0x49, 0x7a,
+	0x20, 0xa8, 0x5b, 0x7a,
 	0x01, 0xe2, 0x88, 0x30,
-	0x00, 0xe2, 0x92, 0x5b,
-	0xa0, 0x36, 0x51, 0x62,
+	0x00, 0xe2, 0xa4, 0x5b,
+	0xa0, 0x36, 0x63, 0x62,
 	0x23, 0xa8, 0x89, 0x08,
-	0x00, 0xe2, 0x92, 0x5b,
-	0xa0, 0x36, 0x51, 0x62,
-	0x00, 0xa8, 0x48, 0x42,
-	0xff, 0xe2, 0x48, 0x62,
-	0x00, 0xe2, 0x68, 0x42,
+	0x00, 0xe2, 0xa4, 0x5b,
+	0xa0, 0x36, 0x63, 0x62,
+	0x00, 0xa8, 0x5a, 0x42,
+	0xff, 0xe2, 0x5a, 0x62,
+	0x00, 0xe2, 0x7a, 0x42,
 	0x40, 0xea, 0x98, 0x00,
 	0x01, 0xe2, 0x88, 0x30,
-	0x00, 0xe2, 0x92, 0x5b,
-	0xa0, 0x36, 0x27, 0x72,
+	0x00, 0xe2, 0xa4, 0x5b,
+	0xa0, 0x36, 0x39, 0x72,
 	0x40, 0xea, 0x98, 0x00,
 	0x01, 0x31, 0x89, 0x32,
 	0x08, 0xea, 0x62, 0x02,
-	0x00, 0xe2, 0xdc, 0x41,
-	0xe0, 0xea, 0xa2, 0x5b,
-	0x80, 0xe0, 0xa0, 0x6a,
-	0x04, 0xe0, 0x40, 0x73,
-	0x02, 0xe0, 0x70, 0x73,
-	0x00, 0xea, 0xfe, 0x72,
-	0x03, 0xe0, 0x80, 0x73,
-	0x23, 0xe0, 0x7a, 0x72,
-	0x08, 0xe0, 0x9c, 0x72,
-	0x00, 0xe2, 0x92, 0x5b,
-	0x07, 0xea, 0x3c, 0x59,
+	0x00, 0xe2, 0xee, 0x41,
+	0xe0, 0xea, 0xb4, 0x5b,
+	0x80, 0xe0, 0xb2, 0x6a,
+	0x04, 0xe0, 0x52, 0x73,
+	0x02, 0xe0, 0x82, 0x73,
+	0x00, 0xea, 0x10, 0x73,
+	0x03, 0xe0, 0x92, 0x73,
+	0x23, 0xe0, 0x8c, 0x72,
+	0x08, 0xe0, 0xae, 0x72,
+	0x00, 0xe2, 0xa4, 0x5b,
+	0x07, 0xea, 0x46, 0x59,
 	0x07, 0xea, 0x04, 0x00,
-	0x08, 0x42, 0xdd, 0x71,
-	0x04, 0x42, 0x77, 0x62,
+	0x08, 0x42, 0xef, 0x71,
+	0x04, 0x42, 0x89, 0x62,
 	0x01, 0x43, 0x89, 0x30,
-	0x00, 0xe2, 0x68, 0x42,
+	0x00, 0xe2, 0x7a, 0x42,
 	0x01, 0x44, 0xd4, 0x31,
-	0x00, 0xe2, 0x68, 0x42,
+	0x00, 0xe2, 0x7a, 0x42,
 	0x01, 0x00, 0x60, 0x32,
-	0x33, 0xea, 0x30, 0x59,
+	0x33, 0xea, 0x3a, 0x59,
 	0x33, 0xea, 0x00, 0x00,
 	0x4c, 0x34, 0xc1, 0x28,
 	0x01, 0x64, 0xc0, 0x31,
-	0x00, 0x30, 0x31, 0x59,
+	0x00, 0x30, 0x3b, 0x59,
 	0x01, 0x30, 0x01, 0x30,
-	0x01, 0xe0, 0x9a, 0x7a,
-	0xa0, 0xea, 0x98, 0x5b,
-	0x01, 0xa0, 0x9a, 0x62,
-	0x01, 0x84, 0x93, 0x7a,
-	0x01, 0xa7, 0x9c, 0x7a,
-	0x00, 0xe2, 0x9c, 0x42,
-	0x03, 0xea, 0x3c, 0x59,
+	0x01, 0xe0, 0xac, 0x7a,
+	0xa0, 0xea, 0xaa, 0x5b,
+	0x01, 0xa0, 0xac, 0x62,
+	0x01, 0x84, 0xa5, 0x7a,
+	0x01, 0xa7, 0xae, 0x7a,
+	0x00, 0xe2, 0xae, 0x42,
+	0x03, 0xea, 0x46, 0x59,
 	0x03, 0xea, 0x04, 0x00,
-	0x00, 0xe2, 0x9c, 0x42,
-	0x07, 0xea, 0xaa, 0x5b,
+	0x00, 0xe2, 0xae, 0x42,
+	0x07, 0xea, 0xbc, 0x5b,
 	0x01, 0x44, 0xd4, 0x31,
-	0x00, 0xe2, 0xdc, 0x41,
+	0x00, 0xe2, 0xee, 0x41,
 	0x3f, 0xe0, 0x6a, 0x0a,
 	0xc0, 0x34, 0xc1, 0x09,
 	0x00, 0x35, 0x51, 0x01,
@@ -352,54 +361,54 @@ static uint8_t seqprog[] = {
 	0x01, 0xea, 0xc6, 0x01,
 	0x02, 0xe2, 0xc8, 0x31,
 	0x02, 0xec, 0x40, 0x31,
-	0xff, 0xa1, 0xbc, 0x72,
+	0xff, 0xa1, 0xce, 0x72,
 	0x02, 0xe8, 0xda, 0x31,
 	0x02, 0xa0, 0x50, 0x31,
-	0x00, 0xe2, 0xde, 0x42,
+	0x00, 0xe2, 0xf0, 0x42,
 	0x80, 0x33, 0x67, 0x02,
 	0x01, 0x44, 0xd4, 0x31,
-	0x00, 0xe2, 0x92, 0x5b,
+	0x00, 0xe2, 0xa4, 0x5b,
 	0x01, 0x33, 0x67, 0x02,
-	0xe0, 0x36, 0xf9, 0x62,
+	0xe0, 0x36, 0x0b, 0x63,
 	0x02, 0x33, 0x67, 0x02,
-	0x20, 0x46, 0xf2, 0x62,
+	0x20, 0x46, 0x04, 0x63,
 	0xff, 0xea, 0x52, 0x09,
-	0xa8, 0xea, 0x98, 0x5b,
-	0x04, 0xa8, 0xd9, 0x7a,
+	0xa8, 0xea, 0xaa, 0x5b,
+	0x04, 0xa8, 0xeb, 0x7a,
 	0x01, 0x34, 0xc1, 0x31,
-	0x00, 0xa9, 0xd9, 0x62,
+	0x00, 0xa9, 0xeb, 0x62,
 	0x01, 0x35, 0xc1, 0x31,
-	0x00, 0xaa, 0xe3, 0x72,
+	0x00, 0xaa, 0xf5, 0x72,
 	0x01, 0xa9, 0x52, 0x11,
-	0xff, 0xa9, 0xce, 0x6a,
-	0x00, 0xe2, 0xf2, 0x42,
+	0xff, 0xa9, 0xe0, 0x6a,
+	0x00, 0xe2, 0x04, 0x43,
 	0x10, 0x33, 0x67, 0x02,
-	0x04, 0xa8, 0xf3, 0x7a,
+	0x04, 0xa8, 0x05, 0x7b,
 	0xfb, 0xa8, 0x51, 0x0b,
 	0xff, 0xea, 0x66, 0x0a,
-	0x01, 0xa4, 0xed, 0x6a,
+	0x01, 0xa4, 0xff, 0x6a,
 	0x02, 0xa8, 0x90, 0x32,
-	0x00, 0xe2, 0x56, 0x59,
-	0x10, 0xa8, 0x9d, 0x7a,
-	0xff, 0xea, 0xaa, 0x5b,
-	0x00, 0xe2, 0x9c, 0x42,
-	0x04, 0xea, 0x3c, 0x59,
+	0x00, 0xe2, 0x60, 0x59,
+	0x10, 0xa8, 0xaf, 0x7a,
+	0xff, 0xea, 0xbc, 0x5b,
+	0x00, 0xe2, 0xae, 0x42,
+	0x04, 0xea, 0x46, 0x59,
 	0x04, 0xea, 0x04, 0x00,
-	0x00, 0xe2, 0x9c, 0x42,
-	0x04, 0xea, 0x3c, 0x59,
+	0x00, 0xe2, 0xae, 0x42,
+	0x04, 0xea, 0x46, 0x59,
 	0x04, 0xea, 0x04, 0x00,
-	0x00, 0xe2, 0xdc, 0x41,
-	0x08, 0xa8, 0x95, 0x7a,
-	0xc0, 0x33, 0x09, 0x7b,
-	0x80, 0x33, 0x95, 0x6a,
-	0xff, 0x88, 0x09, 0x6b,
-	0x40, 0x33, 0x95, 0x6a,
-	0x10, 0xa8, 0x0f, 0x7b,
-	0x0a, 0xea, 0x3c, 0x59,
+	0x00, 0xe2, 0xee, 0x41,
+	0x08, 0xa8, 0xa7, 0x7a,
+	0xc0, 0x33, 0x1b, 0x7b,
+	0x80, 0x33, 0xa7, 0x6a,
+	0xff, 0x88, 0x1b, 0x6b,
+	0x40, 0x33, 0xa7, 0x6a,
+	0x10, 0xa8, 0x21, 0x7b,
+	0x0a, 0xea, 0x46, 0x59,
 	0x0a, 0xea, 0x04, 0x00,
-	0x00, 0xe2, 0x28, 0x5b,
-	0x00, 0xe2, 0x5c, 0x43,
-	0x50, 0x4b, 0x16, 0x6b,
+	0x00, 0xe2, 0x3a, 0x5b,
+	0x00, 0xe2, 0x6e, 0x43,
+	0x50, 0x4b, 0x28, 0x6b,
 	0xbf, 0x3a, 0x74, 0x08,
 	0x01, 0xe0, 0xf8, 0x31,
 	0xff, 0xea, 0xc0, 0x09,
@@ -407,24 +416,24 @@ static uint8_t seqprog[] = {
 	0x00, 0x2f, 0x5f, 0x22,
 	0x04, 0x47, 0x8f, 0x02,
 	0x01, 0xfc, 0xc0, 0x35,
-	0x33, 0xea, 0x30, 0x59,
+	0x33, 0xea, 0x3a, 0x59,
 	0x33, 0xea, 0x00, 0x00,
 	0x02, 0x42, 0x51, 0x31,
 	0x10, 0xa8, 0x51, 0x03,
-	0xff, 0x88, 0x37, 0x6b,
-	0x01, 0xa4, 0x33, 0x6b,
-	0x02, 0xa4, 0x3b, 0x6b,
-	0x01, 0x84, 0x3b, 0x7b,
+	0xff, 0x88, 0x49, 0x6b,
+	0x01, 0xa4, 0x45, 0x6b,
+	0x02, 0xa4, 0x4d, 0x6b,
+	0x01, 0x84, 0x4d, 0x7b,
 	0x02, 0x28, 0x19, 0x33,
 	0x02, 0xa8, 0x50, 0x36,
-	0xff, 0x88, 0x3b, 0x73,
-	0x00, 0xe2, 0x12, 0x5b,
+	0xff, 0x88, 0x4d, 0x73,
+	0x00, 0xe2, 0x24, 0x5b,
 	0x02, 0x2c, 0x19, 0x33,
 	0x02, 0xa8, 0x58, 0x32,
 	0x04, 0xa4, 0x49, 0x07,
-	0xc0, 0x33, 0x95, 0x6a,
+	0xc0, 0x33, 0xa7, 0x6a,
 	0x04, 0xa8, 0x51, 0x03,
-	0x20, 0xa8, 0x5d, 0x6b,
+	0x20, 0xa8, 0x6f, 0x6b,
 	0x02, 0xa8, 0x40, 0x31,
 	0xc0, 0x34, 0xc1, 0x09,
 	0x00, 0x35, 0x51, 0x01,
@@ -439,66 +448,66 @@ static uint8_t seqprog[] = {
 	0xf7, 0x57, 0xae, 0x08,
 	0x08, 0xea, 0x98, 0x00,
 	0x01, 0x44, 0xd4, 0x31,
-	0xee, 0x00, 0x66, 0x6b,
+	0xee, 0x00, 0x78, 0x6b,
 	0x02, 0xea, 0xb4, 0x00,
-	0x00, 0xe2, 0x8e, 0x5b,
-	0x09, 0x4c, 0x68, 0x7b,
+	0x00, 0xe2, 0xa0, 0x5b,
+	0x09, 0x4c, 0x7a, 0x7b,
 	0x08, 0x4c, 0x06, 0x68,
-	0x0b, 0xea, 0x3c, 0x59,
+	0x0b, 0xea, 0x46, 0x59,
 	0x0b, 0xea, 0x04, 0x00,
 	0x01, 0x44, 0xd4, 0x31,
-	0x20, 0x33, 0xdd, 0x79,
-	0x00, 0xe2, 0x78, 0x5b,
-	0x00, 0xe2, 0xdc, 0x41,
-	0x01, 0x84, 0x7d, 0x7b,
+	0x20, 0x33, 0xef, 0x79,
+	0x00, 0xe2, 0x8a, 0x5b,
+	0x00, 0xe2, 0xee, 0x41,
+	0x01, 0x84, 0x8f, 0x7b,
 	0x01, 0xa4, 0x49, 0x07,
 	0x08, 0x60, 0x30, 0x33,
 	0x08, 0x80, 0x41, 0x37,
 	0xdf, 0x33, 0x67, 0x0a,
-	0xee, 0x00, 0x8a, 0x6b,
+	0xee, 0x00, 0x9c, 0x6b,
 	0x05, 0xea, 0xb4, 0x00,
-	0x33, 0xea, 0x30, 0x59,
+	0x33, 0xea, 0x3a, 0x59,
 	0x33, 0xea, 0x00, 0x00,
-	0x00, 0xe2, 0x56, 0x59,
-	0x00, 0xe2, 0x9c, 0x42,
+	0x00, 0xe2, 0x60, 0x59,
+	0x00, 0xe2, 0xae, 0x42,
 	0x01, 0xea, 0x6c, 0x02,
 	0xc0, 0xea, 0x66, 0x06,
-	0xff, 0x42, 0x92, 0x7b,
-	0x04, 0x4c, 0x92, 0x6b,
+	0xff, 0x42, 0xa4, 0x7b,
+	0x04, 0x4c, 0xa4, 0x6b,
 	0xe0, 0x41, 0x6c, 0x0e,
 	0x01, 0x44, 0xd4, 0x31,
-	0xff, 0x42, 0x9a, 0x7b,
-	0x04, 0x4c, 0x9a, 0x6b,
+	0xff, 0x42, 0xac, 0x7b,
+	0x04, 0x4c, 0xac, 0x6b,
 	0xe0, 0x41, 0x6c, 0x0a,
-	0xe0, 0x36, 0xdd, 0x61,
+	0xe0, 0x36, 0xef, 0x61,
 	0xff, 0xea, 0xca, 0x09,
 	0x01, 0xe2, 0xc8, 0x31,
 	0x01, 0x46, 0xda, 0x35,
 	0x01, 0x44, 0xd4, 0x35,
 	0x10, 0xea, 0x80, 0x00,
 	0x01, 0xe2, 0x62, 0x36,
-	0x04, 0xa6, 0xb2, 0x7b,
+	0x04, 0xa6, 0xc4, 0x7b,
 	0xff, 0xea, 0x5a, 0x09,
 	0xff, 0xea, 0x4c, 0x0d,
-	0x01, 0xa6, 0xd0, 0x6b,
-	0x10, 0xad, 0x4e, 0x7d,
-	0x80, 0xad, 0xc8, 0x6b,
-	0x08, 0xad, 0x4e, 0x6d,
+	0x01, 0xa6, 0xe2, 0x6b,
+	0x10, 0xad, 0x66, 0x7d,
+	0x80, 0xad, 0xda, 0x6b,
+	0x08, 0xad, 0x66, 0x6d,
 	0x04, 0x84, 0xf9, 0x30,
 	0x00, 0xea, 0x08, 0x81,
 	0xff, 0xea, 0xd4, 0x09,
 	0x02, 0x84, 0xf9, 0x88,
 	0x1d, 0xea, 0x5a, 0x01,
 	0x04, 0xa6, 0x4c, 0x05,
-	0x04, 0xa6, 0x4e, 0x7d,
+	0x04, 0xa6, 0x66, 0x7d,
 	0xff, 0xea, 0x5a, 0x09,
 	0x03, 0x84, 0x59, 0x89,
 	0x03, 0xea, 0x4c, 0x01,
-	0x80, 0x1a, 0x4e, 0x7d,
+	0x80, 0x1a, 0x66, 0x7d,
 	0x08, 0xb0, 0xe0, 0x30,
 	0x04, 0xb0, 0xe0, 0x30,
 	0x03, 0xb0, 0xf0, 0x30,
-	0x01, 0x78, 0xdc, 0x7b,
+	0x01, 0x78, 0xee, 0x7b,
 	0x01, 0xa7, 0x4e, 0x11,
 	0x01, 0xb0, 0x06, 0x33,
 	0x7f, 0x83, 0xe9, 0x08,
@@ -509,244 +518,247 @@ static uint8_t seqprog[] = {
 	0x00, 0x86, 0x0d, 0x23,
 	0x00, 0x87, 0x0f, 0x23,
 	0x01, 0x84, 0xc5, 0x31,
-	0x01, 0xa7, 0xf2, 0x7b,
+	0x01, 0xa7, 0x04, 0x7c,
 	0x04, 0xe2, 0xc4, 0x01,
-	0x80, 0x83, 0xf9, 0x7b,
+	0x80, 0x83, 0x0b, 0x7c,
 	0x02, 0xe2, 0xc4, 0x01,
 	0xff, 0xea, 0x4c, 0x09,
 	0x01, 0xe2, 0x36, 0x30,
 	0xc8, 0x19, 0x32, 0x00,
 	0x88, 0x19, 0x32, 0x00,
 	0x01, 0xac, 0xd4, 0x99,
-	0x00, 0xe2, 0x4e, 0x55,
+	0x00, 0xe2, 0x66, 0x55,
 	0xfe, 0xa6, 0x4c, 0x0d,
 	0x0b, 0x98, 0xe1, 0x30,
 	0x01, 0xa0, 0x4f, 0x09,
 	0xfd, 0xa4, 0x49, 0x09,
-	0x80, 0xa3, 0x0f, 0x7c,
+	0x80, 0xa3, 0x21, 0x7c,
 	0x02, 0xa4, 0x48, 0x01,
-	0x01, 0xa7, 0x12, 0x7c,
+	0x01, 0xa7, 0x24, 0x7c,
 	0x04, 0xa4, 0x48, 0x01,
 	0x01, 0xa4, 0x36, 0x30,
 	0xa8, 0xea, 0x32, 0x00,
 	0xfd, 0xa4, 0x49, 0x0b,
 	0x05, 0xa3, 0x07, 0x33,
-	0x80, 0x83, 0x1f, 0x6c,
+	0x80, 0x83, 0x31, 0x6c,
 	0x02, 0xea, 0x4c, 0x05,
 	0xff, 0xea, 0x4c, 0x0d,
-	0x00, 0xe2, 0x28, 0x59,
-	0x02, 0xa6, 0xb4, 0x6b,
+	0x00, 0xe2, 0x32, 0x59,
+	0x02, 0xa6, 0xc6, 0x6b,
 	0x80, 0xf9, 0xf2, 0x05,
-	0xc0, 0x33, 0x2d, 0x7c,
-	0x03, 0xea, 0x3c, 0x59,
+	0xc0, 0x33, 0x3f, 0x7c,
+	0x03, 0xea, 0x46, 0x59,
 	0x03, 0xea, 0x04, 0x00,
-	0x20, 0x33, 0x51, 0x7c,
-	0x01, 0x84, 0x37, 0x6c,
-	0x06, 0xea, 0x3c, 0x59,
+	0x20, 0x33, 0x63, 0x7c,
+	0x01, 0x84, 0x49, 0x6c,
+	0x06, 0xea, 0x46, 0x59,
 	0x06, 0xea, 0x04, 0x00,
-	0x00, 0xe2, 0x54, 0x44,
+	0x00, 0xe2, 0x66, 0x44,
 	0x01, 0x00, 0x60, 0x32,
-	0xee, 0x00, 0x40, 0x6c,
+	0xee, 0x00, 0x52, 0x6c,
 	0x05, 0xea, 0xb4, 0x00,
-	0x33, 0xea, 0x30, 0x59,
+	0x33, 0xea, 0x3a, 0x59,
 	0x33, 0xea, 0x00, 0x00,
 	0x80, 0x3d, 0x7a, 0x00,
-	0xfc, 0x42, 0x42, 0x7c,
+	0xfc, 0x42, 0x54, 0x7c,
 	0x7f, 0x3d, 0x7a, 0x08,
-	0x00, 0x30, 0x31, 0x59,
+	0x00, 0x30, 0x3b, 0x59,
 	0x01, 0x30, 0x01, 0x30,
-	0x09, 0xea, 0x3c, 0x59,
+	0x09, 0xea, 0x46, 0x59,
 	0x09, 0xea, 0x04, 0x00,
-	0x00, 0xe2, 0xdc, 0x41,
-	0x01, 0xa4, 0x37, 0x6c,
-	0x00, 0xe2, 0x04, 0x5c,
+	0x00, 0xe2, 0xee, 0x41,
+	0x01, 0xa4, 0x49, 0x6c,
+	0x00, 0xe2, 0x16, 0x5c,
 	0x20, 0x33, 0x67, 0x02,
 	0x01, 0x00, 0x60, 0x32,
-	0x02, 0xa6, 0x5c, 0x7c,
-	0x00, 0xe2, 0x20, 0x5c,
-	0x00, 0xe2, 0x5c, 0x58,
-	0x00, 0xe2, 0x6c, 0x58,
+	0x02, 0xa6, 0x6e, 0x7c,
+	0x00, 0xe2, 0x32, 0x5c,
+	0x00, 0xe2, 0x66, 0x58,
+	0x00, 0xe2, 0x76, 0x58,
 	0x00, 0xe2, 0x30, 0x58,
-	0x00, 0x30, 0x31, 0x59,
+	0x00, 0x30, 0x3b, 0x59,
 	0x01, 0x30, 0x01, 0x30,
-	0x20, 0x19, 0x5c, 0x6c,
-	0x00, 0xe2, 0x84, 0x5c,
-	0x04, 0x19, 0x76, 0x6c,
+	0x20, 0x19, 0x6e, 0x6c,
+	0x00, 0xe2, 0x96, 0x5c,
+	0x04, 0x19, 0x88, 0x6c,
 	0x02, 0x19, 0x32, 0x00,
-	0x01, 0x84, 0x77, 0x7c,
-	0x01, 0x1b, 0x70, 0x7c,
-	0x01, 0x1a, 0x76, 0x6c,
-	0x00, 0xe2, 0x26, 0x44,
-	0x80, 0x4b, 0x7c, 0x6c,
-	0x01, 0x4c, 0x78, 0x7c,
-	0x03, 0x42, 0x26, 0x6c,
-	0x00, 0xe2, 0xae, 0x5b,
+	0x01, 0x84, 0x89, 0x7c,
+	0x01, 0x1b, 0x82, 0x7c,
+	0x01, 0x1a, 0x88, 0x6c,
+	0x00, 0xe2, 0x38, 0x44,
+	0x80, 0x4b, 0x8e, 0x6c,
+	0x01, 0x4c, 0x8a, 0x7c,
+	0x03, 0x42, 0x38, 0x6c,
+	0x00, 0xe2, 0xc0, 0x5b,
 	0x80, 0xf9, 0xf2, 0x01,
-	0x04, 0x33, 0xdd, 0x79,
-	0x00, 0xe2, 0xdc, 0x41,
-	0x02, 0x1b, 0x8c, 0x7c,
-	0x08, 0x5d, 0x8a, 0x7c,
+	0x04, 0x33, 0xef, 0x79,
+	0x00, 0xe2, 0xee, 0x41,
+	0x02, 0x1b, 0x9e, 0x7c,
+	0x08, 0x5d, 0x9c, 0x7c,
 	0x03, 0x68, 0x00, 0x37,
 	0x01, 0x84, 0x09, 0x07,
-	0x08, 0x5d, 0x96, 0x6c,
-	0x00, 0xe2, 0x5c, 0x58,
-	0x00, 0x30, 0x31, 0x59,
+	0x08, 0x5d, 0xa8, 0x6c,
+	0x00, 0xe2, 0x66, 0x58,
+	0x00, 0x30, 0x3b, 0x59,
 	0x01, 0x30, 0x01, 0x30,
-	0x00, 0xe2, 0x84, 0x44,
-	0x80, 0x1b, 0xa0, 0x7c,
-	0x80, 0x84, 0xa1, 0x6c,
+	0x00, 0xe2, 0x96, 0x44,
+	0x80, 0x1b, 0xb2, 0x7c,
+	0x80, 0x84, 0xb3, 0x6c,
 	0xff, 0x85, 0x0b, 0x1b,
 	0xff, 0x86, 0x0d, 0x23,
 	0xff, 0x87, 0x0f, 0x23,
 	0xf8, 0x1b, 0x08, 0x0b,
 	0xff, 0xea, 0x4e, 0x09,
-	0x04, 0x1b, 0xa8, 0x7c,
+	0x04, 0x1b, 0xba, 0x7c,
 	0x01, 0xa7, 0x4e, 0x01,
 	0xff, 0xea, 0x06, 0x0b,
 	0x03, 0x68, 0x00, 0x37,
-	0x00, 0xe2, 0xac, 0x58,
+	0x00, 0xe2, 0xb6, 0x58,
 	0x10, 0xea, 0x18, 0x00,
 	0xf9, 0xd9, 0xb2, 0x0d,
 	0x01, 0xd9, 0xb2, 0x05,
 	0xff, 0xea, 0xd4, 0x09,
-	0x10, 0x5b, 0xcc, 0x6c,
-	0x08, 0x5b, 0xd4, 0x6c,
-	0x20, 0x5b, 0xc2, 0x6c,
-	0x02, 0x5b, 0xe2, 0x6d,
-	0x0e, 0xea, 0x3c, 0x59,
+	0x10, 0x5b, 0xde, 0x6c,
+	0x08, 0x5b, 0xe6, 0x6c,
+	0x20, 0x5b, 0xd4, 0x6c,
+	0x02, 0x5b, 0xfa, 0x6d,
+	0x0e, 0xea, 0x46, 0x59,
 	0x0e, 0xea, 0x04, 0x00,
-	0x08, 0x19, 0xc8, 0x7c,
+	0x08, 0x19, 0xda, 0x7c,
 	0xdf, 0x5c, 0xb8, 0x08,
 	0x01, 0xd9, 0xb2, 0x05,
 	0x02, 0xea, 0xb4, 0x00,
 	0x01, 0xd9, 0xb2, 0x05,
-	0x01, 0xa4, 0xab, 0x6d,
-	0x00, 0xe2, 0x04, 0x5c,
-	0x00, 0xe2, 0xee, 0x5c,
+	0x01, 0xa4, 0xc3, 0x6d,
+	0x00, 0xe2, 0x16, 0x5c,
+	0x00, 0xe2, 0x06, 0x5d,
 	0x01, 0xd9, 0xb2, 0x05,
-	0x00, 0xe2, 0x12, 0x5b,
+	0x00, 0xe2, 0x24, 0x5b,
 	0xf3, 0x92, 0xd5, 0x19,
-	0x00, 0xe2, 0xe2, 0x54,
-	0x80, 0x92, 0xe3, 0x6c,
-	0x0f, 0xea, 0x3c, 0x59,
+	0x00, 0xe2, 0xf4, 0x54,
+	0x80, 0x92, 0xf5, 0x6c,
+	0x0f, 0xea, 0x46, 0x59,
 	0x0f, 0xea, 0x04, 0x00,
-	0x00, 0xe2, 0xea, 0x44,
+	0x00, 0xe2, 0xfc, 0x44,
 	0x04, 0x8c, 0xe1, 0x30,
 	0x01, 0xea, 0xf2, 0x00,
 	0x02, 0xea, 0x36, 0x00,
 	0xa8, 0xea, 0x32, 0x00,
-	0x00, 0xe2, 0x70, 0x5d,
+	0xff, 0x93, 0x03, 0x7d,
+	0x14, 0xea, 0x46, 0x59,
+	0x14, 0xea, 0x04, 0x00,
+	0x00, 0xe2, 0x88, 0x5d,
 	0x01, 0xd9, 0xb2, 0x05,
 	0x02, 0xa8, 0xf4, 0x31,
-	0x02, 0xa6, 0x00, 0x7d,
-	0x00, 0xe2, 0x2a, 0x59,
-	0x20, 0x5b, 0x0e, 0x6d,
-	0xfc, 0x42, 0xfa, 0x7c,
-	0x10, 0x40, 0xfc, 0x6c,
-	0x20, 0x4d, 0xfe, 0x7c,
-	0x08, 0x5d, 0x0e, 0x6d,
-	0x02, 0xa6, 0xb4, 0x6b,
-	0x00, 0xe2, 0x2a, 0x59,
-	0x20, 0x5b, 0x0e, 0x6d,
-	0x01, 0x1b, 0x2e, 0x6d,
-	0xfc, 0x42, 0x0a, 0x7d,
-	0x10, 0x40, 0x0c, 0x6d,
-	0x20, 0x4d, 0x4e, 0x7d,
-	0x08, 0x5d, 0x4e, 0x7d,
+	0x02, 0xa6, 0x18, 0x7d,
+	0x00, 0xe2, 0x34, 0x59,
+	0x20, 0x5b, 0x26, 0x6d,
+	0xfc, 0x42, 0x12, 0x7d,
+	0x10, 0x40, 0x14, 0x6d,
+	0x20, 0x4d, 0x16, 0x7d,
+	0x08, 0x5d, 0x26, 0x6d,
+	0x02, 0xa6, 0xc6, 0x6b,
+	0x00, 0xe2, 0x34, 0x59,
+	0x20, 0x5b, 0x26, 0x6d,
+	0x01, 0x1b, 0x46, 0x6d,
+	0xfc, 0x42, 0x22, 0x7d,
+	0x10, 0x40, 0x24, 0x6d,
+	0x20, 0x4d, 0x66, 0x7d,
+	0x08, 0x5d, 0x66, 0x7d,
 	0x02, 0x19, 0x32, 0x00,
 	0x01, 0x5b, 0x40, 0x31,
-	0x00, 0xe2, 0x84, 0x5c,
-	0x00, 0xe2, 0x78, 0x5b,
+	0x00, 0xe2, 0x96, 0x5c,
+	0x00, 0xe2, 0x8a, 0x5b,
 	0x20, 0xea, 0xb6, 0x00,
-	0x00, 0xe2, 0xae, 0x5b,
+	0x00, 0xe2, 0xc0, 0x5b,
 	0x20, 0x5c, 0xb8, 0x00,
-	0x04, 0x19, 0x24, 0x6d,
-	0x01, 0x1a, 0x24, 0x6d,
-	0x00, 0xe2, 0x2a, 0x59,
-	0x01, 0x1a, 0x4e, 0x7d,
+	0x04, 0x19, 0x3c, 0x6d,
+	0x01, 0x1a, 0x3c, 0x6d,
+	0x00, 0xe2, 0x34, 0x59,
+	0x01, 0x1a, 0x66, 0x7d,
 	0x80, 0xf9, 0xf2, 0x01,
-	0x20, 0xa0, 0x94, 0x7d,
-	0x08, 0xa8, 0x2d, 0x7d,
-	0x00, 0xe2, 0x40, 0x45,
+	0x20, 0xa0, 0xac, 0x7d,
+	0x08, 0xa8, 0x45, 0x7d,
+	0x00, 0xe2, 0x58, 0x45,
 	0x02, 0xea, 0xb4, 0x04,
 	0x02, 0x19, 0x32, 0x00,
-	0x08, 0xa8, 0x51, 0x7d,
-	0x04, 0x5d, 0xaa, 0x7d,
-	0x01, 0x1a, 0xaa, 0x7d,
+	0x08, 0xa8, 0x69, 0x7d,
+	0x04, 0x5d, 0xc2, 0x7d,
+	0x01, 0x1a, 0xc2, 0x7d,
 	0x01, 0xa4, 0x49, 0x03,
 	0x80, 0xf9, 0xf2, 0x01,
 	0x02, 0xa8, 0x84, 0x32,
 	0x02, 0xea, 0xb4, 0x00,
-	0x00, 0xe2, 0x22, 0x43,
+	0x00, 0xe2, 0x34, 0x43,
 	0x02, 0xa8, 0x84, 0x32,
 	0x02, 0xea, 0xb4, 0x00,
 	0xff, 0xea, 0xd4, 0x19,
-	0x00, 0xe2, 0x36, 0x59,
+	0x00, 0xe2, 0x40, 0x59,
 	0x11, 0x00, 0x00, 0x10,
-	0x00, 0xe2, 0x80, 0x5d,
-	0x00, 0xe2, 0x22, 0x53,
+	0x00, 0xe2, 0x98, 0x5d,
+	0x00, 0xe2, 0x34, 0x53,
 	0xff, 0xea, 0xd4, 0x0d,
-	0x00, 0xe2, 0x2a, 0x59,
-	0x40, 0x5b, 0x5c, 0x6d,
-	0x04, 0x5d, 0xaa, 0x7d,
-	0x01, 0x1a, 0xaa, 0x7d,
-	0x20, 0x4d, 0x4e, 0x7d,
-	0x40, 0x5b, 0x94, 0x7d,
-	0x04, 0x5d, 0xaa, 0x7d,
-	0x01, 0x1a, 0xaa, 0x7d,
+	0x00, 0xe2, 0x34, 0x59,
+	0x40, 0x5b, 0x74, 0x6d,
+	0x04, 0x5d, 0xc2, 0x7d,
+	0x01, 0x1a, 0xc2, 0x7d,
+	0x20, 0x4d, 0x66, 0x7d,
+	0x40, 0x5b, 0xac, 0x7d,
+	0x04, 0x5d, 0xc2, 0x7d,
+	0x01, 0x1a, 0xc2, 0x7d,
 	0x80, 0xf9, 0xf2, 0x01,
 	0x01, 0xa4, 0x49, 0x03,
-	0x08, 0xa8, 0x41, 0x6d,
+	0x08, 0xa8, 0x59, 0x6d,
 	0x02, 0xea, 0xb4, 0x04,
-	0xff, 0x6a, 0x76, 0x7d,
-	0x10, 0xea, 0x3c, 0x59,
+	0xff, 0x6a, 0x8e, 0x7d,
+	0x10, 0xea, 0x46, 0x59,
 	0x10, 0xea, 0x04, 0x00,
-	0x00, 0xe2, 0x76, 0x45,
-	0x00, 0xe2, 0x28, 0x59,
-	0x10, 0x5d, 0x68, 0x6d,
-	0x40, 0x5b, 0x4e, 0x7d,
+	0x00, 0xe2, 0x8e, 0x45,
+	0x00, 0xe2, 0x32, 0x59,
+	0x10, 0x5d, 0x80, 0x6d,
+	0x40, 0x5b, 0x66, 0x7d,
 	0x02, 0x19, 0x32, 0x00,
 	0x80, 0xf9, 0xf2, 0x01,
 	0xff, 0xea, 0x10, 0x03,
 	0x08, 0xa8, 0x51, 0x03,
-	0x00, 0xe2, 0x40, 0x45,
-	0x80, 0xf9, 0x4e, 0x6d,
+	0x00, 0xe2, 0x58, 0x45,
+	0x80, 0xf9, 0x66, 0x6d,
 	0x01, 0x43, 0xc1, 0x31,
-	0x00, 0xfb, 0x4e, 0x65,
+	0x00, 0xfb, 0x66, 0x65,
 	0x01, 0x42, 0xc1, 0x31,
-	0x00, 0xfa, 0x4e, 0x65,
+	0x00, 0xfa, 0x66, 0x65,
 	0x01, 0xe8, 0xd4, 0x1d,
 	0x30, 0x3f, 0xc0, 0x09,
-	0x30, 0xe0, 0x4e, 0x65,
-	0x40, 0x4b, 0x4e, 0x6d,
+	0x30, 0xe0, 0x66, 0x65,
+	0x40, 0x4b, 0x66, 0x6d,
 	0xff, 0xea, 0x52, 0x01,
-	0xee, 0x00, 0x9a, 0x6d,
+	0xee, 0x00, 0xb2, 0x6d,
 	0x80, 0xf9, 0xf2, 0x01,
 	0x02, 0xea, 0xb4, 0x00,
 	0x20, 0xea, 0x9a, 0x00,
-	0xf3, 0x42, 0xa4, 0x6d,
-	0x12, 0xea, 0x3c, 0x59,
+	0xf3, 0x42, 0xbc, 0x6d,
+	0x12, 0xea, 0x46, 0x59,
 	0x12, 0xea, 0x04, 0x00,
-	0x00, 0xe2, 0xdc, 0x41,
-	0x0d, 0xea, 0x3c, 0x59,
+	0x00, 0xe2, 0xee, 0x41,
+	0x0d, 0xea, 0x46, 0x59,
 	0x0d, 0xea, 0x04, 0x00,
-	0x00, 0xe2, 0xdc, 0x41,
-	0x11, 0xea, 0x3c, 0x59,
+	0x00, 0xe2, 0xee, 0x41,
+	0x11, 0xea, 0x46, 0x59,
 	0x11, 0xea, 0x04, 0x00,
-	0x00, 0xe2, 0x12, 0x5b,
+	0x00, 0xe2, 0x24, 0x5b,
 	0x08, 0x5a, 0xb4, 0x00,
-	0x00, 0xe2, 0xcc, 0x5d,
+	0x00, 0xe2, 0xe4, 0x5d,
 	0xa8, 0xea, 0x32, 0x00,
-	0x00, 0xe2, 0x2a, 0x59,
-	0x80, 0x1a, 0xbe, 0x7d,
-	0x00, 0xe2, 0xcc, 0x5d,
+	0x00, 0xe2, 0x34, 0x59,
+	0x80, 0x1a, 0xd6, 0x7d,
+	0x00, 0xe2, 0xe4, 0x5d,
 	0x80, 0x19, 0x32, 0x00,
-	0x40, 0x5b, 0xc4, 0x6d,
-	0x08, 0x5a, 0xc4, 0x7d,
-	0x20, 0x4d, 0x4e, 0x7d,
+	0x40, 0x5b, 0xdc, 0x6d,
+	0x08, 0x5a, 0xdc, 0x7d,
+	0x20, 0x4d, 0x66, 0x7d,
 	0x02, 0x84, 0x09, 0x03,
-	0x40, 0x5b, 0x94, 0x7d,
-	0x08, 0xa8, 0x39, 0x6d,
+	0x40, 0x5b, 0xac, 0x7d,
+	0x08, 0xa8, 0x51, 0x6d,
 	0x02, 0xea, 0xb4, 0x04,
 	0x01, 0x38, 0xe1, 0x30,
 	0x05, 0x39, 0xe3, 0x98,
@@ -930,116 +942,122 @@ static struct patch {
 	{ ahd_patch0_func, 7, 1, 1 },
 	{ ahd_patch2_func, 24, 1, 2 },
 	{ ahd_patch0_func, 25, 1, 1 },
-	{ ahd_patch2_func, 35, 1, 2 },
-	{ ahd_patch0_func, 36, 1, 1 },
-	{ ahd_patch2_func, 39, 1, 2 },
-	{ ahd_patch0_func, 40, 1, 1 },
-	{ ahd_patch2_func, 43, 1, 2 },
-	{ ahd_patch0_func, 44, 1, 1 },
-	{ ahd_patch2_func, 46, 1, 2 },
-	{ ahd_patch0_func, 47, 1, 1 },
-	{ ahd_patch2_func, 50, 1, 2 },
-	{ ahd_patch0_func, 51, 1, 1 },
-	{ ahd_patch2_func, 54, 1, 2 },
-	{ ahd_patch0_func, 55, 1, 1 },
-	{ ahd_patch2_func, 152, 6, 1 },
-	{ ahd_patch1_func, 158, 2, 1 },
-	{ ahd_patch3_func, 160, 1, 1 },
-	{ ahd_patch2_func, 169, 1, 2 },
-	{ ahd_patch0_func, 170, 1, 1 },
-	{ ahd_patch4_func, 171, 2, 2 },
-	{ ahd_patch0_func, 173, 6, 3 },
-	{ ahd_patch2_func, 176, 1, 2 },
-	{ ahd_patch0_func, 177, 1, 1 },
-	{ ahd_patch2_func, 180, 1, 2 },
-	{ ahd_patch0_func, 181, 1, 1 },
-	{ ahd_patch5_func, 183, 2, 1 },
-	{ ahd_patch3_func, 191, 16, 2 },
-	{ ahd_patch0_func, 207, 1, 1 },
-	{ ahd_patch6_func, 227, 2, 1 },
-	{ ahd_patch5_func, 231, 2, 1 },
-	{ ahd_patch1_func, 245, 1, 2 },
-	{ ahd_patch0_func, 246, 1, 1 },
-	{ ahd_patch1_func, 249, 1, 2 },
-	{ ahd_patch0_func, 250, 1, 1 },
-	{ ahd_patch2_func, 253, 1, 2 },
-	{ ahd_patch0_func, 254, 1, 1 },
-	{ ahd_patch1_func, 309, 1, 2 },
-	{ ahd_patch0_func, 310, 1, 1 },
-	{ ahd_patch2_func, 318, 1, 2 },
+	{ ahd_patch1_func, 32, 1, 2 },
+	{ ahd_patch0_func, 33, 1, 1 },
+	{ ahd_patch2_func, 40, 1, 2 },
+	{ ahd_patch0_func, 41, 1, 1 },
+	{ ahd_patch2_func, 44, 1, 2 },
+	{ ahd_patch0_func, 45, 1, 1 },
+	{ ahd_patch2_func, 48, 1, 2 },
+	{ ahd_patch0_func, 49, 1, 1 },
+	{ ahd_patch2_func, 51, 1, 2 },
+	{ ahd_patch0_func, 52, 1, 1 },
+	{ ahd_patch2_func, 55, 1, 2 },
+	{ ahd_patch0_func, 56, 1, 1 },
+	{ ahd_patch2_func, 59, 1, 2 },
+	{ ahd_patch0_func, 60, 1, 1 },
+	{ ahd_patch2_func, 157, 6, 1 },
+	{ ahd_patch1_func, 163, 2, 1 },
+	{ ahd_patch3_func, 165, 1, 1 },
+	{ ahd_patch2_func, 174, 1, 2 },
+	{ ahd_patch0_func, 175, 1, 1 },
+	{ ahd_patch4_func, 176, 2, 2 },
+	{ ahd_patch0_func, 178, 6, 3 },
+	{ ahd_patch2_func, 181, 1, 2 },
+	{ ahd_patch0_func, 182, 1, 1 },
+	{ ahd_patch2_func, 185, 1, 2 },
+	{ ahd_patch0_func, 186, 1, 1 },
+	{ ahd_patch5_func, 188, 2, 1 },
+	{ ahd_patch3_func, 196, 16, 2 },
+	{ ahd_patch0_func, 212, 1, 1 },
+	{ ahd_patch6_func, 232, 2, 1 },
+	{ ahd_patch1_func, 236, 1, 2 },
+	{ ahd_patch0_func, 237, 1, 1 },
+	{ ahd_patch5_func, 240, 2, 1 },
+	{ ahd_patch1_func, 254, 1, 2 },
+	{ ahd_patch0_func, 255, 1, 1 },
+	{ ahd_patch1_func, 258, 1, 2 },
+	{ ahd_patch0_func, 259, 1, 1 },
+	{ ahd_patch2_func, 262, 1, 2 },
+	{ ahd_patch0_func, 263, 1, 1 },
+	{ ahd_patch1_func, 318, 1, 2 },
 	{ ahd_patch0_func, 319, 1, 1 },
-	{ ahd_patch2_func, 322, 1, 2 },
-	{ ahd_patch0_func, 323, 1, 1 },
-	{ ahd_patch1_func, 330, 1, 2 },
-	{ ahd_patch0_func, 331, 1, 1 },
-	{ ahd_patch7_func, 350, 1, 1 },
-	{ ahd_patch7_func, 353, 1, 1 },
-	{ ahd_patch7_func, 355, 1, 1 },
-	{ ahd_patch7_func, 367, 1, 1 },
-	{ ahd_patch1_func, 377, 1, 2 },
-	{ ahd_patch0_func, 378, 1, 1 },
-	{ ahd_patch1_func, 380, 1, 2 },
-	{ ahd_patch0_func, 381, 1, 1 },
+	{ ahd_patch2_func, 327, 1, 2 },
+	{ ahd_patch0_func, 328, 1, 1 },
+	{ ahd_patch2_func, 331, 1, 2 },
+	{ ahd_patch0_func, 332, 1, 1 },
+	{ ahd_patch1_func, 339, 1, 2 },
+	{ ahd_patch0_func, 340, 1, 1 },
+	{ ahd_patch7_func, 359, 1, 1 },
+	{ ahd_patch7_func, 362, 1, 1 },
+	{ ahd_patch7_func, 364, 1, 1 },
+	{ ahd_patch7_func, 376, 1, 1 },
+	{ ahd_patch1_func, 386, 1, 2 },
+	{ ahd_patch0_func, 387, 1, 1 },
 	{ ahd_patch1_func, 389, 1, 2 },
 	{ ahd_patch0_func, 390, 1, 1 },
-	{ ahd_patch2_func, 401, 1, 2 },
-	{ ahd_patch0_func, 402, 1, 1 },
-	{ ahd_patch8_func, 404, 1, 1 },
-	{ ahd_patch9_func, 431, 1, 1 },
-	{ ahd_patch1_func, 438, 1, 2 },
-	{ ahd_patch0_func, 439, 1, 1 },
-	{ ahd_patch2_func, 451, 1, 2 },
-	{ ahd_patch0_func, 452, 1, 1 },
-	{ ahd_patch10_func, 480, 1, 1 },
-	{ ahd_patch11_func, 489, 1, 2 },
-	{ ahd_patch0_func, 490, 1, 1 },
-	{ ahd_patch12_func, 495, 1, 1 },
-	{ ahd_patch11_func, 496, 1, 1 },
-	{ ahd_patch13_func, 509, 1, 2 },
-	{ ahd_patch0_func, 510, 1, 1 },
-	{ ahd_patch1_func, 532, 1, 2 },
-	{ ahd_patch0_func, 533, 1, 1 },
-	{ ahd_patch1_func, 536, 1, 2 },
-	{ ahd_patch0_func, 537, 1, 1 },
-	{ ahd_patch2_func, 542, 1, 2 },
-	{ ahd_patch0_func, 543, 1, 1 },
-	{ ahd_patch2_func, 547, 1, 2 },
-	{ ahd_patch0_func, 548, 1, 1 },
-	{ ahd_patch1_func, 549, 1, 2 },
-	{ ahd_patch0_func, 550, 1, 1 },
-	{ ahd_patch2_func, 561, 1, 2 },
-	{ ahd_patch0_func, 562, 1, 1 },
-	{ ahd_patch14_func, 566, 1, 1 },
-	{ ahd_patch15_func, 571, 1, 1 },
-	{ ahd_patch16_func, 572, 2, 1 },
-	{ ahd_patch15_func, 576, 1, 2 },
-	{ ahd_patch0_func, 577, 1, 1 },
-	{ ahd_patch2_func, 584, 1, 2 },
-	{ ahd_patch0_func, 585, 1, 1 },
-	{ ahd_patch2_func, 600, 1, 2 },
-	{ ahd_patch0_func, 601, 1, 1 },
-	{ ahd_patch1_func, 607, 1, 2 },
-	{ ahd_patch0_func, 608, 1, 1 },
-	{ ahd_patch1_func, 622, 1, 2 },
-	{ ahd_patch0_func, 623, 1, 1 },
-	{ ahd_patch14_func, 647, 1, 1 },
-	{ ahd_patch14_func, 663, 1, 1 },
-	{ ahd_patch2_func, 675, 1, 2 },
-	{ ahd_patch0_func, 676, 1, 1 },
-	{ ahd_patch1_func, 693, 1, 2 },
-	{ ahd_patch0_func, 694, 1, 1 },
-	{ ahd_patch14_func, 699, 1, 1 },
-	{ ahd_patch1_func, 719, 1, 2 },
-	{ ahd_patch0_func, 720, 1, 1 },
-	{ ahd_patch1_func, 722, 1, 2 },
-	{ ahd_patch0_func, 723, 1, 1 },
-	{ ahd_patch1_func, 725, 1, 2 },
-	{ ahd_patch0_func, 726, 1, 1 },
-	{ ahd_patch17_func, 728, 1, 2 },
-	{ ahd_patch0_func, 729, 2, 1 },
-	{ ahd_patch18_func, 732, 4, 2 },
-	{ ahd_patch0_func, 736, 1, 1 },
-	{ ahd_patch18_func, 742, 11, 1 }
+	{ ahd_patch1_func, 398, 1, 2 },
+	{ ahd_patch0_func, 399, 1, 1 },
+	{ ahd_patch2_func, 410, 1, 2 },
+	{ ahd_patch0_func, 411, 1, 1 },
+	{ ahd_patch8_func, 413, 1, 1 },
+	{ ahd_patch9_func, 440, 1, 1 },
+	{ ahd_patch1_func, 447, 1, 2 },
+	{ ahd_patch0_func, 448, 1, 1 },
+	{ ahd_patch2_func, 460, 1, 2 },
+	{ ahd_patch0_func, 461, 1, 1 },
+	{ ahd_patch10_func, 489, 1, 1 },
+	{ ahd_patch11_func, 498, 1, 2 },
+	{ ahd_patch0_func, 499, 1, 1 },
+	{ ahd_patch12_func, 504, 1, 1 },
+	{ ahd_patch11_func, 505, 1, 1 },
+	{ ahd_patch13_func, 518, 1, 2 },
+	{ ahd_patch0_func, 519, 1, 1 },
+	{ ahd_patch1_func, 541, 1, 2 },
+	{ ahd_patch0_func, 542, 1, 1 },
+	{ ahd_patch1_func, 545, 1, 2 },
+	{ ahd_patch0_func, 546, 1, 1 },
+	{ ahd_patch2_func, 551, 1, 2 },
+	{ ahd_patch0_func, 552, 1, 1 },
+	{ ahd_patch2_func, 556, 1, 2 },
+	{ ahd_patch0_func, 557, 1, 1 },
+	{ ahd_patch1_func, 558, 1, 2 },
+	{ ahd_patch0_func, 559, 1, 1 },
+	{ ahd_patch2_func, 570, 1, 2 },
+	{ ahd_patch0_func, 571, 1, 1 },
+	{ ahd_patch14_func, 575, 1, 1 },
+	{ ahd_patch15_func, 580, 1, 1 },
+	{ ahd_patch16_func, 581, 2, 1 },
+	{ ahd_patch15_func, 585, 1, 2 },
+	{ ahd_patch0_func, 586, 1, 1 },
+	{ ahd_patch2_func, 593, 1, 2 },
+	{ ahd_patch0_func, 594, 1, 1 },
+	{ ahd_patch2_func, 609, 1, 2 },
+	{ ahd_patch0_func, 610, 1, 1 },
+	{ ahd_patch1_func, 616, 1, 2 },
+	{ ahd_patch0_func, 617, 1, 1 },
+	{ ahd_patch1_func, 631, 1, 2 },
+	{ ahd_patch0_func, 632, 1, 1 },
+	{ ahd_patch1_func, 639, 1, 2 },
+	{ ahd_patch0_func, 640, 1, 1 },
+	{ ahd_patch14_func, 659, 1, 1 },
+	{ ahd_patch14_func, 675, 1, 1 },
+	{ ahd_patch2_func, 687, 1, 2 },
+	{ ahd_patch0_func, 688, 1, 1 },
+	{ ahd_patch1_func, 705, 1, 2 },
+	{ ahd_patch0_func, 706, 1, 1 },
+	{ ahd_patch14_func, 711, 1, 1 },
+	{ ahd_patch1_func, 731, 1, 2 },
+	{ ahd_patch0_func, 732, 1, 1 },
+	{ ahd_patch1_func, 734, 1, 2 },
+	{ ahd_patch0_func, 735, 1, 1 },
+	{ ahd_patch1_func, 737, 1, 2 },
+	{ ahd_patch0_func, 738, 1, 1 },
+	{ ahd_patch17_func, 740, 1, 2 },
+	{ ahd_patch0_func, 741, 2, 1 },
+	{ ahd_patch18_func, 744, 4, 2 },
+	{ ahd_patch0_func, 748, 1, 1 },
+	{ ahd_patch18_func, 754, 11, 1 }
 };
 
 static struct cs {
@@ -1048,19 +1066,19 @@ static struct cs {
 } critical_sections[] = {
 	{ 11, 12 },
 	{ 13, 14 },
-	{ 24, 32 },
-	{ 33, 46 },
-	{ 59, 62 },
-	{ 89, 114 },
-	{ 115, 146 },
-	{ 148, 152 },
-	{ 160, 168 },
-	{ 191, 224 },
-	{ 647, 663 },
-	{ 663, 681 },
-	{ 686, 692 },
-	{ 699, 704 },
-	{ 704, 710 }
+	{ 24, 37 },
+	{ 38, 51 },
+	{ 64, 67 },
+	{ 94, 119 },
+	{ 120, 151 },
+	{ 153, 157 },
+	{ 165, 173 },
+	{ 196, 245 },
+	{ 659, 675 },
+	{ 675, 693 },
+	{ 698, 704 },
+	{ 711, 716 },
+	{ 716, 722 }
 };
 
 static const int num_critical_sections = sizeof(critical_sections)

drivers/scsi/aic7xxx/aic7xxx.h

@@ -37,7 +37,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.h#67 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.h#70 $
  *
  * $FreeBSD$
  */
@@ -318,11 +318,11 @@ typedef enum {
  */
 typedef enum {
 	AHC_FNONE	      = 0x000,
-	AHC_PRIMARY_CHANNEL   = 0x003,/*
+	AHC_PRIMARY_CHANNEL   = 0x003,  /*
 					 * The channel that should
 					 * be probed first.
 					 */
-	AHC_USEDEFAULTS	      = 0x004,/*
+	AHC_USEDEFAULTS	      = 0x004,  /*
 					 * For cards without an seeprom
 					 * or a BIOS to initialize the chip's
 					 * SRAM, we use the default target
@@ -330,29 +330,29 @@ typedef enum {
 					 */
 	AHC_SEQUENCER_DEBUG   = 0x008,
 	AHC_SHARED_SRAM	      = 0x010,
-	AHC_LARGE_SEEPROM     = 0x020,/* Uses C56_66 not C46 */
+	AHC_LARGE_SEEPROM     = 0x020,  /* Uses C56_66 not C46 */
 	AHC_RESET_BUS_A	      = 0x040,
 	AHC_RESET_BUS_B	      = 0x080,
 	AHC_EXTENDED_TRANS_A  = 0x100,
 	AHC_EXTENDED_TRANS_B  = 0x200,
 	AHC_TERM_ENB_A	      = 0x400,
 	AHC_TERM_ENB_B	      = 0x800,
-	AHC_INITIATORROLE     = 0x1000,/*
+	AHC_INITIATORROLE     = 0x1000,  /*
 					  * Allow initiator operations on
 					  * this controller.
 					  */
-	AHC_TARGETROLE	      = 0x2000,/*
+	AHC_TARGETROLE	      = 0x2000,  /*
 					  * Allow target operations on this
 					  * controller.
 					  */
 	AHC_NEWEEPROM_FMT     = 0x4000,
 	AHC_RESOURCE_SHORTAGE = 0x8000,
-	AHC_TQINFIFO_BLOCKED  = 0x10000,/* Blocked waiting for ATIOs */
-	AHC_INT50_SPEEDFLEX   = 0x20000,/*
+	AHC_TQINFIFO_BLOCKED  = 0x10000,  /* Blocked waiting for ATIOs */
+	AHC_INT50_SPEEDFLEX   = 0x20000,  /*
 					   * Internal 50pin connector
 					   * sits behind an aic3860
 					   */
-	AHC_SCB_BTT	      = 0x40000,/*
+	AHC_SCB_BTT	      = 0x40000,  /*
 					   * The busy targets table is
 					   * stored in SCB space rather
 					   * than SRAM.
@@ -363,7 +363,9 @@ typedef enum {
 	AHC_EDGE_INTERRUPT    = 0x800000,  /* Device uses edge triggered ints */
 	AHC_39BIT_ADDRESSING  = 0x1000000, /* Use 39 bit addressing scheme. */
 	AHC_LSCBS_ENABLED     = 0x2000000, /* 64Byte SCBs enabled */
-	AHC_SCB_CONFIG_USED   = 0x4000000  /* No SEEPROM but SCB2 had info. */
+	AHC_SCB_CONFIG_USED   = 0x4000000, /* No SEEPROM but SCB2 had info. */
+	AHC_NO_BIOS_INIT      = 0x8000000, /* No BIOS left over settings. */
+	AHC_DISABLE_PCI_PERR  = 0x10000000
 } ahc_flag;
 
 /************************* Hardware  SCB Definition ***************************/
@@ -758,6 +760,7 @@ struct ahc_syncrate {
 #define AHC_SYNCRATE_ULTRA	3
 #define AHC_SYNCRATE_FAST	6
 #define AHC_SYNCRATE_MAX	AHC_SYNCRATE_DT
+#define	AHC_SYNCRATE_MIN	13
 
 /***************************** Lookup Tables **********************************/
 /*

drivers/scsi/aic7xxx/aic7xxx.seq

@@ -40,7 +40,7 @@
  * $FreeBSD$
  */
 
-VERSION = "$Id: //depot/aic7xxx/aic7xxx/aic7xxx.seq#53 $"
+VERSION = "$Id: //depot/aic7xxx/aic7xxx/aic7xxx.seq#54 $"
 PATCH_ARG_LIST = "struct ahc_softc *ahc"
 PREFIX = "ahc_"
 
@@ -193,7 +193,7 @@ select_in:
 		 * Setup the DMA for sending the identify and
 		 * command information.
 		 */
-		or	SEQ_FLAGS, CMDPHASE_PENDING;
+		mvi	SEQ_FLAGS, CMDPHASE_PENDING;
 
 		mov     A, TQINPOS;
 		if ((ahc->features & AHC_CMD_CHAN) != 0) {
@@ -306,7 +306,7 @@ ident_messages_done:
 		} else {
 			mvi	DFDAT, SCB_LIST_NULL;
 		}
-		mvi	SEQ_FLAGS, TARG_CMD_PENDING;
+		or	SEQ_FLAGS, TARG_CMD_PENDING;
 		test	SEQ_FLAGS2, TARGET_MSG_PENDING
 			jnz target_mesgout_pending;
 		test	SCSISIGI, ATNI jnz target_mesgout_continue;
@@ -512,6 +512,7 @@ target_mesgout:
 target_mesgout_continue:
 		call	target_inb;
 target_mesgout_pending:
+		and	SEQ_FLAGS2, ~TARGET_MSG_PENDING;
 		/* Local Processing goes here... */
 		jmp	host_target_message_loop;
 		

drivers/scsi/aic7xxx/aic7xxx_core.c

@@ -37,7 +37,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.c#108 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.c#110 $
  *
  * $FreeBSD$
  */
@@ -1844,8 +1844,9 @@ ahc_update_neg_request(struct ahc_softc *ahc, struct ahc_devinfo *devinfo,
 		 * occurs the need to renegotiate is
 		 * recorded persistently.
 		 */
-		tinfo->curr.period = AHC_PERIOD_UNKNOWN;
+		if ((ahc->features & AHC_WIDE) != 0)
 			tinfo->curr.width = AHC_WIDTH_UNKNOWN;
+		tinfo->curr.period = AHC_PERIOD_UNKNOWN;
 		tinfo->curr.offset = AHC_OFFSET_UNKNOWN;
 	}
 	if (tinfo->curr.period != tinfo->goal.period
@@ -4045,6 +4046,14 @@ ahc_reset(struct ahc_softc *ahc)
 	 * to disturb the integrity of the bus.
 	 */
 	ahc_pause(ahc);
+	if ((ahc_inb(ahc, HCNTRL) & CHIPRST) != 0) {
+		/*
+		 * The chip has not been initialized since
+		 * PCI/EISA/VLB bus reset.  Don't trust
+		 * "left over BIOS data".
+		 */
+		ahc->flags |= AHC_NO_BIOS_INIT;
+	}
 	sxfrctl1_b = 0;
 	if ((ahc->chip & AHC_CHIPID_MASK) == AHC_AIC7770) {
 		u_int sblkctl;
@@ -6725,13 +6734,14 @@ ahc_dump_card_state(struct ahc_softc *ahc)
 	       ahc_inb(ahc, SCBPTR));
 	cur_col = 0;
 	if ((ahc->features & AHC_DT) != 0)
+		ahc_scsiphase_print(ahc_inb(ahc, SCSIPHASE), &cur_col, 50);
 	ahc_scsisigi_print(ahc_inb(ahc, SCSISIGI), &cur_col, 50);
 	ahc_error_print(ahc_inb(ahc, ERROR), &cur_col, 50);
-	ahc_scsiphase_print(ahc_inb(ahc, SCSIPHASE), &cur_col, 50);
 	ahc_scsibusl_print(ahc_inb(ahc, SCSIBUSL), &cur_col, 50);
 	ahc_lastphase_print(ahc_inb(ahc, LASTPHASE), &cur_col, 50);
 	ahc_scsiseq_print(ahc_inb(ahc, SCSISEQ), &cur_col, 50);
 	ahc_sblkctl_print(ahc_inb(ahc, SBLKCTL), &cur_col, 50);
+	ahc_scsirate_print(ahc_inb(ahc, SCSIRATE), &cur_col, 50);
 	ahc_seqctl_print(ahc_inb(ahc, SEQCTL), &cur_col, 50);
 	ahc_seq_flags_print(ahc_inb(ahc, SEQ_FLAGS), &cur_col, 50);
 	ahc_sstat0_print(ahc_inb(ahc, SSTAT0), &cur_col, 50);

drivers/scsi/aic7xxx/aic7xxx_osm.c

 /*
  * Adaptec AIC7xxx device driver for Linux.
  *
- * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic7xxx_osm.c#170 $
+ * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic7xxx_osm.c#178 $
  *
  * Copyright (c) 1994 John Aycock
  *   The University of Calgary Department of Computer Science.
@@ -524,8 +524,6 @@ static void ahc_linux_dv_transition(struct ahc_softc *ahc,
 				    struct scsi_cmnd *cmd,
 				    struct ahc_devinfo *devinfo,
 				    struct ahc_linux_target *targ);
-static uint32_t aic_dv_error_action(struct scsi_cmnd *cmd,
-				    struct scsi_inquiry_data *inq_data);
 static void ahc_linux_dv_fill_cmd(struct ahc_softc *ahc,
 				  struct scsi_cmnd *cmd,
 				  struct ahc_devinfo *devinfo);
@@ -976,7 +974,7 @@ ahc_linux_queue(Scsi_Cmnd * cmd, void (*scsi_done) (Scsi_Cmnd *))
 	struct	 ahc_linux_device *dev;
 	u_long	 flags;
 
-	ahc = *(struct ahc_softc **)cmd->host->hostdata;
+	ahc = *(struct ahc_softc **)cmd->device->host->hostdata;
 
 	/*
 	 * Save the callback on completion function.
@@ -1000,8 +998,8 @@ ahc_linux_queue(Scsi_Cmnd * cmd, void (*scsi_done) (Scsi_Cmnd *))
 		ahc_midlayer_entrypoint_unlock(ahc, &flags);
 		return (0);
 	}
-	dev = ahc_linux_get_device(ahc, cmd->channel, cmd->target,
-				   cmd->lun, /*alloc*/TRUE);
+	dev = ahc_linux_get_device(ahc, cmd->device->channel, cmd->device->id,
+				   cmd->device->lun, /*alloc*/TRUE);
 	if (dev == NULL) {
 		ahc_midlayer_entrypoint_unlock(ahc, &flags);
 		printf("aic7xxx_linux_queue: Unable to allocate device!\n");
@@ -1245,12 +1243,12 @@ ahc_linux_bus_reset(Scsi_Cmnd *cmd)
 	u_long s;
 	int    found;
 
-	ahc = *(struct ahc_softc **)cmd->host->hostdata;
+	ahc = *(struct ahc_softc **)cmd->device->host->hostdata;
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
 	spin_unlock_irq(&io_request_lock);
 #endif
 	ahc_midlayer_entrypoint_lock(ahc, &s);
-	found = ahc_reset_channel(ahc, cmd->channel + 'A',
+	found = ahc_reset_channel(ahc, cmd->device->channel + 'A',
 				  /*initiate reset*/TRUE);
 	acmd = TAILQ_FIRST(&ahc->platform_data->completeq);
 	TAILQ_INIT(&ahc->platform_data->completeq);
@@ -1375,9 +1373,9 @@ static int ahc_linux_halt(struct notifier_block *nb, u_long event, void *buf)
 
 /******************************** Macros **************************************/
 #define BUILD_SCSIID(ahc, cmd)						    \
-	((((cmd)->target << TID_SHIFT) & TID)				\
-	| (((cmd)->channel == 0) ? (ahc)->our_id : (ahc)->our_id_b)	\
-	| (((cmd)->channel == 0) ? 0 : TWIN_CHNLB))
+	((((cmd)->device->id << TID_SHIFT) & TID)			    \
+	| (((cmd)->device->channel == 0) ? (ahc)->our_id : (ahc)->our_id_b) \
+	| (((cmd)->device->channel == 0) ? 0 : TWIN_CHNLB))
 
 /******************************** Bus DMA *************************************/
 int
@@ -2045,6 +2043,9 @@ ahc_platform_alloc(struct ahc_softc *ahc, void *platform_arg)
 #endif
 	ahc->seltime = (aic7xxx_seltime & 0x3) << 4;
 	ahc->seltime_b = (aic7xxx_seltime & 0x3) << 4;
+	if (aic7xxx_pci_parity == 0)
+		ahc->flags |= AHC_DISABLE_PCI_PERR;
+
 	if (TAILQ_EMPTY(&ahc_tailq))
 		register_reboot_notifier(&ahc_linux_notifier);
 	return (0);
@@ -2053,7 +2054,10 @@ ahc_platform_alloc(struct ahc_softc *ahc, void *platform_arg)
 void
 ahc_platform_free(struct ahc_softc *ahc)
 {
+	struct ahc_linux_target *targ;
+	struct ahc_linux_device *dev;
 	u_long s;
+	int i, j;
 
 	if (ahc->platform_data != NULL) {
 		/* Kill the DV kthread */
@@ -2077,6 +2081,23 @@ ahc_platform_free(struct ahc_softc *ahc)
 #endif
 		if (ahc->platform_data->host != NULL)
 			scsi_unregister(ahc->platform_data->host);
+
+		/* destroy all of the device and target objects */
+		for (i = 0; i < AHC_NUM_TARGETS; i++) {
+			targ = ahc->platform_data->targets[i];
+			if (targ != NULL) {
+				for (j = 0; j < AHC_NUM_LUNS; j++) {
+					if (targ->devices[j] != NULL) {
+						dev = targ->devices[j];
+						ahc_linux_free_device(ahc, dev);
+					}
+					if (ahc->platform_data->targets[i] ==
+					    NULL)
+						break;
+				}
+			}
+		}
+
 		if (ahc->platform_data->irq != AHC_LINUX_NOIRQ)
 			free_irq(ahc->platform_data->irq, ahc);
 		if (ahc->tag == BUS_SPACE_PIO
@@ -2446,6 +2467,7 @@ ahc_linux_dv_target(struct ahc_softc *ahc, u_int target_offset)
 	struct	 ahc_devinfo devinfo;
 	struct	 ahc_linux_target *targ;
 	struct	 scsi_cmnd *cmd;
+	struct	 scsi_device *scsi_dev;
 	struct	 scsi_sense_data *sense;
 	uint8_t *buffer;
 	u_long	 s;
@@ -2473,6 +2495,12 @@ ahc_linux_dv_target(struct ahc_softc *ahc, u_int target_offset)
 	ahc_unlock(ahc, &s);
 
 	cmd = malloc(sizeof(struct scsi_cmnd), M_DEVBUF, M_WAITOK);
+	scsi_dev = malloc(sizeof(struct scsi_device), M_DEVBUF, M_WAITOK);
+	scsi_dev->host = ahc->platform_data->host;
+	scsi_dev->id = devinfo.target;
+	scsi_dev->lun = devinfo.lun;
+	scsi_dev->channel = devinfo.channel - 'A';
+	ahc->platform_data->dv_scsi_dev = scsi_dev;
 
 	AHC_SET_DV_STATE(ahc, targ, AHC_DV_STATE_INQ_SHORT_ASYNC);
 
@@ -2597,6 +2625,11 @@ ahc_linux_dv_target(struct ahc_softc *ahc, u_int target_offset)
 	if (cmd != NULL)
 		free(cmd, M_DEVBUF);
 
+	if (ahc->platform_data->dv_scsi_dev != NULL) {
+		free(ahc->platform_data->dv_scsi_dev, M_DEVBUF);
+		ahc->platform_data->dv_scsi_dev = NULL;
+	}
+
 	ahc_lock(ahc, &s);
 	if (targ->dv_buffer != NULL)
 		free(targ->dv_buffer, M_DEVBUF);
@@ -2613,9 +2646,13 @@ ahc_linux_dv_transition(struct ahc_softc *ahc, struct scsi_cmnd *cmd,
 			struct ahc_devinfo *devinfo,
 			struct ahc_linux_target *targ)
 {
+	cam_status cam_status;
 	u_int32_t status;
+	u_int scsi_status;
 
-	status = aic_dv_error_action(cmd, targ->inq_data);
+	scsi_status = ahc_cmd_get_scsi_status(cmd);
+	cam_status = ahc_cmd_get_transaction_status(cmd);
+	status = aic_error_action(cmd, targ->inq_data, cam_status, scsi_status);
 
 	
 #ifdef AHC_DEBUG
@@ -3082,104 +3119,13 @@ ahc_linux_dv_transition(struct ahc_softc *ahc, struct scsi_cmnd *cmd,
 	}
 }
 
-static uint32_t
-aic_dv_error_action(struct scsi_cmnd *cmd, struct scsi_inquiry_data *inq_data)
-{
-	aic_sense_action  err_action;
-	cam_status	  status;
-	u_int		  scsi_status;
-	int		  sense;
-
-	status = ahc_cmd_get_transaction_status(cmd);
-	scsi_status = ahc_cmd_get_scsi_status(cmd);
-	sense  = (cmd->result >> 24) == DRIVER_SENSE;
-
-	switch (status) {
-	case CAM_REQ_CMP:
-		err_action = SS_NOP;
-		break;
-	case CAM_AUTOSENSE_FAIL:
-	case CAM_SCSI_STATUS_ERROR:
-
-		switch (scsi_status) {
-		case SCSI_STATUS_OK:
-		case SCSI_STATUS_COND_MET:
-		case SCSI_STATUS_INTERMED:
-		case SCSI_STATUS_INTERMED_COND_MET:
-			err_action = SS_NOP;
-			break;
-		case SCSI_STATUS_CMD_TERMINATED:
-		case SCSI_STATUS_CHECK_COND:
-			if (sense != 0) {
-				struct scsi_sense_data *sense;
-
-				sense = (struct scsi_sense_data *)
-				    &cmd->sense_buffer;
-				err_action =
-				    aic_sense_error_action(sense, inq_data, 0);
-
-			} else {
-				err_action = SS_RETRY|SSQ_FALLBACK
-					   | SSQ_DECREMENT_COUNT|EIO;
-			}
-			break;
-		case SCSI_STATUS_QUEUE_FULL:
-		case SCSI_STATUS_BUSY:
-			err_action = SS_RETRY|SSQ_DELAY|SSQ_MANY
-				   | SSQ_DECREMENT_COUNT|EBUSY;
-			break;
-		case SCSI_STATUS_RESERV_CONFLICT:
-		default:
-			err_action = SS_FAIL|EBUSY;
-			break;
-		}
-		break;
-	case CAM_REQ_CMP_ERR:
-	case CAM_CMD_TIMEOUT:
-	case CAM_UNEXP_BUSFREE:
-	case CAM_UNCOR_PARITY:
-	case CAM_DATA_RUN_ERR:
-		err_action = SS_RETRY|SSQ_FALLBACK|EIO;
-		break;
-	case CAM_UA_ABORT:
-	case CAM_UA_TERMIO:
-	case CAM_MSG_REJECT_REC:
-	case CAM_SEL_TIMEOUT:
-		err_action = SS_FAIL|EIO;
-		break;
-	case CAM_REQ_INVALID:
-	case CAM_PATH_INVALID:
-	case CAM_DEV_NOT_THERE:
-	case CAM_NO_HBA:
-	case CAM_PROVIDE_FAIL:
-	case CAM_REQ_TOO_BIG:		
-	case CAM_RESRC_UNAVAIL:
-	case CAM_BUSY:
-	default:
-		/* panic??  These should never occur in our application. */
-		err_action = SS_FAIL|EIO;
-		break;
-	case CAM_SCSI_BUS_RESET:
-	case CAM_BDR_SENT:		
-	case CAM_REQUEUE_REQ:
-		/* Unconditional requeue */
-		err_action = SS_RETRY;
-		break;
-	}
-
-	return (err_action);
-}
-
 static void
 ahc_linux_dv_fill_cmd(struct ahc_softc *ahc, struct scsi_cmnd *cmd,
 		      struct ahc_devinfo *devinfo)
 {
 	memset(cmd, 0, sizeof(struct scsi_cmnd));
-	cmd->host = ahc->platform_data->host;
+	cmd->device = ahc->platform_data->dv_scsi_dev;
 	cmd->scsi_done = ahc_linux_dv_complete;
-	cmd->target = devinfo->target;
-	cmd->lun = devinfo->lun;
-	cmd->channel = devinfo->channel - 'A';
 }
 
 /*
@@ -3332,23 +3278,6 @@ ahc_linux_dv_su(struct ahc_softc *ahc, struct scsi_cmnd *cmd,
 	cmd->cmnd[4] = le | SSS_START;
 }
 
-/*
- * Return speed in KB/s.
- */
-static u_int
-ahc_linux_calc_speed(u_int width, u_int period, u_int offset)
-{
-	u_int freq;
-
-	if (offset != 0)
-		freq  = aic_calc_syncsrate(period);
-	else
-		/* Roughly 3.3MB/s for async */
-		freq  = 3300;
-	freq <<= width;
-	return (freq);
-}
-
 static int
 ahc_linux_fallback(struct ahc_softc *ahc, struct ahc_devinfo *devinfo)
 {
@@ -3396,14 +3325,17 @@ ahc_linux_fallback(struct ahc_softc *ahc, struct ahc_devinfo *devinfo)
 	if (targ->dv_last_ppr_options == 0)
 		targ->dv_last_ppr_options = ppr_options;
 
-	cur_speed = ahc_linux_calc_speed(width, period, offset);
-	wide_speed = ahc_linux_calc_speed(MSG_EXT_WDTR_BUS_16_BIT,
+	cur_speed = aic_calc_speed(width, period, offset, AHC_SYNCRATE_MIN);
+	wide_speed = aic_calc_speed(MSG_EXT_WDTR_BUS_16_BIT,
 					  targ->dv_next_wide_period,
-					  MAX_OFFSET);
-	narrow_speed = ahc_linux_calc_speed(MSG_EXT_WDTR_BUS_8_BIT,
+					  MAX_OFFSET,
+					  AHC_SYNCRATE_MIN);
+	narrow_speed = aic_calc_speed(MSG_EXT_WDTR_BUS_8_BIT,
 					    targ->dv_next_narrow_period,
-					    MAX_OFFSET);
-	fallback_speed = ahc_linux_calc_speed(width, period+1, offset);
+					    MAX_OFFSET,
+					    AHC_SYNCRATE_MIN);
+	fallback_speed = aic_calc_speed(width, period+1, offset,
+					AHC_SYNCRATE_MIN);
 #ifdef AHC_DEBUG
 	if (ahc_debug & AHC_SHOW_DV) {
 		printf("cur_speed= %d, wide_speed= %d, narrow_speed= %d, "
@@ -3537,7 +3469,7 @@ ahc_linux_dv_timeout(struct scsi_cmnd *cmd)
 	struct	scb *scb;
 	u_long	flags;
 
-	ahc = *((struct ahc_softc **)cmd->host->hostdata);
+	ahc = *((struct ahc_softc **)cmd->device->host->hostdata);
 	ahc_lock(ahc, &flags);
 
 #ifdef AHC_DEBUG
@@ -3565,7 +3497,7 @@ ahc_linux_dv_timeout(struct scsi_cmnd *cmd)
 		ahc_set_transaction_status(scb, CAM_AUTOSENSE_FAIL);
 	else
 		ahc_set_transaction_status(scb, CAM_CMD_TIMEOUT);
-	ahc_reset_channel(ahc, cmd->channel + 'A', /*initiate*/TRUE);
+	ahc_reset_channel(ahc, cmd->device->channel + 'A', /*initiate*/TRUE);
 
 	/*
 	 * Add a minimal bus settle delay for devices that are slow to
@@ -3615,7 +3547,7 @@ ahc_linux_dv_complete(struct scsi_cmnd *cmd)
 {
 	struct ahc_softc *ahc;
 
-	ahc = *((struct ahc_softc **)cmd->host->hostdata);
+	ahc = *((struct ahc_softc **)cmd->device->host->hostdata);
 
 	/* Delete the DV timer before it goes off! */
 	scsi_delete_timer(cmd);
@@ -3623,7 +3555,8 @@ ahc_linux_dv_complete(struct scsi_cmnd *cmd)
 #ifdef AHC_DEBUG
 	if (ahc_debug & AHC_SHOW_DV)
 		printf("%s:%d:%d: Command completed, status= 0x%x\n",
-		       ahc_name(ahc), cmd->channel, cmd->target, cmd->result);
+		       ahc_name(ahc), cmd->device->channel,
+		       cmd->device->id, cmd->result);
 #endif
 
 	/* Wake up the state machine */
@@ -4250,7 +4183,34 @@ ahc_send_async(struct ahc_softc *ahc, char channel,
 		break;
 	}
         case AC_SENT_BDR:
+	{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
+		Scsi_Device *scsi_dev;
+
+		/*
+		 * Find the SCSI device associated with this
+		 * request and indicate that a UA is expected.
+		 * XXX This should really be handled by the mid-layer.
+		 */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
+		list_for_each_entry(scsi_dev,
+				    &ahc->platform_data->host->my_devices,
+				    siblings) {
+#else
+		for (scsi_dev = ahc->platform_data->host->host_queue;
+		     scsi_dev != NULL; scsi_dev = scsi_dev->next) {
+#endif
+			if (channel - 'A' == scsi_dev->channel
+			 && target == scsi_dev->id
+			 && (lun == CAM_LUN_WILDCARD
+			  || lun == scsi_dev->lun)) {
+				scsi_dev->was_reset = 1;
+				scsi_dev->expecting_cc_ua = 1;
+			}
+		}
+#endif
 		break;
+	}
         case AC_BUS_RESET:
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
 		if (ahc->platform_data->host != NULL) {
@@ -4376,8 +4336,8 @@ ahc_done(struct ahc_softc *ahc, struct scb *scb)
 		if (ahc_get_transaction_status(scb) == CAM_BDR_SENT
 		 || ahc_get_transaction_status(scb) == CAM_REQ_ABORTED)
 			ahc_set_transaction_status(scb, CAM_CMD_TIMEOUT);
-		if ((scb->platform_data->flags & AHC_UP_EH_SEMAPHORE) != 0) {
-			scb->platform_data->flags &= ~AHC_UP_EH_SEMAPHORE;
+		if ((ahc->platform_data->flags & AHC_UP_EH_SEMAPHORE) != 0) {
+			ahc->platform_data->flags &= ~AHC_UP_EH_SEMAPHORE;
 			up(&ahc->platform_data->eh_sem);
 		}
 	}
@@ -4446,8 +4406,11 @@ ahc_linux_handle_scsi_status(struct ahc_softc *ahc,
 
 				printf("Copied %d bytes of sense data:",
 				       sense_size);
-				for (i = 0; i < sense_size; i++)
-					printf(" 0x%x", cmd->sense_buffer[i]);
+				for (i = 0; i < sense_size; i++) {
+					if ((i & 0xF) == 0)
+						printf("\n");
+					printf("0x%x ", cmd->sense_buffer[i]);
+				}
 				printf("\n");
 			}
 #endif
@@ -4621,6 +4584,7 @@ ahc_linux_queue_cmd_complete(struct ahc_softc *ahc, Scsi_Cmnd *cmd)
 			 * evoke a retry even if this command is being sent
 			 * via the eh thread.  Ick!  Ick!  Ick!
 			 */
+			if (cmd->retries > 0)
 				cmd->retries--;
 			new_status = DID_OK;
 			ahc_cmd_set_scsi_status(cmd, SCSI_STATUS_CHECK_COND);
@@ -4856,6 +4820,7 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 	u_int  saved_scbptr;
 	u_int  active_scb_index;
 	u_int  last_phase;
+	u_int  saved_scsiid;
 	int    retval;
 	int    paused;
 	int    wait;
@@ -4864,11 +4829,12 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 	pending_scb = NULL;
 	paused = FALSE;
 	wait = FALSE;
-	ahc = *(struct ahc_softc **)cmd->host->hostdata;
+	ahc = *(struct ahc_softc **)cmd->device->host->hostdata;
 	acmd = (struct ahc_cmd *)cmd;
 
 	printf("%s:%d:%d:%d: Attempting to queue a%s message\n",
-	       ahc_name(ahc), cmd->channel, cmd->target, cmd->lun,
+	       ahc_name(ahc), cmd->device->channel,
+	       cmd->device->id, cmd->device->lun,
 	       flag == SCB_ABORT ? "n ABORT" : " TARGET RESET");
 
 	/*
@@ -4897,8 +4863,8 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 	 * at all, and the system wanted us to just abort the
 	 * command return success.
 	 */
-	dev = ahc_linux_get_device(ahc, cmd->channel, cmd->target,
-				   cmd->lun, /*alloc*/FALSE);
+	dev = ahc_linux_get_device(ahc, cmd->device->channel, cmd->device->id,
+				   cmd->device->lun, /*alloc*/FALSE);
 
 	if (dev == NULL) {
 		/*
@@ -4906,7 +4872,8 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 		 * so we must not still own the command.
 		 */
 		printf("%s:%d:%d:%d: Is not an active device\n",
-		       ahc_name(ahc), cmd->channel, cmd->target, cmd->lun);
+		       ahc_name(ahc), cmd->device->channel, cmd->device->id,
+		       cmd->device->lun);
 		retval = SUCCESS;
 		goto no_cmd;
 	}
@@ -4918,7 +4885,8 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 
 	if (list_acmd != NULL) {
 		printf("%s:%d:%d:%d: Command found on device queue\n",
-		       ahc_name(ahc), cmd->channel, cmd->target, cmd->lun);
+		       ahc_name(ahc), cmd->device->channel, cmd->device->id,
+		       cmd->device->lun);
 		if (flag == SCB_ABORT) {
 			TAILQ_REMOVE(&dev->busyq, list_acmd, acmd_links.tqe);
 			cmd->result = DID_ABORT << 16;
@@ -4929,11 +4897,13 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 	}
 
 	if ((dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED)) == 0
-	 && ahc_search_untagged_queues(ahc, cmd, cmd->target,
-				       cmd->channel + 'A', cmd->lun,
+	 && ahc_search_untagged_queues(ahc, cmd, cmd->device->id,
+				       cmd->device->channel + 'A',
+				       cmd->device->lun,
 				       CAM_REQ_ABORTED, SEARCH_COMPLETE) != 0) {
 		printf("%s:%d:%d:%d: Command found on untagged queue\n",
-		       ahc_name(ahc), cmd->channel, cmd->target, cmd->lun);
+		       ahc_name(ahc), cmd->device->channel, cmd->device->id,
+		       cmd->device->lun);
 		retval = SUCCESS;
 		goto done;
 	}
@@ -4950,8 +4920,9 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 
 		/* Any SCB for this device will do for a target reset */
 		LIST_FOREACH(pending_scb, &ahc->pending_scbs, pending_links) {
-		  	if (ahc_match_scb(ahc, pending_scb, cmd->target,
-					  cmd->channel + 'A', CAM_LUN_WILDCARD,
+		  	if (ahc_match_scb(ahc, pending_scb, cmd->device->id,
+					  cmd->device->channel + 'A',
+					  CAM_LUN_WILDCARD,
 					  SCB_LIST_NULL, ROLE_INITIATOR) == 0)
 				break;
 		}
@@ -4959,7 +4930,8 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 
 	if (pending_scb == NULL) {
 		printf("%s:%d:%d:%d: Command not found\n",
-		       ahc_name(ahc), cmd->channel, cmd->target, cmd->lun);
+		       ahc_name(ahc), cmd->device->channel, cmd->device->id,
+		       cmd->device->lun);
 		goto no_cmd;
 	}
 
@@ -4983,24 +4955,28 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 
 	if ((pending_scb->flags & SCB_ACTIVE) == 0) {
 		printf("%s:%d:%d:%d: Command already completed\n",
-		       ahc_name(ahc), cmd->channel, cmd->target, cmd->lun);
+		       ahc_name(ahc), cmd->device->channel, cmd->device->id,
+		       cmd->device->lun);
 		goto no_cmd;
 	}
 
 	disconnected = TRUE;
 	if (flag == SCB_ABORT) {
-		if (ahc_search_qinfifo(ahc, cmd->target, cmd->channel + 'A',
-				       cmd->lun, pending_scb->hscb->tag,
+		if (ahc_search_qinfifo(ahc, cmd->device->id,
+				       cmd->device->channel + 'A',
+				       cmd->device->lun,
+				       pending_scb->hscb->tag,
 				       ROLE_INITIATOR, CAM_REQ_ABORTED,
 				       SEARCH_COMPLETE) > 0) {
 			printf("%s:%d:%d:%d: Cmd aborted from QINFIFO\n",
-			       ahc_name(ahc), cmd->channel, cmd->target,
-					cmd->lun);
+			       ahc_name(ahc), cmd->device->channel,
+					cmd->device->id, cmd->device->lun);
 			retval = SUCCESS;
 			goto done;
 		}
-	} else if (ahc_search_qinfifo(ahc, cmd->target, cmd->channel + 'A',
-				      cmd->lun, pending_scb->hscb->tag,
+	} else if (ahc_search_qinfifo(ahc, cmd->device->id,
+				      cmd->device->channel + 'A',
+				      cmd->device->lun, pending_scb->hscb->tag,
 				      ROLE_INITIATOR, /*status*/0,
 				      SEARCH_COUNT) > 0) {
 		disconnected = FALSE;
@@ -5029,10 +5005,11 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 	last_phase = ahc_inb(ahc, LASTPHASE);
 	saved_scbptr = ahc_inb(ahc, SCBPTR);
 	active_scb_index = ahc_inb(ahc, SCB_TAG);
+	saved_scsiid = ahc_inb(ahc, SAVED_SCSIID);
 	if (last_phase != P_BUSFREE
 	 && (pending_scb->hscb->tag == active_scb_index
 	  || (flag == SCB_DEVICE_RESET
-	   && SCSIID_TARGET(ahc, ahc_inb(ahc, SAVED_SCSIID)) == cmd->target))) {
+	   && SCSIID_TARGET(ahc, saved_scsiid) == cmd->device->id))) {
 
 		/*
 		 * We're active on the bus, so assert ATN
@@ -5043,7 +5020,8 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 		ahc_outb(ahc, MSG_OUT, HOST_MSG);
 		ahc_outb(ahc, SCSISIGO, last_phase|ATNO);
 		printf("%s:%d:%d:%d: Device is active, asserting ATN\n",
-		       ahc_name(ahc), cmd->channel, cmd->target, cmd->lun);
+		       ahc_name(ahc), cmd->device->channel, cmd->device->id,
+		       cmd->device->lun);
 		wait = TRUE;
 	} else if (disconnected) {
 
@@ -5073,8 +5051,9 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 		 * same element in the SCB, SCB_NEXT, for
 		 * both the qinfifo and the disconnected list.
 		 */
-		ahc_search_disc_list(ahc, cmd->target, cmd->channel + 'A',
-				     cmd->lun, pending_scb->hscb->tag,
+		ahc_search_disc_list(ahc, cmd->device->id,
+				     cmd->device->channel + 'A',
+				     cmd->device->lun, pending_scb->hscb->tag,
 				     /*stop_on_first*/TRUE,
 				     /*remove*/TRUE,
 				     /*save_state*/FALSE);
@@ -5097,19 +5076,20 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 		 * so we are the next SCB for this target
 		 * to run.
 		 */
-		ahc_search_qinfifo(ahc, cmd->target, cmd->channel + 'A',
-				   cmd->lun, SCB_LIST_NULL, ROLE_INITIATOR,
-				   CAM_REQUEUE_REQ, SEARCH_COMPLETE);
-		ahc_print_path(ahc, pending_scb);
-		printf("Queuing a recovery SCB\n");
+		ahc_search_qinfifo(ahc, cmd->device->id,
+				   cmd->device->channel + 'A',
+				   cmd->device->lun, SCB_LIST_NULL,
+				   ROLE_INITIATOR, CAM_REQUEUE_REQ,
+				   SEARCH_COMPLETE);
 		ahc_qinfifo_requeue_tail(ahc, pending_scb);
 		ahc_outb(ahc, SCBPTR, saved_scbptr);
-		printf("%s:%d:%d:%d: Device is disconnected, re-queuing SCB\n",
-		       ahc_name(ahc), cmd->channel, cmd->target, cmd->lun);
+		ahc_print_path(ahc, pending_scb);
+		printf("Device is disconnected, re-queuing SCB\n");
 		wait = TRUE;
 	} else {
 		printf("%s:%d:%d:%d: Unable to deliver message\n",
-		       ahc_name(ahc), cmd->channel, cmd->target, cmd->lun);
+		       ahc_name(ahc), cmd->channel, cmd->device->id,
+		       cmd->device->lun);
 		retval = FAILED;
 		goto done;
 	}
@@ -5129,7 +5109,7 @@ ahc_linux_queue_recovery_cmd(Scsi_Cmnd *cmd, scb_flag flag)
 		struct timer_list timer;
 		int ret;
 
-		pending_scb->platform_data->flags |= AHC_UP_EH_SEMAPHORE;
+		ahc->platform_data->flags |= AHC_UP_EH_SEMAPHORE;
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
 		ahc_unlock(ahc, &s);
 #else

drivers/scsi/aic7xxx/aic7xxx_osm.h

@@ -53,7 +53,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic7xxx_osm.h#118 $
+ * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic7xxx_osm.h#121 $
  *
  */
 #ifndef _AIC7XXX_LINUX_H_
@@ -90,7 +90,6 @@
 #define AIC_LIB_PREFIX ahc
 #include "scsi.h"
 #include "hosts.h"
-#include "aiclib.h"
 
 /* Name space conflict with BSD queue macros */
 #ifdef LIST_HEAD
@@ -100,6 +99,7 @@
 #include "cam.h"
 #include "queue.h"
 #include "scsi_message.h"
+#include "aiclib.h"
 
 /*********************************** Debugging ********************************/
 #ifdef CONFIG_AIC7XXX_DEBUG_ENABLE
@@ -497,7 +497,7 @@ struct ahc_linux_target {
  * Per-SCB OSM storage.
  */
 typedef enum {
-	AHC_UP_EH_SEMAPHORE
+	AHC_UP_EH_SEMAPHORE = 0x1
 } ahc_linux_scb_flags;
 
 struct scb_platform_data {
@@ -550,6 +550,7 @@ struct ahc_platform_data {
 	struct semaphore	 dv_cmd_sem;	/* XXX This needs to be in
 						 * the target struct
 						 */
+	struct scsi_device	*dv_scsi_dev;
 	struct Scsi_Host        *host;		/* pointer to scsi host */
 #define AHC_LINUX_NOIRQ	((uint32_t)~0)
 	uint32_t		 irq;		/* IRQ for this adapter */

drivers/scsi/aic7xxx/aic7xxx_pci.c

@@ -39,7 +39,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGES.
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic7xxx_pci.c#55 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic7xxx_pci.c#57 $
  *
  * $FreeBSD$
  */
@@ -641,6 +641,7 @@ const u_int ahc_num_pci_devs = NUM_ELEMENTS(ahc_pci_ident_table);
 #define AHC_494X_SLOT_CHANNEL_D	7
 
 #define	DEVCONFIG		0x40
+#define		PCIERRGENDIS	0x80000000ul
 #define		SCBSIZE32	0x00010000ul	/* aic789X only */
 #define		REXTVALID	0x00001000ul	/* ultra cards only */
 #define		MPORTMODE	0x00000400ul	/* aic7870+ only */
@@ -785,6 +786,7 @@ ahc_pci_config(struct ahc_softc *ahc, struct ahc_pci_identity *entry)
 	u_int	 sxfrctl1;
 	u_int	 scsiseq;
 	u_int	 dscommand0;
+	uint32_t devconfig;
 	int	 error;
 	uint8_t	 sblkctl;
 
@@ -809,6 +811,8 @@ ahc_pci_config(struct ahc_softc *ahc, struct ahc_pci_identity *entry)
 	 */
 	ahc_intr_enable(ahc, FALSE);
 
+	devconfig = ahc_pci_read_config(ahc->dev_softc, DEVCONFIG, /*bytes*/4);
+
 	/*
 	 * If we need to support high memory, enable dual
 	 * address cycles.  This bit must be set to enable
@@ -816,21 +820,30 @@ ahc_pci_config(struct ahc_softc *ahc, struct ahc_pci_identity *entry)
 	 * 64bit bus (PCI64BIT set in devconfig).
 	 */
 	if ((ahc->flags & AHC_39BIT_ADDRESSING) != 0) {
-		uint32_t devconfig;
 
 		if (bootverbose)
 			printf("%s: Enabling 39Bit Addressing\n",
 			       ahc_name(ahc));
-		devconfig = ahc_pci_read_config(ahc->dev_softc,
-						DEVCONFIG, /*bytes*/4);
 		devconfig |= DACEN;
-		ahc_pci_write_config(ahc->dev_softc, DEVCONFIG,
-				     devconfig, /*bytes*/4);
 	}
 	
+	/* Ensure that pci error generation, a test feature, is disabled. */
+	devconfig |= PCIERRGENDIS;
+
+	ahc_pci_write_config(ahc->dev_softc, DEVCONFIG, devconfig, /*bytes*/4);
+
 	/* Ensure busmastering is enabled */
 	command = ahc_pci_read_config(ahc->dev_softc, PCIR_COMMAND, /*bytes*/1);
 	command |= PCIM_CMD_BUSMASTEREN;
+
+	/*
+	 * Disable PCI parity error reporting.  Users typically
+	 * do this to work around broken PCI chipsets that get
+	 * the parity timing wrong and thus generate lots of spurious
+	 * errors.
+	 */
+	if ((ahc->flags & AHC_DISABLE_PCI_PERR) != 0)
+		command &= ~PCIM_CMD_PERRESPEN;
 	ahc_pci_write_config(ahc->dev_softc, PCIR_COMMAND, command, /*bytes*/1);
 
 	/* On all PCI adapters, we allow SCB paging */
@@ -947,7 +960,8 @@ ahc_pci_config(struct ahc_softc *ahc, struct ahc_pci_identity *entry)
 		 * a SEEPROM.
 		 */
 		/* See if someone else set us up already */
-		if (scsiseq != 0) {
+		if ((ahc->flags & AHC_NO_BIOS_INIT) == 0
+		 && scsiseq != 0) {
 			printf("%s: Using left over BIOS settings\n",
 				ahc_name(ahc));
 			ahc->flags &= ~AHC_USEDEFAULTS;

drivers/scsi/aic7xxx/aic7xxx_reg.h_shipped

@@ -2,7 +2,7 @@
  * DO NOT EDIT - This file is automatically generated
  *		 from the following source files:
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.seq#53 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.seq#54 $
  * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.reg#37 $
  */
 typedef int (ahc_reg_print_t)(u_int, u_int *, u_int);

drivers/scsi/aic7xxx/aic7xxx_reg_print.c_shipped

@@ -2,7 +2,7 @@
  * DO NOT EDIT - This file is automatically generated
  *		 from the following source files:
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.seq#53 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.seq#54 $
  * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.reg#37 $
  */
 

drivers/scsi/aic7xxx/aic7xxx_seq.h_shipped

@@ -2,13 +2,13 @@
  * DO NOT EDIT - This file is automatically generated
  *		 from the following source files:
  *
- * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.seq#53 $
+ * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.seq#54 $
  * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.reg#37 $
  */
 static uint8_t seqprog[] = {
 	0xb2, 0x00, 0x00, 0x08,
 	0xf7, 0x11, 0x22, 0x08,
-	0x00, 0x65, 0xea, 0x59,
+	0x00, 0x65, 0xec, 0x59,
 	0xf7, 0x01, 0x02, 0x08,
 	0xff, 0x6a, 0x24, 0x08,
 	0x40, 0x00, 0x40, 0x68,
@@ -21,15 +21,15 @@ static uint8_t seqprog[] = {
 	0x01, 0x4d, 0xc8, 0x30,
 	0x00, 0x4c, 0x12, 0x70,
 	0x01, 0x39, 0xa2, 0x30,
-	0x00, 0x6a, 0xd2, 0x5e,
+	0x00, 0x6a, 0xd4, 0x5e,
 	0x01, 0x51, 0x20, 0x31,
 	0x01, 0x57, 0xae, 0x00,
 	0x0d, 0x6a, 0x76, 0x00,
-	0x00, 0x51, 0x24, 0x5e,
+	0x00, 0x51, 0x26, 0x5e,
 	0x01, 0x51, 0xc8, 0x30,
 	0x00, 0x39, 0xc8, 0x60,
 	0x00, 0xbb, 0x30, 0x70,
-	0xc1, 0x6a, 0xea, 0x5e,
+	0xc1, 0x6a, 0xec, 0x5e,
 	0x01, 0xbf, 0x72, 0x30,
 	0x01, 0x40, 0x7e, 0x31,
 	0x01, 0x90, 0x80, 0x30,
@@ -46,13 +46,13 @@ static uint8_t seqprog[] = {
 	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, 0x0e, 0x5e,
+	0x48, 0x6a, 0x10, 0x5e,
 	0x01, 0x6a, 0xdc, 0x01,
 	0x88, 0x6a, 0xcc, 0x00,
-	0x48, 0x6a, 0x0e, 0x5e,
+	0x48, 0x6a, 0x10, 0x5e,
 	0x01, 0x6a, 0x26, 0x01,
 	0xf0, 0x19, 0x7a, 0x08,
 	0x0f, 0x18, 0xc8, 0x08,
@@ -63,7 +63,7 @@ static uint8_t seqprog[] = {
 	0x80, 0x3d, 0x7a, 0x00,
 	0x01, 0x3d, 0xd8, 0x31,
 	0x01, 0x3d, 0x32, 0x31,
-	0x10, 0x03, 0x4c, 0x79,
+	0x10, 0x03, 0x4e, 0x79,
 	0x00, 0x65, 0xf2, 0x58,
 	0x80, 0x66, 0xae, 0x78,
 	0x01, 0x66, 0xd8, 0x31,
@@ -79,7 +79,7 @@ static uint8_t seqprog[] = {
 	0x00, 0x65, 0xaa, 0x48,
 	0x01, 0x66, 0xd8, 0x31,
 	0x01, 0x66, 0x32, 0x31,
-	0x10, 0x03, 0x4c, 0x79,
+	0x10, 0x03, 0x4e, 0x79,
 	0x00, 0x65, 0xf2, 0x58,
 	0x01, 0x66, 0xd8, 0x31,
 	0x01, 0x66, 0x32, 0x31,
@@ -87,13 +87,13 @@ static uint8_t seqprog[] = {
 	0x40, 0x3c, 0x78, 0x00,
 	0xff, 0x6a, 0xd8, 0x01,
 	0xff, 0x6a, 0x32, 0x01,
-	0x10, 0x6a, 0x78, 0x00,
+	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, 0xea, 0x5e,
+	0x61, 0x6a, 0xec, 0x5e,
 	0x08, 0x51, 0x20, 0x71,
 	0x02, 0x0b, 0xb2, 0x78,
 	0x00, 0x65, 0xae, 0x40,
@@ -105,8 +105,8 @@ static uint8_t seqprog[] = {
 	0x08, 0x1f, 0xc4, 0x78,
 	0x80, 0x3d, 0x7a, 0x00,
 	0x20, 0x6a, 0x16, 0x00,
-	0x00, 0x65, 0xca, 0x41,
-	0x00, 0x65, 0xc4, 0x5e,
+	0x00, 0x65, 0xcc, 0x41,
+	0x00, 0x65, 0xc6, 0x5e,
 	0x00, 0x65, 0x12, 0x40,
 	0x20, 0x11, 0xd2, 0x68,
 	0x20, 0x6a, 0x18, 0x00,
@@ -137,57 +137,58 @@ static uint8_t seqprog[] = {
 	0x01, 0xb9, 0x7a, 0x30,
 	0x01, 0xba, 0x7c, 0x30,
 	0x00, 0x65, 0xea, 0x58,
-	0x80, 0x0b, 0xc2, 0x79,
+	0x80, 0x0b, 0xc4, 0x79,
 	0x12, 0x01, 0x02, 0x00,
 	0x01, 0xab, 0xac, 0x30,
-	0xe4, 0x6a, 0x80, 0x5d,
+	0xe4, 0x6a, 0x82, 0x5d,
 	0x40, 0x6a, 0x16, 0x00,
-	0x80, 0xba, 0x96, 0x5d,
+	0x80, 0xba, 0x98, 0x5d,
 	0x20, 0xb8, 0x18, 0x79,
-	0x20, 0x6a, 0x96, 0x5d,
-	0x00, 0xab, 0x96, 0x5d,
+	0x20, 0x6a, 0x98, 0x5d,
+	0x00, 0xab, 0x98, 0x5d,
 	0x01, 0xa9, 0x78, 0x30,
 	0x10, 0xb8, 0x20, 0x79,
-	0xe4, 0x6a, 0x80, 0x5d,
+	0xe4, 0x6a, 0x82, 0x5d,
 	0x00, 0x65, 0xae, 0x40,
 	0x10, 0x03, 0x3c, 0x69,
-	0x08, 0x3c, 0x58, 0x69,
-	0x04, 0x3c, 0x90, 0x69,
-	0x02, 0x3c, 0x96, 0x69,
-	0x01, 0x3c, 0x42, 0x79,
+	0x08, 0x3c, 0x5a, 0x69,
+	0x04, 0x3c, 0x92, 0x69,
+	0x02, 0x3c, 0x98, 0x69,
+	0x01, 0x3c, 0x44, 0x79,
 	0xff, 0x6a, 0x70, 0x00,
-	0x00, 0x65, 0xa2, 0x59,
-	0x00, 0x6a, 0xd2, 0x5e,
+	0x00, 0x65, 0xa4, 0x59,
+	0x00, 0x6a, 0xd4, 0x5e,
 	0xff, 0x38, 0x30, 0x71,
 	0x0d, 0x6a, 0x76, 0x00,
-	0x00, 0x38, 0x24, 0x5e,
+	0x00, 0x38, 0x26, 0x5e,
 	0x00, 0x65, 0xea, 0x58,
 	0x12, 0x01, 0x02, 0x00,
 	0x00, 0x65, 0x18, 0x41,
 	0xa4, 0x6a, 0x06, 0x00,
 	0x00, 0x65, 0xf2, 0x58,
+	0xfd, 0x57, 0xae, 0x08,
 	0x00, 0x65, 0xae, 0x40,
-	0xe4, 0x6a, 0x80, 0x5d,
-	0x20, 0x3c, 0x48, 0x79,
-	0x02, 0x6a, 0x96, 0x5d,
-	0x04, 0x6a, 0x96, 0x5d,
-	0x01, 0x03, 0x4a, 0x69,
+	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, 0xa2, 0x59,
+	0x00, 0x65, 0xa4, 0x59,
 	0x00, 0x65, 0x04, 0x40,
 	0x80, 0x86, 0xc8, 0x08,
 	0x01, 0x4f, 0xc8, 0x30,
-	0x00, 0x50, 0x6a, 0x61,
-	0xc4, 0x6a, 0x80, 0x5d,
-	0x40, 0x3c, 0x66, 0x79,
-	0x28, 0x6a, 0x96, 0x5d,
-	0x00, 0x65, 0x4a, 0x41,
-	0x08, 0x6a, 0x96, 0x5d,
-	0x00, 0x65, 0x4a, 0x41,
-	0x84, 0x6a, 0x80, 0x5d,
+	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,
@@ -195,62 +196,62 @@ static uint8_t seqprog[] = {
 	0x5b, 0x64, 0xc8, 0x28,
 	0x30, 0x64, 0xca, 0x18,
 	0x01, 0x6c, 0xc8, 0x30,
-	0xff, 0x64, 0x8c, 0x79,
+	0xff, 0x64, 0x8e, 0x79,
 	0x08, 0x01, 0x02, 0x00,
-	0x02, 0x0b, 0x7e, 0x79,
-	0x01, 0x64, 0x84, 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, 0x7e, 0x69,
+	0xff, 0x64, 0x80, 0x69,
 	0xf7, 0x3c, 0x78, 0x08,
 	0x00, 0x65, 0x20, 0x41,
 	0x40, 0xaa, 0x7e, 0x10,
-	0x04, 0xaa, 0x80, 0x5d,
-	0x00, 0x65, 0x5c, 0x42,
-	0xc4, 0x6a, 0x80, 0x5d,
+	0x04, 0xaa, 0x82, 0x5d,
+	0x00, 0x65, 0x5e, 0x42,
+	0xc4, 0x6a, 0x82, 0x5d,
 	0xc0, 0x6a, 0x7e, 0x00,
-	0x00, 0xa8, 0x96, 0x5d,
+	0x00, 0xa8, 0x98, 0x5d,
 	0xe4, 0x6a, 0x06, 0x00,
-	0x00, 0x6a, 0x96, 0x5d,
-	0x00, 0x65, 0x4a, 0x41,
-	0x10, 0x3c, 0xa6, 0x69,
-	0x00, 0xbb, 0x9c, 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, 0xae, 0x79,
+	0x80, 0xee, 0xb0, 0x79,
 	0xff, 0x6a, 0xdc, 0x09,
 	0x01, 0x93, 0x26, 0x01,
 	0x03, 0x6a, 0x2a, 0x01,
 	0x01, 0x69, 0x32, 0x31,
-	0x1c, 0x6a, 0xf2, 0x5d,
+	0x1c, 0x6a, 0xf4, 0x5d,
 	0x0a, 0x93, 0x26, 0x01,
-	0x00, 0x65, 0xba, 0x5e,
+	0x00, 0x65, 0xbc, 0x5e,
 	0x01, 0x50, 0xa0, 0x18,
 	0x02, 0x6a, 0x22, 0x05,
 	0x1a, 0x01, 0x02, 0x00,
 	0x80, 0x6a, 0x74, 0x00,
 	0x40, 0x6a, 0x78, 0x00,
 	0x40, 0x6a, 0x16, 0x00,
-	0x00, 0x65, 0xea, 0x5d,
+	0x00, 0x65, 0xec, 0x5d,
 	0x01, 0x3f, 0xc8, 0x30,
-	0xbf, 0x64, 0x5c, 0x7a,
-	0x80, 0x64, 0xb0, 0x73,
-	0xa0, 0x64, 0x12, 0x74,
-	0xc0, 0x64, 0x06, 0x74,
-	0xe0, 0x64, 0x42, 0x74,
-	0x01, 0x6a, 0xea, 0x5e,
-	0x00, 0x65, 0xca, 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, 0xe4, 0x79,
+	0x09, 0x0c, 0xe6, 0x79,
 	0x08, 0x0c, 0x04, 0x68,
-	0xb1, 0x6a, 0xea, 0x5e,
+	0xb1, 0x6a, 0xec, 0x5e,
 	0xff, 0x6a, 0x26, 0x09,
 	0x12, 0x01, 0x02, 0x00,
 	0x02, 0x6a, 0x08, 0x30,
@@ -263,33 +264,33 @@ static uint8_t seqprog[] = {
 	0x00, 0xa5, 0x4a, 0x21,
 	0x00, 0xa6, 0x4c, 0x21,
 	0x00, 0xa7, 0x4e, 0x25,
-	0x08, 0xeb, 0xee, 0x7e,
-	0x80, 0xeb, 0x04, 0x7a,
+	0x08, 0xeb, 0xf0, 0x7e,
+	0x80, 0xeb, 0x06, 0x7a,
 	0xff, 0x6a, 0xd6, 0x09,
-	0x08, 0xeb, 0x08, 0x6a,
+	0x08, 0xeb, 0x0a, 0x6a,
 	0xff, 0x6a, 0xd4, 0x0c,
-	0x80, 0xa3, 0xee, 0x6e,
-	0x88, 0xeb, 0x1e, 0x72,
-	0x08, 0xeb, 0xee, 0x6e,
-	0x04, 0xea, 0x22, 0xe2,
-	0x08, 0xee, 0xee, 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, 0x06, 0x5a,
+	0x00, 0x65, 0x08, 0x5a,
 	0x06, 0xa4, 0xd4, 0x89,
-	0x80, 0x94, 0xee, 0x7e,
+	0x80, 0x94, 0xf0, 0x7e,
 	0x07, 0xe9, 0x10, 0x31,
-	0x01, 0x8c, 0x2a, 0x7a,
+	0x01, 0x8c, 0x2c, 0x7a,
 	0x01, 0x55, 0xaa, 0x10,
 	0x01, 0xe9, 0x46, 0x31,
-	0x00, 0xa3, 0xcc, 0x5e,
-	0x00, 0x65, 0xf8, 0x59,
+	0x00, 0xa3, 0xce, 0x5e,
+	0x00, 0x65, 0xfa, 0x59,
 	0x01, 0xa4, 0xca, 0x30,
-	0x01, 0x55, 0x36, 0x7a,
+	0x01, 0x55, 0x38, 0x7a,
 	0x04, 0x65, 0xca, 0x00,
-	0x80, 0xa3, 0x3a, 0x7a,
+	0x80, 0xa3, 0x3c, 0x7a,
 	0x02, 0x65, 0xca, 0x00,
 	0x01, 0x65, 0xf8, 0x31,
 	0x80, 0x93, 0x26, 0x01,
@@ -297,168 +298,168 @@ static uint8_t seqprog[] = {
 	0x01, 0x8c, 0xc8, 0x30,
 	0x00, 0x88, 0xc8, 0x18,
 	0x02, 0x64, 0xc8, 0x88,
-	0xff, 0x64, 0xee, 0x7e,
-	0xff, 0x8d, 0x50, 0x6a,
-	0xff, 0x8e, 0x50, 0x6a,
+	0xff, 0x64, 0xf0, 0x7e,
+	0xff, 0x8d, 0x52, 0x6a,
+	0xff, 0x8e, 0x52, 0x6a,
 	0x03, 0x8c, 0xd4, 0x98,
-	0x00, 0x65, 0xee, 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,
-	0xc0, 0x3c, 0x60, 0x7a,
-	0x21, 0x6a, 0xea, 0x5e,
+	0xc0, 0x3c, 0x62, 0x7a,
+	0x21, 0x6a, 0xec, 0x5e,
 	0xa8, 0x6a, 0x76, 0x00,
 	0x79, 0x6a, 0x76, 0x00,
-	0x40, 0x3f, 0x68, 0x6a,
+	0x40, 0x3f, 0x6a, 0x6a,
 	0x04, 0x3b, 0x76, 0x00,
 	0x04, 0x6a, 0xd4, 0x81,
-	0x20, 0x3c, 0x70, 0x7a,
-	0x51, 0x6a, 0xea, 0x5e,
-	0x00, 0x65, 0x8a, 0x42,
+	0x20, 0x3c, 0x72, 0x7a,
+	0x51, 0x6a, 0xec, 0x5e,
+	0x00, 0x65, 0x8c, 0x42,
 	0x20, 0x3c, 0x78, 0x00,
-	0x00, 0xb3, 0xcc, 0x5e,
+	0x00, 0xb3, 0xce, 0x5e,
 	0x07, 0xac, 0x10, 0x31,
 	0x05, 0xb3, 0x46, 0x31,
 	0x88, 0x6a, 0xcc, 0x00,
-	0xac, 0x6a, 0x00, 0x5e,
+	0xac, 0x6a, 0x02, 0x5e,
 	0xa3, 0x6a, 0xcc, 0x00,
-	0xb3, 0x6a, 0x04, 0x5e,
-	0x00, 0x65, 0x40, 0x5a,
+	0xb3, 0x6a, 0x06, 0x5e,
+	0x00, 0x65, 0x42, 0x5a,
 	0xfd, 0xa4, 0x48, 0x09,
 	0x01, 0x8c, 0xaa, 0x08,
 	0x03, 0x8c, 0x10, 0x30,
-	0x00, 0x65, 0xf8, 0x5d,
-	0x01, 0xa4, 0x9c, 0x7a,
+	0x00, 0x65, 0xfa, 0x5d,
+	0x01, 0xa4, 0x9e, 0x7a,
 	0x04, 0x3b, 0x76, 0x08,
 	0x01, 0x3b, 0x26, 0x31,
 	0x80, 0x02, 0x04, 0x00,
-	0x10, 0x0c, 0x92, 0x7a,
-	0x03, 0x9e, 0x94, 0x6a,
+	0x10, 0x0c, 0x94, 0x7a,
+	0x03, 0x9e, 0x96, 0x6a,
 	0x7f, 0x02, 0x04, 0x08,
-	0x91, 0x6a, 0xea, 0x5e,
-	0x00, 0x65, 0xca, 0x41,
+	0x91, 0x6a, 0xec, 0x5e,
+	0x00, 0x65, 0xcc, 0x41,
 	0x01, 0xa4, 0xca, 0x30,
-	0x80, 0xa3, 0xa2, 0x7a,
+	0x80, 0xa3, 0xa4, 0x7a,
 	0x02, 0x65, 0xca, 0x00,
-	0x01, 0x55, 0xa6, 0x7a,
+	0x01, 0x55, 0xa8, 0x7a,
 	0x04, 0x65, 0xca, 0x00,
 	0x01, 0x65, 0xf8, 0x31,
 	0x01, 0x3b, 0x26, 0x31,
-	0x00, 0x65, 0x0c, 0x5a,
-	0x01, 0xfc, 0xb4, 0x6a,
-	0x80, 0x0b, 0xaa, 0x6a,
-	0x10, 0x0c, 0xaa, 0x7a,
-	0x20, 0x93, 0xaa, 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, 0xbe, 0x7a,
-	0x40, 0x0d, 0xd8, 0x6a,
+	0x02, 0xfc, 0xc0, 0x7a,
+	0x40, 0x0d, 0xda, 0x6a,
 	0x01, 0xa4, 0x48, 0x01,
-	0x00, 0x65, 0xd8, 0x42,
-	0x40, 0x0d, 0xc4, 0x6a,
-	0x00, 0x65, 0x0c, 0x5a,
-	0x00, 0x65, 0xb6, 0x42,
-	0x80, 0xfc, 0xce, 0x7a,
-	0x80, 0xa4, 0xce, 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, 0xd6, 0x7a,
+	0x04, 0xfc, 0xd8, 0x7a,
 	0x01, 0x55, 0xaa, 0x00,
 	0xff, 0x6a, 0x46, 0x09,
-	0x04, 0x3b, 0xf0, 0x6a,
+	0x04, 0x3b, 0xf2, 0x6a,
 	0x02, 0x93, 0x26, 0x01,
-	0x01, 0x94, 0xda, 0x7a,
-	0x01, 0x94, 0xda, 0x7a,
-	0x01, 0x94, 0xda, 0x7a,
-	0x01, 0x94, 0xda, 0x7a,
-	0x01, 0x94, 0xda, 0x7a,
-	0x01, 0xa4, 0xee, 0x7a,
-	0x01, 0xfc, 0xe8, 0x7a,
-	0x01, 0x94, 0xf0, 0x6a,
-	0x00, 0x65, 0x8a, 0x42,
-	0x01, 0x94, 0xee, 0x7a,
-	0x10, 0x94, 0xf0, 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, 0xf4, 0x6a,
+	0x28, 0x93, 0xf6, 0x6a,
 	0x01, 0x85, 0x0a, 0x01,
-	0x02, 0xfc, 0xfc, 0x6a,
+	0x02, 0xfc, 0xfe, 0x6a,
 	0x01, 0x14, 0x46, 0x31,
 	0xff, 0x6a, 0x10, 0x09,
 	0xfe, 0x85, 0x0a, 0x09,
-	0xff, 0x38, 0x0a, 0x6b,
-	0x80, 0xa3, 0x0a, 0x7b,
-	0x80, 0x0b, 0x08, 0x7b,
-	0x04, 0x3b, 0x0a, 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, 0x0c, 0x5a,
-	0x01, 0x0b, 0x18, 0x6b,
-	0x10, 0x0c, 0x0c, 0x7b,
-	0x04, 0x93, 0x16, 0x6b,
-	0x01, 0x94, 0x14, 0x7b,
-	0x10, 0x94, 0x16, 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, 0x1a, 0x6b,
-	0xff, 0x08, 0x6c, 0x6b,
-	0xff, 0x09, 0x6c, 0x6b,
-	0xff, 0x0a, 0x6c, 0x6b,
-	0xff, 0x38, 0x36, 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, 0x06, 0x5e,
-	0x00, 0x38, 0xf2, 0x5d,
+	0x14, 0x6a, 0x08, 0x5e,
+	0x00, 0x38, 0xf4, 0x5d,
 	0xff, 0x6a, 0x70, 0x08,
-	0x00, 0x65, 0x62, 0x43,
-	0x80, 0xa3, 0x3c, 0x7b,
+	0x00, 0x65, 0x64, 0x43,
+	0x80, 0xa3, 0x3e, 0x7b,
 	0x01, 0xa4, 0x48, 0x01,
-	0x00, 0x65, 0x6c, 0x43,
-	0x08, 0xeb, 0x42, 0x7b,
-	0x00, 0x65, 0x0c, 0x5a,
-	0x08, 0xeb, 0x3e, 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, 0xcc, 0x5e,
+	0x00, 0x6a, 0xce, 0x5e,
 	0x88, 0x6a, 0xcc, 0x00,
-	0xa4, 0x6a, 0x06, 0x5e,
-	0x08, 0x6a, 0xf2, 0x5d,
+	0xa4, 0x6a, 0x08, 0x5e,
+	0x08, 0x6a, 0xf4, 0x5d,
 	0x0d, 0x93, 0x26, 0x01,
-	0x00, 0x65, 0xba, 0x5e,
+	0x00, 0x65, 0xbc, 0x5e,
 	0x88, 0x6a, 0xcc, 0x00,
-	0x00, 0x65, 0x9c, 0x5e,
+	0x00, 0x65, 0x9e, 0x5e,
 	0x01, 0x99, 0x46, 0x31,
-	0x00, 0xa3, 0xcc, 0x5e,
+	0x00, 0xa3, 0xce, 0x5e,
 	0x01, 0x88, 0x10, 0x31,
-	0x00, 0x65, 0x40, 0x5a,
-	0x00, 0x65, 0xf8, 0x59,
+	0x00, 0x65, 0x42, 0x5a,
+	0x00, 0x65, 0xfa, 0x59,
 	0x03, 0x8c, 0x10, 0x30,
-	0x00, 0x65, 0xf8, 0x5d,
-	0x01, 0x8c, 0x6a, 0x7b,
+	0x00, 0x65, 0xfa, 0x5d,
+	0x01, 0x8c, 0x6c, 0x7b,
 	0x01, 0x55, 0xaa, 0x10,
-	0x80, 0x0b, 0x8a, 0x6a,
-	0x80, 0x0b, 0x74, 0x6b,
-	0x01, 0x0c, 0x6e, 0x7b,
-	0x10, 0x0c, 0x8a, 0x7a,
-	0x03, 0x9e, 0x8a, 0x6a,
-	0x00, 0x65, 0x02, 0x5a,
-	0x00, 0x6a, 0xcc, 0x5e,
-	0x01, 0xa4, 0x94, 0x6b,
-	0xff, 0x38, 0x8a, 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, 0x8c, 0x43,
+	0x00, 0x65, 0x8e, 0x43,
 	0x03, 0x08, 0x40, 0x31,
 	0x03, 0x08, 0x40, 0x31,
 	0x01, 0x08, 0x40, 0x31,
@@ -467,19 +468,19 @@ static uint8_t seqprog[] = {
 	0xfd, 0xb4, 0x68, 0x09,
 	0x12, 0x01, 0x02, 0x00,
 	0x12, 0x01, 0x02, 0x00,
-	0x04, 0x3c, 0xca, 0x79,
+	0x04, 0x3c, 0xcc, 0x79,
 	0xfb, 0x3c, 0x78, 0x08,
 	0x04, 0x93, 0x20, 0x79,
-	0x01, 0x0c, 0xa0, 0x6b,
+	0x01, 0x0c, 0xa2, 0x6b,
 	0x01, 0x55, 0x20, 0x79,
 	0x80, 0x04, 0x20, 0x79,
-	0xe4, 0x6a, 0x80, 0x5d,
-	0x23, 0x6a, 0x96, 0x5d,
-	0x01, 0x6a, 0x96, 0x5d,
+	0xe4, 0x6a, 0x82, 0x5d,
+	0x23, 0x6a, 0x98, 0x5d,
+	0x01, 0x6a, 0x98, 0x5d,
 	0x00, 0x65, 0x20, 0x41,
-	0x00, 0x65, 0xca, 0x41,
-	0x80, 0x3c, 0xb4, 0x7b,
-	0x21, 0x6a, 0xea, 0x5e,
+	0x00, 0x65, 0xcc, 0x41,
+	0x80, 0x3c, 0xb6, 0x7b,
+	0x21, 0x6a, 0xec, 0x5e,
 	0x01, 0xbc, 0x18, 0x31,
 	0x02, 0x6a, 0x1a, 0x31,
 	0x02, 0x6a, 0xf8, 0x01,
@@ -489,16 +490,16 @@ static uint8_t seqprog[] = {
 	0xff, 0x6a, 0x12, 0x08,
 	0xff, 0x6a, 0x14, 0x08,
 	0xf3, 0xbc, 0xd4, 0x18,
-	0xa0, 0x6a, 0xda, 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, 0x06, 0x5e,
-	0x00, 0xbc, 0xf2, 0x5d,
+	0xa0, 0x6a, 0x08, 0x5e,
+	0x00, 0xbc, 0xf4, 0x5d,
 	0x3d, 0x6a, 0x26, 0x01,
-	0x00, 0x65, 0xf2, 0x43,
+	0x00, 0x65, 0xf4, 0x43,
 	0xff, 0x6a, 0x10, 0x09,
 	0xa4, 0x6a, 0x26, 0x01,
 	0x0c, 0xa0, 0x32, 0x31,
@@ -508,128 +509,128 @@ static uint8_t seqprog[] = {
 	0x36, 0x6a, 0x26, 0x01,
 	0x02, 0x93, 0x26, 0x01,
 	0x35, 0x6a, 0x26, 0x01,
-	0x00, 0x65, 0xae, 0x5e,
-	0x00, 0x65, 0xae, 0x5e,
+	0x00, 0x65, 0xb0, 0x5e,
+	0x00, 0x65, 0xb0, 0x5e,
 	0x02, 0x93, 0x26, 0x01,
 	0xbf, 0x3c, 0x78, 0x08,
-	0x04, 0x0b, 0xf8, 0x6b,
-	0x10, 0x0c, 0xf4, 0x7b,
-	0x01, 0x03, 0xf8, 0x6b,
-	0x20, 0x93, 0xfa, 0x6b,
-	0x04, 0x0b, 0x00, 0x6c,
+	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, 0x02, 0x6c,
-	0x00, 0x65, 0xca, 0x41,
-	0x80, 0x3c, 0x68, 0x6c,
+	0x38, 0x93, 0x04, 0x6c,
+	0x00, 0x65, 0xcc, 0x41,
+	0x80, 0x3c, 0x6a, 0x6c,
 	0x01, 0x06, 0x50, 0x31,
 	0x80, 0xb8, 0x70, 0x01,
-	0x00, 0x65, 0xca, 0x41,
+	0x00, 0x65, 0xcc, 0x41,
 	0x10, 0x3f, 0x06, 0x00,
 	0x10, 0x6a, 0x06, 0x00,
 	0x01, 0x3a, 0xca, 0x30,
-	0x80, 0x65, 0x2e, 0x64,
-	0x10, 0xb8, 0x52, 0x6c,
+	0x80, 0x65, 0x30, 0x64,
+	0x10, 0xb8, 0x54, 0x6c,
 	0xc0, 0xba, 0xca, 0x00,
-	0x40, 0xb8, 0x1e, 0x6c,
+	0x40, 0xb8, 0x20, 0x6c,
 	0xbf, 0x65, 0xca, 0x08,
-	0x20, 0xb8, 0x32, 0x7c,
+	0x20, 0xb8, 0x34, 0x7c,
 	0x01, 0x65, 0x0c, 0x30,
-	0x00, 0x65, 0xea, 0x5d,
-	0xa0, 0x3f, 0x3a, 0x64,
+	0x00, 0x65, 0xec, 0x5d,
+	0xa0, 0x3f, 0x3c, 0x64,
 	0x23, 0xb8, 0x0c, 0x08,
-	0x00, 0x65, 0xea, 0x5d,
-	0xa0, 0x3f, 0x3a, 0x64,
-	0x00, 0xbb, 0x32, 0x44,
-	0xff, 0x65, 0x32, 0x64,
-	0x00, 0x65, 0x52, 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, 0xea, 0x5d,
-	0xa0, 0x3f, 0x0e, 0x74,
+	0x00, 0x65, 0xec, 0x5d,
+	0xa0, 0x3f, 0x10, 0x74,
 	0x40, 0x6a, 0x18, 0x00,
 	0x01, 0x3a, 0xa6, 0x30,
 	0x08, 0x6a, 0x74, 0x00,
-	0x00, 0x65, 0xca, 0x41,
-	0x64, 0x6a, 0x7a, 0x5d,
-	0x80, 0x64, 0xea, 0x6c,
-	0x04, 0x64, 0xac, 0x74,
-	0x02, 0x64, 0xbc, 0x74,
-	0x00, 0x6a, 0x72, 0x74,
-	0x03, 0x64, 0xda, 0x74,
-	0x23, 0x64, 0x5a, 0x74,
-	0x08, 0x64, 0x6e, 0x74,
-	0x61, 0x6a, 0xea, 0x5e,
-	0x00, 0x65, 0xea, 0x5d,
-	0x08, 0x51, 0xcc, 0x71,
-	0x00, 0x65, 0x52, 0x44,
-	0x80, 0x04, 0x6c, 0x7c,
-	0x51, 0x6a, 0x70, 0x5d,
-	0x01, 0x51, 0x6c, 0x64,
-	0x01, 0xa4, 0x64, 0x7c,
-	0x01, 0x55, 0x6e, 0x7c,
-	0x41, 0x6a, 0xea, 0x5e,
-	0x00, 0x65, 0x6e, 0x44,
-	0x21, 0x6a, 0xea, 0x5e,
-	0x00, 0x65, 0x6e, 0x44,
-	0x07, 0x6a, 0x66, 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, 0xca, 0x41,
-	0x80, 0xb8, 0x68, 0x7c,
-	0xc0, 0x3c, 0x7c, 0x7c,
-	0x80, 0x3c, 0x68, 0x6c,
-	0xff, 0xa8, 0x7c, 0x6c,
-	0x40, 0x3c, 0x68, 0x6c,
-	0x10, 0xb8, 0x80, 0x7c,
-	0xa1, 0x6a, 0xea, 0x5e,
-	0x01, 0xb4, 0x86, 0x6c,
-	0x02, 0xb4, 0x88, 0x6c,
-	0x01, 0xa4, 0x88, 0x7c,
-	0xff, 0xa8, 0x98, 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, 0x24, 0x5e,
-	0xff, 0xa8, 0x98, 0x7c,
-	0x71, 0x6a, 0xea, 0x5e,
-	0x40, 0x51, 0x98, 0x64,
-	0x00, 0x65, 0xc4, 0x5e,
-	0x00, 0x65, 0xdc, 0x41,
-	0x00, 0xbb, 0x9c, 0x5c,
-	0x00, 0x65, 0xdc, 0x41,
-	0x00, 0x65, 0xc4, 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, 0xc8, 0xdd,
-	0x00, 0x51, 0xda, 0x5d,
+	0x00, 0x6a, 0xca, 0xdd,
+	0x00, 0x51, 0xdc, 0x5d,
 	0x01, 0x4e, 0x9c, 0x18,
 	0x02, 0x6a, 0x22, 0x05,
-	0xc0, 0x3c, 0x68, 0x6c,
+	0xc0, 0x3c, 0x6a, 0x6c,
 	0x04, 0xb8, 0x70, 0x01,
-	0x00, 0x65, 0xe6, 0x5e,
-	0x20, 0xb8, 0xdc, 0x69,
+	0x00, 0x65, 0xe8, 0x5e,
+	0x20, 0xb8, 0xde, 0x69,
 	0x01, 0xbb, 0xa2, 0x30,
 	0x01, 0xba, 0x7c, 0x30,
-	0x00, 0xb9, 0xe0, 0x5c,
-	0x00, 0x65, 0xdc, 0x41,
+	0x00, 0xb9, 0xe2, 0x5c,
+	0x00, 0x65, 0xde, 0x41,
 	0x01, 0x06, 0xd4, 0x30,
-	0x20, 0x3c, 0xca, 0x79,
-	0x20, 0x3c, 0x6e, 0x7c,
-	0x01, 0xa4, 0xca, 0x7c,
+	0x20, 0x3c, 0xcc, 0x79,
+	0x20, 0x3c, 0x70, 0x7c,
+	0x01, 0xa4, 0xcc, 0x7c,
 	0x01, 0xb4, 0x68, 0x01,
-	0x00, 0x65, 0xca, 0x41,
-	0x00, 0x65, 0x6e, 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, 0x06, 0x5e,
+	0x14, 0x6a, 0x08, 0x5e,
 	0x01, 0x06, 0xd4, 0x30,
-	0xa0, 0x6a, 0xfe, 0x5d,
-	0x00, 0x65, 0xca, 0x41,
+	0xa0, 0x6a, 0x00, 0x5e,
+	0x00, 0x65, 0xcc, 0x41,
 	0xdf, 0x3c, 0x78, 0x08,
 	0x12, 0x01, 0x02, 0x00,
-	0x00, 0x65, 0x6e, 0x44,
+	0x00, 0x65, 0x70, 0x44,
 	0x4c, 0x65, 0xcc, 0x28,
 	0x01, 0x3e, 0x20, 0x31,
 	0xd0, 0x66, 0xcc, 0x18,
@@ -640,102 +641,102 @@ static uint8_t seqprog[] = {
 	0xd0, 0x65, 0xca, 0x18,
 	0x01, 0x3e, 0x20, 0x31,
 	0x30, 0x65, 0xd4, 0x18,
-	0x00, 0x65, 0xf8, 0x4c,
+	0x00, 0x65, 0xfa, 0x4c,
 	0xe1, 0x6a, 0x22, 0x01,
 	0xff, 0x6a, 0xd4, 0x08,
 	0x20, 0x65, 0xd4, 0x18,
-	0x00, 0x65, 0x00, 0x55,
+	0x00, 0x65, 0x02, 0x55,
 	0xe1, 0x6a, 0x22, 0x01,
 	0xff, 0x6a, 0xd4, 0x08,
 	0x20, 0x65, 0xca, 0x18,
 	0xe0, 0x65, 0xd4, 0x18,
-	0x00, 0x65, 0x0a, 0x4d,
+	0x00, 0x65, 0x0c, 0x4d,
 	0xe1, 0x6a, 0x22, 0x01,
 	0xff, 0x6a, 0xd4, 0x08,
 	0xd0, 0x65, 0xd4, 0x18,
-	0x00, 0x65, 0x12, 0x55,
+	0x00, 0x65, 0x14, 0x55,
 	0xe1, 0x6a, 0x22, 0x01,
 	0xff, 0x6a, 0xd4, 0x08,
 	0x01, 0x6c, 0xa2, 0x30,
-	0xff, 0x51, 0x24, 0x75,
-	0x00, 0x51, 0xa0, 0x5d,
+	0xff, 0x51, 0x26, 0x75,
+	0x00, 0x51, 0xa2, 0x5d,
 	0x01, 0x51, 0x20, 0x31,
-	0x00, 0x65, 0x46, 0x45,
+	0x00, 0x65, 0x48, 0x45,
 	0x01, 0xba, 0xc8, 0x30,
-	0x00, 0x3e, 0x46, 0x75,
-	0x00, 0x65, 0xc2, 0x5e,
+	0x00, 0x3e, 0x48, 0x75,
+	0x00, 0x65, 0xc4, 0x5e,
 	0x80, 0x3c, 0x78, 0x00,
 	0x01, 0x06, 0xd4, 0x30,
-	0x00, 0x65, 0xea, 0x5d,
+	0x00, 0x65, 0xec, 0x5d,
 	0x01, 0x3c, 0x78, 0x00,
-	0xe0, 0x3f, 0x62, 0x65,
+	0xe0, 0x3f, 0x64, 0x65,
 	0x02, 0x3c, 0x78, 0x00,
-	0x20, 0x12, 0x62, 0x65,
-	0x51, 0x6a, 0x70, 0x5d,
-	0x00, 0x51, 0xa0, 0x5d,
-	0x51, 0x6a, 0x70, 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, 0x60, 0x65,
+	0x00, 0x3d, 0x62, 0x65,
 	0x08, 0x3c, 0x78, 0x00,
 	0x01, 0xba, 0xc8, 0x30,
-	0x00, 0x3e, 0x60, 0x65,
+	0x00, 0x3e, 0x62, 0x65,
 	0x10, 0x3c, 0x78, 0x00,
-	0x04, 0xb8, 0x60, 0x7d,
+	0x04, 0xb8, 0x62, 0x7d,
 	0xfb, 0xb8, 0x70, 0x09,
-	0x20, 0xb8, 0x56, 0x6d,
+	0x20, 0xb8, 0x58, 0x6d,
 	0x01, 0x90, 0xc8, 0x30,
 	0xff, 0x6a, 0xa2, 0x00,
-	0x00, 0x3d, 0xe0, 0x5c,
+	0x00, 0x3d, 0xe2, 0x5c,
 	0x01, 0x64, 0x20, 0x31,
 	0xff, 0x6a, 0x78, 0x08,
 	0x00, 0x65, 0xea, 0x58,
-	0x10, 0xb8, 0x6e, 0x7c,
-	0xff, 0x6a, 0x66, 0x5d,
-	0x00, 0x65, 0x6e, 0x44,
-	0x00, 0x65, 0xc2, 0x5e,
-	0x31, 0x6a, 0xea, 0x5e,
-	0x00, 0x65, 0x6e, 0x44,
+	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, 0xea, 0x5e,
-	0x00, 0x65, 0x72, 0x45,
+	0x81, 0x6a, 0xec, 0x5e,
+	0x00, 0x65, 0x74, 0x45,
 	0x01, 0x06, 0xd4, 0x30,
-	0x01, 0x0c, 0x72, 0x7d,
-	0x04, 0x0c, 0x6c, 0x6d,
+	0x01, 0x0c, 0x74, 0x7d,
+	0x04, 0x0c, 0x6e, 0x6d,
 	0xe0, 0x03, 0x7e, 0x08,
-	0xe0, 0x3f, 0xca, 0x61,
+	0xe0, 0x3f, 0xcc, 0x61,
 	0x01, 0x65, 0xcc, 0x30,
 	0x01, 0x12, 0xda, 0x34,
 	0x01, 0x06, 0xd4, 0x34,
-	0x01, 0x03, 0x80, 0x6d,
+	0x01, 0x03, 0x82, 0x6d,
 	0x40, 0x03, 0xcc, 0x08,
 	0x01, 0x65, 0x06, 0x30,
 	0x40, 0x65, 0xc8, 0x08,
-	0x00, 0x66, 0x8e, 0x75,
-	0x40, 0x65, 0x8e, 0x7d,
-	0x00, 0x65, 0x8e, 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, 0x98, 0x7d,
+	0x02, 0x0b, 0x9a, 0x7d,
 	0x01, 0x65, 0x0c, 0x30,
-	0x02, 0x0b, 0x9c, 0x7d,
+	0x02, 0x0b, 0x9e, 0x7d,
 	0xf7, 0x01, 0x02, 0x0c,
 	0x01, 0x65, 0xc8, 0x30,
-	0xff, 0x41, 0xc0, 0x75,
+	0xff, 0x41, 0xc2, 0x75,
 	0x01, 0x41, 0x20, 0x31,
 	0xff, 0x6a, 0xa4, 0x00,
-	0x00, 0x65, 0xb0, 0x45,
-	0xff, 0xbf, 0xc0, 0x75,
+	0x00, 0x65, 0xb2, 0x45,
+	0xff, 0xbf, 0xc2, 0x75,
 	0x01, 0x90, 0xa4, 0x30,
 	0x01, 0xbf, 0x20, 0x31,
-	0x00, 0xbb, 0xaa, 0x65,
-	0xff, 0x52, 0xbe, 0x75,
+	0x00, 0xbb, 0xac, 0x65,
+	0xff, 0x52, 0xc0, 0x75,
 	0x01, 0xbf, 0xcc, 0x30,
 	0x01, 0x90, 0xca, 0x30,
 	0x01, 0x52, 0x20, 0x31,
@@ -743,28 +744,28 @@ static uint8_t seqprog[] = {
 	0x01, 0x65, 0x20, 0x35,
 	0x01, 0xbf, 0x82, 0x34,
 	0x01, 0x64, 0xa2, 0x30,
-	0x00, 0x6a, 0xd2, 0x5e,
+	0x00, 0x6a, 0xd4, 0x5e,
 	0x0d, 0x6a, 0x76, 0x00,
-	0x00, 0x51, 0x24, 0x46,
+	0x00, 0x51, 0x26, 0x46,
 	0x01, 0x65, 0xa4, 0x30,
 	0xe0, 0x6a, 0xcc, 0x00,
-	0x48, 0x6a, 0x18, 0x5e,
+	0x48, 0x6a, 0x1a, 0x5e,
 	0x01, 0x6a, 0xd0, 0x01,
 	0x01, 0x6a, 0xdc, 0x05,
 	0x88, 0x6a, 0xcc, 0x00,
-	0x48, 0x6a, 0x18, 0x5e,
-	0x01, 0x6a, 0xf2, 0x5d,
+	0x48, 0x6a, 0x1a, 0x5e,
+	0x01, 0x6a, 0xf4, 0x5d,
 	0x01, 0x6a, 0x26, 0x05,
 	0x01, 0x65, 0xd8, 0x31,
 	0x09, 0xee, 0xdc, 0x01,
-	0x80, 0xee, 0xde, 0x7d,
+	0x80, 0xee, 0xe0, 0x7d,
 	0xff, 0x6a, 0xdc, 0x0d,
 	0x01, 0x65, 0x32, 0x31,
 	0x0a, 0x93, 0x26, 0x01,
-	0x00, 0x65, 0xba, 0x46,
-	0x81, 0x6a, 0xea, 0x5e,
-	0x01, 0x0c, 0xea, 0x7d,
-	0x04, 0x0c, 0xe8, 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,
@@ -783,7 +784,7 @@ static uint8_t seqprog[] = {
 	0x01, 0x6c, 0xda, 0x34,
 	0x3d, 0x64, 0xa4, 0x28,
 	0x55, 0x64, 0xc8, 0x28,
-	0x00, 0x65, 0x18, 0x46,
+	0x00, 0x65, 0x1a, 0x46,
 	0x2e, 0x64, 0xa4, 0x28,
 	0x66, 0x64, 0xc8, 0x28,
 	0x00, 0x6c, 0xda, 0x18,
@@ -794,63 +795,63 @@ static uint8_t seqprog[] = {
 	0x00, 0x6c, 0xda, 0x24,
 	0x01, 0x65, 0xc8, 0x30,
 	0xe0, 0x6a, 0xcc, 0x00,
-	0x44, 0x6a, 0x14, 0x5e,
+	0x44, 0x6a, 0x16, 0x5e,
 	0x01, 0x90, 0xe2, 0x31,
-	0x04, 0x3b, 0x38, 0x7e,
+	0x04, 0x3b, 0x3a, 0x7e,
 	0x30, 0x6a, 0xd0, 0x01,
 	0x20, 0x6a, 0xd0, 0x01,
 	0x1d, 0x6a, 0xdc, 0x01,
-	0xdc, 0xee, 0x34, 0x66,
-	0x00, 0x65, 0x50, 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, 0x40, 0x7e,
+	0x80, 0xee, 0x42, 0x7e,
 	0x11, 0x6a, 0xdc, 0x01,
-	0x50, 0xee, 0x44, 0x66,
+	0x50, 0xee, 0x46, 0x66,
 	0x20, 0x6a, 0xd0, 0x01,
 	0x09, 0x6a, 0xdc, 0x01,
-	0x88, 0xee, 0x4a, 0x66,
+	0x88, 0xee, 0x4c, 0x66,
 	0x19, 0x6a, 0xdc, 0x01,
-	0xd8, 0xee, 0x4e, 0x66,
+	0xd8, 0xee, 0x50, 0x66,
 	0xff, 0x6a, 0xdc, 0x09,
-	0x18, 0xee, 0x52, 0x6e,
+	0x18, 0xee, 0x54, 0x6e,
 	0xff, 0x6a, 0xd4, 0x0c,
 	0x88, 0x6a, 0xcc, 0x00,
-	0x44, 0x6a, 0x14, 0x5e,
-	0x20, 0x6a, 0xf2, 0x5d,
+	0x44, 0x6a, 0x16, 0x5e,
+	0x20, 0x6a, 0xf4, 0x5d,
 	0x01, 0x3b, 0x26, 0x31,
-	0x04, 0x3b, 0x6c, 0x6e,
+	0x04, 0x3b, 0x6e, 0x6e,
 	0xa0, 0x6a, 0xca, 0x00,
 	0x20, 0x65, 0xc8, 0x18,
-	0x00, 0x65, 0xaa, 0x5e,
-	0x00, 0x65, 0x64, 0x66,
+	0x00, 0x65, 0xac, 0x5e,
+	0x00, 0x65, 0x66, 0x66,
 	0x0a, 0x93, 0x26, 0x01,
-	0x00, 0x65, 0xba, 0x46,
+	0x00, 0x65, 0xbc, 0x46,
 	0xa0, 0x6a, 0xcc, 0x00,
 	0xff, 0x6a, 0xc8, 0x08,
-	0x20, 0x94, 0x70, 0x6e,
-	0x10, 0x94, 0x72, 0x6e,
-	0x08, 0x94, 0x8c, 0x6e,
-	0x08, 0x94, 0x8c, 0x6e,
-	0x08, 0x94, 0x8c, 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, 0x80, 0x66,
-	0xc0, 0x66, 0xbc, 0x76,
+	0x00, 0x66, 0x82, 0x66,
+	0xc0, 0x66, 0xbe, 0x76,
 	0x60, 0x66, 0xc8, 0x18,
 	0x3d, 0x64, 0xc8, 0x28,
-	0x00, 0x65, 0x70, 0x46,
+	0x00, 0x65, 0x72, 0x46,
 	0xf7, 0x93, 0x26, 0x09,
-	0x08, 0x93, 0x8e, 0x6e,
+	0x08, 0x93, 0x90, 0x6e,
 	0x00, 0x62, 0xc4, 0x18,
-	0x00, 0x65, 0xba, 0x5e,
-	0x00, 0x65, 0x9a, 0x5e,
-	0x00, 0x65, 0x9a, 0x5e,
-	0x00, 0x65, 0x9a, 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,
@@ -867,11 +868,11 @@ static uint8_t seqprog[] = {
 	0x01, 0x6c, 0x32, 0x31,
 	0x01, 0x6c, 0x32, 0x31,
 	0x01, 0x6c, 0x32, 0x35,
-	0x08, 0x94, 0xba, 0x7e,
+	0x08, 0x94, 0xbc, 0x7e,
 	0xf7, 0x93, 0x26, 0x09,
-	0x08, 0x93, 0xbe, 0x6e,
+	0x08, 0x93, 0xc0, 0x6e,
 	0xff, 0x6a, 0xd4, 0x0c,
-	0x04, 0xb8, 0xe6, 0x6e,
+	0x04, 0xb8, 0xe8, 0x6e,
 	0x01, 0x42, 0x7e, 0x31,
 	0xff, 0x6a, 0x76, 0x01,
 	0x01, 0x90, 0x84, 0x34,
@@ -879,14 +880,14 @@ static uint8_t seqprog[] = {
 	0x01, 0x85, 0x0a, 0x01,
 	0x7f, 0x65, 0x10, 0x09,
 	0xfe, 0x85, 0x0a, 0x0d,
-	0xff, 0x42, 0xe2, 0x66,
-	0xff, 0x41, 0xda, 0x66,
-	0xd1, 0x6a, 0xea, 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, 0x24, 0x46,
+	0x00, 0xbb, 0x26, 0x46,
 	0x01, 0x42, 0x20, 0x31,
 	0x01, 0xbf, 0x84, 0x34,
 	0x01, 0x41, 0x7e, 0x31,
@@ -1140,163 +1141,163 @@ static struct patch {
 	{ ahc_patch1_func, 119, 1, 2 },
 	{ ahc_patch0_func, 120, 1, 1 },
 	{ ahc_patch7_func, 121, 4, 1 },
-	{ ahc_patch7_func, 131, 94, 11 },
+	{ ahc_patch7_func, 131, 95, 11 },
 	{ ahc_patch4_func, 151, 1, 1 },
-	{ ahc_patch1_func, 167, 1, 1 },
-	{ ahc_patch12_func, 172, 1, 2 },
-	{ ahc_patch0_func, 173, 1, 1 },
-	{ ahc_patch9_func, 184, 1, 2 },
-	{ ahc_patch0_func, 185, 1, 1 },
-	{ ahc_patch9_func, 194, 1, 2 },
-	{ ahc_patch0_func, 195, 1, 1 },
-	{ ahc_patch9_func, 211, 6, 2 },
-	{ ahc_patch0_func, 217, 6, 1 },
-	{ ahc_patch8_func, 225, 20, 2 },
-	{ ahc_patch1_func, 240, 1, 1 },
-	{ ahc_patch1_func, 247, 1, 2 },
-	{ ahc_patch0_func, 248, 2, 2 },
-	{ ahc_patch11_func, 249, 1, 1 },
-	{ ahc_patch9_func, 257, 31, 3 },
-	{ ahc_patch1_func, 273, 14, 2 },
-	{ ahc_patch13_func, 278, 1, 1 },
-	{ ahc_patch14_func, 288, 14, 1 },
-	{ ahc_patch1_func, 304, 1, 2 },
-	{ ahc_patch0_func, 305, 1, 1 },
-	{ ahc_patch9_func, 308, 1, 1 },
-	{ ahc_patch13_func, 313, 1, 1 },
-	{ ahc_patch9_func, 314, 2, 2 },
-	{ ahc_patch0_func, 316, 4, 1 },
-	{ ahc_patch14_func, 320, 1, 1 },
-	{ ahc_patch15_func, 323, 2, 3 },
-	{ ahc_patch9_func, 323, 1, 2 },
-	{ ahc_patch0_func, 324, 1, 1 },
-	{ ahc_patch6_func, 329, 1, 2 },
-	{ ahc_patch0_func, 330, 1, 1 },
-	{ ahc_patch1_func, 334, 50, 11 },
-	{ ahc_patch6_func, 343, 2, 4 },
-	{ ahc_patch7_func, 343, 1, 1 },
-	{ ahc_patch8_func, 344, 1, 1 },
-	{ ahc_patch0_func, 345, 1, 1 },
-	{ ahc_patch16_func, 346, 1, 1 },
-	{ ahc_patch6_func, 365, 6, 3 },
-	{ ahc_patch16_func, 365, 5, 1 },
-	{ ahc_patch0_func, 371, 5, 1 },
-	{ ahc_patch13_func, 379, 5, 1 },
-	{ ahc_patch0_func, 384, 54, 17 },
-	{ ahc_patch14_func, 384, 1, 1 },
-	{ ahc_patch7_func, 386, 2, 2 },
-	{ ahc_patch17_func, 387, 1, 1 },
-	{ ahc_patch9_func, 390, 1, 1 },
-	{ ahc_patch18_func, 397, 1, 1 },
-	{ ahc_patch14_func, 402, 9, 3 },
-	{ ahc_patch9_func, 403, 3, 2 },
-	{ ahc_patch0_func, 406, 3, 1 },
-	{ ahc_patch9_func, 414, 6, 2 },
-	{ ahc_patch0_func, 420, 9, 2 },
-	{ ahc_patch13_func, 420, 1, 1 },
-	{ ahc_patch13_func, 429, 2, 1 },
-	{ ahc_patch14_func, 431, 1, 1 },
-	{ ahc_patch9_func, 433, 1, 2 },
-	{ ahc_patch0_func, 434, 1, 1 },
-	{ ahc_patch7_func, 437, 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_patch8_func, 439, 3, 3 },
-	{ ahc_patch6_func, 440, 1, 2 },
-	{ ahc_patch0_func, 441, 1, 1 },
-	{ ahc_patch9_func, 442, 1, 1 },
-	{ ahc_patch15_func, 443, 1, 2 },
-	{ ahc_patch13_func, 443, 1, 1 },
-	{ ahc_patch14_func, 445, 9, 4 },
-	{ ahc_patch9_func, 445, 1, 1 },
-	{ ahc_patch9_func, 452, 2, 1 },
-	{ ahc_patch0_func, 454, 4, 3 },
-	{ ahc_patch9_func, 454, 1, 2 },
-	{ ahc_patch0_func, 455, 3, 1 },
-	{ ahc_patch1_func, 459, 2, 1 },
-	{ ahc_patch7_func, 461, 10, 2 },
-	{ ahc_patch0_func, 471, 1, 1 },
-	{ ahc_patch8_func, 472, 118, 22 },
-	{ ahc_patch1_func, 474, 3, 2 },
-	{ ahc_patch0_func, 477, 5, 3 },
-	{ ahc_patch9_func, 477, 2, 2 },
-	{ ahc_patch0_func, 479, 3, 1 },
-	{ ahc_patch1_func, 484, 2, 2 },
-	{ ahc_patch0_func, 486, 6, 3 },
-	{ ahc_patch9_func, 486, 2, 2 },
-	{ ahc_patch0_func, 488, 3, 1 },
-	{ ahc_patch1_func, 494, 2, 2 },
-	{ ahc_patch0_func, 496, 9, 7 },
-	{ ahc_patch9_func, 496, 5, 6 },
-	{ ahc_patch19_func, 496, 1, 2 },
-	{ ahc_patch0_func, 497, 1, 1 },
-	{ ahc_patch19_func, 499, 1, 2 },
-	{ ahc_patch0_func, 500, 1, 1 },
-	{ ahc_patch0_func, 501, 4, 1 },
-	{ ahc_patch6_func, 506, 3, 2 },
-	{ ahc_patch0_func, 509, 1, 1 },
-	{ ahc_patch6_func, 519, 1, 2 },
-	{ ahc_patch0_func, 520, 1, 1 },
-	{ ahc_patch20_func, 557, 7, 1 },
-	{ ahc_patch3_func, 592, 1, 2 },
-	{ ahc_patch0_func, 593, 1, 1 },
-	{ ahc_patch21_func, 596, 1, 1 },
-	{ ahc_patch8_func, 598, 106, 33 },
-	{ ahc_patch4_func, 600, 1, 1 },
-	{ ahc_patch1_func, 606, 2, 2 },
-	{ ahc_patch0_func, 608, 1, 1 },
-	{ ahc_patch1_func, 611, 1, 2 },
-	{ ahc_patch0_func, 612, 1, 1 },
-	{ ahc_patch9_func, 613, 3, 3 },
-	{ ahc_patch15_func, 614, 1, 1 },
-	{ ahc_patch0_func, 616, 4, 1 },
-	{ ahc_patch19_func, 625, 2, 2 },
-	{ ahc_patch0_func, 627, 1, 1 },
-	{ ahc_patch19_func, 631, 10, 3 },
-	{ ahc_patch5_func, 633, 8, 1 },
-	{ ahc_patch0_func, 641, 9, 2 },
-	{ ahc_patch5_func, 642, 8, 1 },
-	{ ahc_patch4_func, 652, 1, 2 },
-	{ ahc_patch0_func, 653, 1, 1 },
-	{ ahc_patch19_func, 654, 1, 2 },
-	{ ahc_patch0_func, 655, 3, 2 },
-	{ ahc_patch4_func, 657, 1, 1 },
-	{ ahc_patch5_func, 658, 1, 1 },
-	{ ahc_patch5_func, 661, 1, 1 },
-	{ ahc_patch5_func, 663, 1, 1 },
-	{ ahc_patch4_func, 665, 2, 2 },
-	{ ahc_patch0_func, 667, 2, 1 },
-	{ ahc_patch5_func, 669, 1, 1 },
-	{ ahc_patch5_func, 672, 1, 1 },
-	{ ahc_patch5_func, 675, 1, 1 },
-	{ ahc_patch19_func, 679, 1, 1 },
-	{ ahc_patch19_func, 682, 1, 1 },
-	{ ahc_patch4_func, 688, 1, 1 },
-	{ ahc_patch6_func, 691, 1, 2 },
-	{ ahc_patch0_func, 692, 1, 1 },
-	{ ahc_patch7_func, 704, 16, 1 },
-	{ ahc_patch4_func, 720, 20, 1 },
-	{ ahc_patch9_func, 741, 4, 2 },
-	{ ahc_patch0_func, 745, 4, 1 },
-	{ ahc_patch9_func, 749, 4, 2 },
-	{ ahc_patch0_func, 753, 3, 1 },
-	{ ahc_patch6_func, 759, 1, 1 },
-	{ ahc_patch22_func, 761, 14, 1 },
-	{ ahc_patch7_func, 775, 3, 1 },
-	{ ahc_patch9_func, 787, 24, 8 },
-	{ ahc_patch19_func, 791, 1, 2 },
-	{ ahc_patch0_func, 792, 1, 1 },
-	{ ahc_patch15_func, 797, 4, 2 },
-	{ ahc_patch0_func, 801, 7, 3 },
-	{ ahc_patch23_func, 801, 5, 2 },
-	{ ahc_patch0_func, 806, 2, 1 },
-	{ ahc_patch0_func, 811, 42, 3 },
-	{ ahc_patch18_func, 823, 18, 2 },
-	{ ahc_patch0_func, 841, 1, 1 },
-	{ ahc_patch4_func, 865, 1, 1 },
-	{ ahc_patch4_func, 866, 3, 2 },
-	{ ahc_patch0_func, 869, 1, 1 },
-	{ ahc_patch13_func, 870, 3, 1 },
-	{ ahc_patch4_func, 873, 12, 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 {
@@ -1305,11 +1306,11 @@ static struct cs {
 } critical_sections[] = {
 	{ 11, 18 },
 	{ 21, 30 },
-	{ 720, 736 },
-	{ 866, 869 },
-	{ 873, 879 },
-	{ 881, 883 },
-	{ 883, 885 }
+	{ 721, 737 },
+	{ 867, 870 },
+	{ 874, 880 },
+	{ 882, 884 },
+	{ 884, 886 }
 };
 
 static const int num_critical_sections = sizeof(critical_sections)

drivers/scsi/aic7xxx/aiclib.c

@@ -1230,3 +1230,106 @@ aic_calc_syncsrate(u_int period_factor)
 	 */
 	return (10000000 / (period_factor * 4 * 10));
 }
+
+/*
+ * Return speed in KB/s.
+ */
+u_int
+aic_calc_speed(u_int width, u_int period, u_int offset, u_int min_rate)
+{
+	u_int freq;
+
+	if (offset != 0 && period < min_rate)
+		freq  = aic_calc_syncsrate(period);
+	else
+		/* Roughly 3.3MB/s for async */
+		freq  = 3300;
+	freq <<= width;
+	return (freq);
+}
+
+uint32_t
+aic_error_action(struct scsi_cmnd *cmd, struct scsi_inquiry_data *inq_data,
+		 cam_status status, u_int scsi_status)
+{
+	aic_sense_action  err_action;
+	int		  sense;
+
+	sense  = (cmd->result >> 24) == DRIVER_SENSE;
+
+	switch (status) {
+	case CAM_REQ_CMP:
+		err_action = SS_NOP;
+		break;
+	case CAM_AUTOSENSE_FAIL:
+	case CAM_SCSI_STATUS_ERROR:
+
+		switch (scsi_status) {
+		case SCSI_STATUS_OK:
+		case SCSI_STATUS_COND_MET:
+		case SCSI_STATUS_INTERMED:
+		case SCSI_STATUS_INTERMED_COND_MET:
+			err_action = SS_NOP;
+			break;
+		case SCSI_STATUS_CMD_TERMINATED:
+		case SCSI_STATUS_CHECK_COND:
+			if (sense != 0) {
+				struct scsi_sense_data *sense;
+
+				sense = (struct scsi_sense_data *)
+				    &cmd->sense_buffer;
+				err_action =
+				    aic_sense_error_action(sense, inq_data, 0);
+
+			} else {
+				err_action = SS_RETRY|SSQ_FALLBACK
+					   | SSQ_DECREMENT_COUNT|EIO;
+			}
+			break;
+		case SCSI_STATUS_QUEUE_FULL:
+		case SCSI_STATUS_BUSY:
+			err_action = SS_RETRY|SSQ_DELAY|SSQ_MANY
+				   | SSQ_DECREMENT_COUNT|EBUSY;
+			break;
+		case SCSI_STATUS_RESERV_CONFLICT:
+		default:
+			err_action = SS_FAIL|EBUSY;
+			break;
+		}
+		break;
+	case CAM_CMD_TIMEOUT:
+	case CAM_REQ_CMP_ERR:
+	case CAM_UNEXP_BUSFREE:
+	case CAM_UNCOR_PARITY:
+	case CAM_DATA_RUN_ERR:
+		err_action = SS_RETRY|SSQ_FALLBACK|EIO;
+		break;
+	case CAM_UA_ABORT:
+	case CAM_UA_TERMIO:
+	case CAM_MSG_REJECT_REC:
+	case CAM_SEL_TIMEOUT:
+		err_action = SS_FAIL|EIO;
+		break;
+	case CAM_REQ_INVALID:
+	case CAM_PATH_INVALID:
+	case CAM_DEV_NOT_THERE:
+	case CAM_NO_HBA:
+	case CAM_PROVIDE_FAIL:
+	case CAM_REQ_TOO_BIG:		
+	case CAM_RESRC_UNAVAIL:
+	case CAM_BUSY:
+	default:
+		/* panic??  These should never occur in our application. */
+		err_action = SS_FAIL|EIO;
+		break;
+	case CAM_SCSI_BUS_RESET:
+	case CAM_BDR_SENT:		
+	case CAM_REQUEUE_REQ:
+		/* Unconditional requeue */
+		err_action = SS_RETRY;
+		break;
+	}
+
+	return (err_action);
+}
+

drivers/scsi/aic7xxx/aiclib.h

@@ -861,11 +861,13 @@ aic_sector_div(sector_t capacity, int heads, int sectors)
 
 #define	aic_sense_desc			AIC_LIB_ENTRY(_sense_desc)
 #define	aic_sense_error_action		AIC_LIB_ENTRY(_sense_error_action)
+#define	aic_error_action		AIC_LIB_ENTRY(_error_action)
 #define	aic_op_desc			AIC_LIB_ENTRY(_op_desc)
 #define	aic_cdb_string			AIC_LIB_ENTRY(_cdb_string)
 #define aic_print_inquiry		AIC_LIB_ENTRY(_print_inquiry)
 #define aic_calc_syncsrate		AIC_LIB_ENTRY(_calc_syncrate)
 #define	aic_calc_syncparam		AIC_LIB_ENTRY(_calc_syncparam)
+#define	aic_calc_speed			AIC_LIB_ENTRY(_calc_speed)
 #define	aic_inquiry_match		AIC_LIB_ENTRY(_inquiry_match)
 #define	aic_static_inquiry_match	AIC_LIB_ENTRY(_static_inquiry_match)
 
@@ -878,6 +880,9 @@ void			aic_sense_desc(int /*sense_key*/, int /*asc*/,
 aic_sense_action	aic_sense_error_action(struct scsi_sense_data*,
 					       struct scsi_inquiry_data*,
 					       uint32_t /*sense_flags*/);
+uint32_t		aic_error_action(struct scsi_cmnd *,
+					 struct scsi_inquiry_data *,
+					 cam_status, u_int);
 
 #define	SF_RETRY_UA	0x01
 #define SF_NO_PRINT	0x02
@@ -892,6 +897,8 @@ void		aic_print_inquiry(struct scsi_inquiry_data*);
 
 u_int		aic_calc_syncsrate(u_int /*period_factor*/);
 u_int		aic_calc_syncparam(u_int /*period*/);
+u_int		aic_calc_speed(u_int width, u_int period, u_int offset,
+			       u_int min_rate);
 	
 int		aic_inquiry_match(caddr_t /*inqbuffer*/,
 				  caddr_t /*table_entry*/);