[PATCH 4/4] aic7xxx: printk() lines unbroken

[Michał Mirosław <mirq-linux@xxxxxxxxxxxx>]

Current code is not SMP-friendly and since now each printk() call
generates a separate line in the log, the output is mostly unreadable.
Make it better formatted.

Signed-off-by: Michał Mirosław <mirq-linux@xxxxxxxxxxxx>
---
 drivers/scsi/Kconfig                             |   3 +-
 drivers/scsi/aic7xxx/Kconfig                     |   6 +
 drivers/scsi/aic7xxx/Kconfig.aic79xx             |   1 +
 drivers/scsi/aic7xxx/Kconfig.aic7xxx             |   1 +
 drivers/scsi/aic7xxx/Makefile                    |   1 +
 drivers/scsi/aic7xxx/aic79xx.h                   |   7 -
 drivers/scsi/aic7xxx/aic79xx_core.c              | 242 +++++-------
 drivers/scsi/aic7xxx/aic79xx_reg.h_shipped       | 307 +++++++--------
 drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped | 480 +++++++++++------------
 drivers/scsi/aic7xxx/aic7xxx.h                   |   7 -
 drivers/scsi/aic7xxx/aic7xxx_core.c              | 181 ++++-----
 drivers/scsi/aic7xxx/aic7xxx_reg.h_shipped       | 157 ++++----
 drivers/scsi/aic7xxx/aic7xxx_reg_print.c_shipped | 242 ++++++------
 drivers/scsi/aic7xxx/aicasm/aicasm_symbol.c      |  39 +-
 drivers/scsi/aic7xxx/aiclib.c                    | 103 +++--
 drivers/scsi/aic7xxx/aiclib.h                    |  32 ++
 16 files changed, 871 insertions(+), 938 deletions(-)

diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index d384f4f86c26..fdb4c8e3b0ca 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -452,8 +452,7 @@ config SCSI_AACRAID
 	  will be called aacraid.
 
 
-source "drivers/scsi/aic7xxx/Kconfig.aic7xxx"
-source "drivers/scsi/aic7xxx/Kconfig.aic79xx"
+source "drivers/scsi/aic7xxx/Kconfig"
 source "drivers/scsi/aic94xx/Kconfig"
 source "drivers/scsi/hisi_sas/Kconfig"
 source "drivers/scsi/mvsas/Kconfig"
diff --git a/drivers/scsi/aic7xxx/Kconfig b/drivers/scsi/aic7xxx/Kconfig
new file mode 100644
index 000000000000..aeae1ba88281
--- /dev/null
+++ b/drivers/scsi/aic7xxx/Kconfig
@@ -0,0 +1,6 @@
+config SCSI_AICLIB
+	tristate
+	default n
+
+source "drivers/scsi/aic7xxx/Kconfig.aic7xxx"
+source "drivers/scsi/aic7xxx/Kconfig.aic79xx"
diff --git a/drivers/scsi/aic7xxx/Kconfig.aic79xx b/drivers/scsi/aic7xxx/Kconfig.aic79xx
index 3b3d599103f8..7cf29839bc54 100644
--- a/drivers/scsi/aic7xxx/Kconfig.aic79xx
+++ b/drivers/scsi/aic7xxx/Kconfig.aic79xx
@@ -6,6 +6,7 @@ config SCSI_AIC79XX
 	tristate "Adaptec AIC79xx U320 support"
 	depends on PCI && SCSI
 	select SCSI_SPI_ATTRS
+	select SCSI_AICLIB
 	help
 	This driver supports all of Adaptec's Ultra 320 PCI-X
 	based SCSI controllers.
diff --git a/drivers/scsi/aic7xxx/Kconfig.aic7xxx b/drivers/scsi/aic7xxx/Kconfig.aic7xxx
index 55ac55ee6068..0d6cea939551 100644
--- a/drivers/scsi/aic7xxx/Kconfig.aic7xxx
+++ b/drivers/scsi/aic7xxx/Kconfig.aic7xxx
@@ -6,6 +6,7 @@ config SCSI_AIC7XXX
 	tristate "Adaptec AIC7xxx Fast -> U160 support (New Driver)"
 	depends on (PCI || EISA) && SCSI
 	select SCSI_SPI_ATTRS
+	select SCSI_AICLIB
 	---help---
 	This driver supports all of Adaptec's Fast through Ultra 160 PCI
 	based SCSI controllers as well as the aic7770 based EISA and VLB
diff --git a/drivers/scsi/aic7xxx/Makefile b/drivers/scsi/aic7xxx/Makefile
index d76cbbba795d..d1f4bdf1726f 100644
--- a/drivers/scsi/aic7xxx/Makefile
+++ b/drivers/scsi/aic7xxx/Makefile
@@ -7,6 +7,7 @@
 # Let kbuild descend into aicasm when cleaning
 subdir-				+= aicasm
 
+obj-$(CONFIG_SCSI_AICLIB)	+= aiclib.o
 obj-$(CONFIG_SCSI_AIC7XXX)	+= aic7xxx.o
 obj-$(CONFIG_SCSI_AIC79XX)	+= aic79xx.o
 
diff --git a/drivers/scsi/aic7xxx/aic79xx.h b/drivers/scsi/aic7xxx/aic79xx.h
index d47b527b25dd..f81287db98bb 100644
--- a/drivers/scsi/aic7xxx/aic79xx.h
+++ b/drivers/scsi/aic7xxx/aic79xx.h
@@ -1468,11 +1468,4 @@ extern uint32_t ahd_debug;
 void			ahd_print_devinfo(struct ahd_softc *ahd,
 					  struct ahd_devinfo *devinfo);
 void			ahd_dump_card_state(struct ahd_softc *ahd);
-int			ahd_print_register(const ahd_reg_parse_entry_t *table,
-					   u_int num_entries,
-					   const char *name,
-					   u_int address,
-					   u_int value,
-					   u_int *cur_column,
-					   u_int wrap_point);
 #endif /* _AIC79XX_H_ */
diff --git a/drivers/scsi/aic7xxx/aic79xx_core.c b/drivers/scsi/aic7xxx/aic79xx_core.c
index 95d8f25cbcca..b895c43e9a5d 100644
--- a/drivers/scsi/aic7xxx/aic79xx_core.c
+++ b/drivers/scsi/aic7xxx/aic79xx_core.c
@@ -2672,6 +2672,7 @@ ahd_handle_scsiint(struct ahd_softc *ahd, u_int intstat)
 static void
 ahd_handle_transmission_error(struct ahd_softc *ahd)
 {
+	struct aic_dump_buffer buf;
 	struct	scb *scb;
 	u_int	scbid;
 	u_int	lqistat1;
@@ -2680,7 +2681,6 @@ ahd_handle_transmission_error(struct ahd_softc *ahd)
 	u_int	curphase;
 	u_int	lastphase;
 	u_int	perrdiag;
-	u_int	cur_col;
 	int	silent;
 
 	scb = NULL;
@@ -2727,14 +2727,14 @@ ahd_handle_transmission_error(struct ahd_softc *ahd)
 			silent = TRUE;
 	}
 
-	cur_col = 0;
+	aic_printbuf_init(&buf, 60);
 	if (silent == FALSE) {
 		printk("%s: Transmission error detected\n", ahd_name(ahd));
-		ahd_lqistat1_print(lqistat1, &cur_col, 50);
-		ahd_lastphase_print(lastphase, &cur_col, 50);
-		ahd_scsisigi_print(curphase, &cur_col, 50);
-		ahd_perrdiag_print(perrdiag, &cur_col, 50);
-		printk("\n");
+		ahd_lqistat1_print(lqistat1, &buf);
+		ahd_lastphase_print(lastphase, &buf);
+		ahd_scsisigi_print(curphase, &buf);
+		ahd_perrdiag_print(perrdiag, &buf);
+		aic_printbuf_finish(&buf);
 		ahd_dump_card_state(ahd);
 	}
 
@@ -9677,64 +9677,16 @@ ahd_probe_stack_size(struct ahd_softc *ahd)
 	return (last_probe);
 }
 
-int
-ahd_print_register(const ahd_reg_parse_entry_t *table, u_int num_entries,
-		   const char *name, u_int address, u_int value,
-		   u_int *cur_column, u_int wrap_point)
-{
-	int	printed;
-	u_int	printed_mask;
-
-	if (cur_column != NULL && *cur_column >= wrap_point) {
-		printk("\n");
-		*cur_column = 0;
-	}
-	printed = printk("%s[0x%x]", name, value);
-	if (table == NULL) {
-		printed += printk(" ");
-		*cur_column += printed;
-		return (printed);
-	}
-	printed_mask = 0;
-	while (printed_mask != 0xFF) {
-		int entry;
-
-		for (entry = 0; entry < num_entries; entry++) {
-			if (((value & table[entry].mask)
-			  != table[entry].value)
-			 || ((printed_mask & table[entry].mask)
-			  == table[entry].mask))
-				continue;
-
-			printed += printk("%s%s",
-					  printed_mask == 0 ? ":(" : "|",
-					  table[entry].name);
-			printed_mask |= table[entry].mask;
-			
-			break;
-		}
-		if (entry >= num_entries)
-			break;
-	}
-	if (printed_mask != 0)
-		printed += printk(") ");
-	else
-		printed += printk(" ");
-	if (cur_column != NULL)
-		*cur_column += printed;
-	return (printed);
-}
-
 void
 ahd_dump_card_state(struct ahd_softc *ahd)
 {
+	struct aic_dump_buffer buf;
 	struct scb	*scb;
 	ahd_mode_state	 saved_modes;
 	u_int		 dffstat;
 	int		 paused;
 	u_int		 scb_index;
 	u_int		 saved_scb_index;
-	u_int		 cur_col;
 	int		 i;
 
 	if (ahd_is_paused(ahd)) {
@@ -9760,78 +9712,75 @@ ahd_dump_card_state(struct ahd_softc *ahd)
 	/*
 	 * Mode independent registers.
 	 */
-	cur_col = 0;
-	ahd_intstat_print(ahd_inb(ahd, INTSTAT), &cur_col, 50);
-	ahd_seloid_print(ahd_inb(ahd, SELOID), &cur_col, 50);
-	ahd_selid_print(ahd_inb(ahd, SELID), &cur_col, 50);
-	ahd_hs_mailbox_print(ahd_inb(ahd, LOCAL_HS_MAILBOX), &cur_col, 50);
-	ahd_intctl_print(ahd_inb(ahd, INTCTL), &cur_col, 50);
-	ahd_seqintstat_print(ahd_inb(ahd, SEQINTSTAT), &cur_col, 50);
-	ahd_saved_mode_print(ahd_inb(ahd, SAVED_MODE), &cur_col, 50);
-	ahd_dffstat_print(ahd_inb(ahd, DFFSTAT), &cur_col, 50);
-	ahd_scsisigi_print(ahd_inb(ahd, SCSISIGI), &cur_col, 50);
-	ahd_scsiphase_print(ahd_inb(ahd, SCSIPHASE), &cur_col, 50);
-	ahd_scsibus_print(ahd_inb(ahd, SCSIBUS), &cur_col, 50);
-	ahd_lastphase_print(ahd_inb(ahd, LASTPHASE), &cur_col, 50);
-	ahd_scsiseq0_print(ahd_inb(ahd, SCSISEQ0), &cur_col, 50);
-	ahd_scsiseq1_print(ahd_inb(ahd, SCSISEQ1), &cur_col, 50);
-	ahd_seqctl0_print(ahd_inb(ahd, SEQCTL0), &cur_col, 50);
-	ahd_seqintctl_print(ahd_inb(ahd, SEQINTCTL), &cur_col, 50);
-	ahd_seq_flags_print(ahd_inb(ahd, SEQ_FLAGS), &cur_col, 50);
-	ahd_seq_flags2_print(ahd_inb(ahd, SEQ_FLAGS2), &cur_col, 50);
-	ahd_qfreeze_count_print(ahd_inw(ahd, QFREEZE_COUNT), &cur_col, 50);
+	aic_printbuf_init(&buf, 60);
+	ahd_intstat_print(ahd_inb(ahd, INTSTAT), &buf);
+	ahd_seloid_print(ahd_inb(ahd, SELOID), &buf);
+	ahd_selid_print(ahd_inb(ahd, SELID), &buf);
+	ahd_hs_mailbox_print(ahd_inb(ahd, LOCAL_HS_MAILBOX), &buf);
+	ahd_intctl_print(ahd_inb(ahd, INTCTL), &buf);
+	ahd_seqintstat_print(ahd_inb(ahd, SEQINTSTAT), &buf);
+	ahd_saved_mode_print(ahd_inb(ahd, SAVED_MODE), &buf);
+	ahd_dffstat_print(ahd_inb(ahd, DFFSTAT), &buf);
+	ahd_scsisigi_print(ahd_inb(ahd, SCSISIGI), &buf);
+	ahd_scsiphase_print(ahd_inb(ahd, SCSIPHASE), &buf);
+	ahd_scsibus_print(ahd_inb(ahd, SCSIBUS), &buf);
+	ahd_lastphase_print(ahd_inb(ahd, LASTPHASE), &buf);
+	ahd_scsiseq0_print(ahd_inb(ahd, SCSISEQ0), &buf);
+	ahd_scsiseq1_print(ahd_inb(ahd, SCSISEQ1), &buf);
+	ahd_seqctl0_print(ahd_inb(ahd, SEQCTL0), &buf);
+	ahd_seqintctl_print(ahd_inb(ahd, SEQINTCTL), &buf);
+	ahd_seq_flags_print(ahd_inb(ahd, SEQ_FLAGS), &buf);
+	ahd_seq_flags2_print(ahd_inb(ahd, SEQ_FLAGS2), &buf);
+	ahd_qfreeze_count_print(ahd_inw(ahd, QFREEZE_COUNT), &buf);
 	ahd_kernel_qfreeze_count_print(ahd_inw(ahd, KERNEL_QFREEZE_COUNT),
-				       &cur_col, 50);
-	ahd_mk_message_scb_print(ahd_inw(ahd, MK_MESSAGE_SCB), &cur_col, 50);
-	ahd_mk_message_scsiid_print(ahd_inb(ahd, MK_MESSAGE_SCSIID),
-				    &cur_col, 50);
-	ahd_sstat0_print(ahd_inb(ahd, SSTAT0), &cur_col, 50);
-	ahd_sstat1_print(ahd_inb(ahd, SSTAT1), &cur_col, 50);
-	ahd_sstat2_print(ahd_inb(ahd, SSTAT2), &cur_col, 50);
-	ahd_sstat3_print(ahd_inb(ahd, SSTAT3), &cur_col, 50);
-	ahd_perrdiag_print(ahd_inb(ahd, PERRDIAG), &cur_col, 50);
-	ahd_simode1_print(ahd_inb(ahd, SIMODE1), &cur_col, 50);
-	ahd_lqistat0_print(ahd_inb(ahd, LQISTAT0), &cur_col, 50);
-	ahd_lqistat1_print(ahd_inb(ahd, LQISTAT1), &cur_col, 50);
-	ahd_lqistat2_print(ahd_inb(ahd, LQISTAT2), &cur_col, 50);
-	ahd_lqostat0_print(ahd_inb(ahd, LQOSTAT0), &cur_col, 50);
-	ahd_lqostat1_print(ahd_inb(ahd, LQOSTAT1), &cur_col, 50);
-	ahd_lqostat2_print(ahd_inb(ahd, LQOSTAT2), &cur_col, 50);
-	printk("\n");
+				       &buf);
+	ahd_mk_message_scb_print(ahd_inw(ahd, MK_MESSAGE_SCB), &buf);
+	ahd_mk_message_scsiid_print(ahd_inb(ahd, MK_MESSAGE_SCSIID), &buf);
+	ahd_sstat0_print(ahd_inb(ahd, SSTAT0), &buf);
+	ahd_sstat1_print(ahd_inb(ahd, SSTAT1), &buf);
+	ahd_sstat2_print(ahd_inb(ahd, SSTAT2), &buf);
+	ahd_sstat3_print(ahd_inb(ahd, SSTAT3), &buf);
+	ahd_perrdiag_print(ahd_inb(ahd, PERRDIAG), &buf);
+	ahd_simode1_print(ahd_inb(ahd, SIMODE1), &buf);
+	ahd_lqistat0_print(ahd_inb(ahd, LQISTAT0), &buf);
+	ahd_lqistat1_print(ahd_inb(ahd, LQISTAT1), &buf);
+	ahd_lqistat2_print(ahd_inb(ahd, LQISTAT2), &buf);
+	ahd_lqostat0_print(ahd_inb(ahd, LQOSTAT0), &buf);
+	ahd_lqostat1_print(ahd_inb(ahd, LQOSTAT1), &buf);
+	ahd_lqostat2_print(ahd_inb(ahd, LQOSTAT2), &buf);
+	aic_printbuf_finish(&buf);
 	printk("\nSCB Count = %d CMDS_PENDING = %d LASTSCB 0x%x "
 	       "CURRSCB 0x%x NEXTSCB 0x%x\n",
 	       ahd->scb_data.numscbs, ahd_inw(ahd, CMDS_PENDING),
 	       ahd_inw(ahd, LASTSCB), ahd_inw(ahd, CURRSCB),
 	       ahd_inw(ahd, NEXTSCB));
-	cur_col = 0;
 	/* QINFIFO */
 	ahd_search_qinfifo(ahd, CAM_TARGET_WILDCARD, ALL_CHANNELS,
 			   CAM_LUN_WILDCARD, SCB_LIST_NULL,
 			   ROLE_UNKNOWN, /*status*/0, SEARCH_PRINT);
 	saved_scb_index = ahd_get_scbptr(ahd);
-	printk("Pending list:");
+	printk("Pending list:\n");
 	i = 0;
 	LIST_FOREACH(scb, &ahd->pending_scbs, pending_links) {
 		if (i++ > AHD_SCB_MAX)
 			break;
-		cur_col = printk("\n%3d FIFO_USE[0x%x] ", SCB_GET_TAG(scb),
-				 ahd_inb_scbram(ahd, SCB_FIFO_USE_COUNT));
+		aic_printbuf_push(&buf, "%3d FIFO_USE[0x%x] ", SCB_GET_TAG(scb),
+				  ahd_inb_scbram(ahd, SCB_FIFO_USE_COUNT));
 		ahd_set_scbptr(ahd, SCB_GET_TAG(scb));
-		ahd_scb_control_print(ahd_inb_scbram(ahd, SCB_CONTROL),
-				      &cur_col, 60);
-		ahd_scb_scsiid_print(ahd_inb_scbram(ahd, SCB_SCSIID),
-				     &cur_col, 60);
+		ahd_scb_control_print(ahd_inb_scbram(ahd, SCB_CONTROL), &buf);
+		ahd_scb_scsiid_print(ahd_inb_scbram(ahd, SCB_SCSIID), &buf);
+		aic_printbuf_finish(&buf);
 	}
-	printk("\nTotal %d\n", i);
+	printk("Total %d\n", i);
 
-	printk("Kernel Free SCB list: ");
+	aic_printbuf_push(&buf, "Kernel Free SCB list: ");
 	i = 0;
 	TAILQ_FOREACH(scb, &ahd->scb_data.free_scbs, links.tqe) {
 		struct scb *list_scb;
 
 		list_scb = scb;
 		do {
-			printk("%d ", SCB_GET_TAG(list_scb));
+			aic_printbuf_push(&buf, "%d ", SCB_GET_TAG(list_scb));
 			list_scb = LIST_NEXT(list_scb, collision_links);
 		} while (list_scb && i++ < AHD_SCB_MAX);
 	}
@@ -9839,49 +9788,49 @@ ahd_dump_card_state(struct ahd_softc *ahd)
 	LIST_FOREACH(scb, &ahd->scb_data.any_dev_free_scb_list, links.le) {
 		if (i++ > AHD_SCB_MAX)
 			break;
-		printk("%d ", SCB_GET_TAG(scb));
+		aic_printbuf_push(&buf, "%d ", SCB_GET_TAG(scb));
 	}
-	printk("\n");
+	aic_printbuf_finish(&buf);
 
-	printk("Sequencer Complete DMA-inprog list: ");
+	aic_printbuf_push(&buf, "Sequencer Complete DMA-inprog list: ");
 	scb_index = ahd_inw(ahd, COMPLETE_SCB_DMAINPROG_HEAD);
 	i = 0;
 	while (!SCBID_IS_NULL(scb_index) && i++ < AHD_SCB_MAX) {
 		ahd_set_scbptr(ahd, scb_index);
-		printk("%d ", scb_index);
+		aic_printbuf_push(&buf, "%d ", scb_index);
 		scb_index = ahd_inw_scbram(ahd, SCB_NEXT_COMPLETE);
 	}
-	printk("\n");
+	aic_printbuf_finish(&buf);
 
-	printk("Sequencer Complete list: ");
+	aic_printbuf_push(&buf, "Sequencer Complete list: ");
 	scb_index = ahd_inw(ahd, COMPLETE_SCB_HEAD);
 	i = 0;
 	while (!SCBID_IS_NULL(scb_index) && i++ < AHD_SCB_MAX) {
 		ahd_set_scbptr(ahd, scb_index);
-		printk("%d ", scb_index);
+		aic_printbuf_push(&buf, "%d ", scb_index);
 		scb_index = ahd_inw_scbram(ahd, SCB_NEXT_COMPLETE);
 	}
-	printk("\n");
+	aic_printbuf_finish(&buf);
 
 	
-	printk("Sequencer DMA-Up and Complete list: ");
+	aic_printbuf_push(&buf, "Sequencer DMA-Up and Complete list: ");
 	scb_index = ahd_inw(ahd, COMPLETE_DMA_SCB_HEAD);
 	i = 0;
 	while (!SCBID_IS_NULL(scb_index) && i++ < AHD_SCB_MAX) {
 		ahd_set_scbptr(ahd, scb_index);
-		printk("%d ", scb_index);
+		aic_printbuf_push(&buf, "%d ", scb_index);
 		scb_index = ahd_inw_scbram(ahd, SCB_NEXT_COMPLETE);
 	}
-	printk("\n");
-	printk("Sequencer On QFreeze and Complete list: ");
+	aic_printbuf_finish(&buf);
+	aic_printbuf_push(&buf, "Sequencer On QFreeze and Complete list: ");
 	scb_index = ahd_inw(ahd, COMPLETE_ON_QFREEZE_HEAD);
 	i = 0;
 	while (!SCBID_IS_NULL(scb_index) && i++ < AHD_SCB_MAX) {
 		ahd_set_scbptr(ahd, scb_index);
-		printk("%d ", scb_index);
+		aic_printbuf_push(&buf, "%d ", scb_index);
 		scb_index = ahd_inw_scbram(ahd, SCB_NEXT_COMPLETE);
 	}
-	printk("\n");
+	aic_printbuf_finish(&buf);
 	ahd_set_scbptr(ahd, saved_scb_index);
 	dffstat = ahd_inb(ahd, DFFSTAT);
 	for (i = 0; i < 2; i++) {
@@ -9896,38 +9845,29 @@ ahd_dump_card_state(struct ahd_softc *ahd)
 		       ahd_name(ahd), i,
 		       (dffstat & (FIFO0FREE << i)) ? "Free" : "Active",
 		       ahd_inw(ahd, LONGJMP_ADDR), fifo_scbptr);
-		cur_col = 0;
-		ahd_seqimode_print(ahd_inb(ahd, SEQIMODE), &cur_col, 50);
-		ahd_seqintsrc_print(ahd_inb(ahd, SEQINTSRC), &cur_col, 50);
-		ahd_dfcntrl_print(ahd_inb(ahd, DFCNTRL), &cur_col, 50);
-		ahd_dfstatus_print(ahd_inb(ahd, DFSTATUS), &cur_col, 50);
-		ahd_sg_cache_shadow_print(ahd_inb(ahd, SG_CACHE_SHADOW),
-					  &cur_col, 50);
-		ahd_sg_state_print(ahd_inb(ahd, SG_STATE), &cur_col, 50);
-		ahd_dffsxfrctl_print(ahd_inb(ahd, DFFSXFRCTL), &cur_col, 50);
-		ahd_soffcnt_print(ahd_inb(ahd, SOFFCNT), &cur_col, 50);
-		ahd_mdffstat_print(ahd_inb(ahd, MDFFSTAT), &cur_col, 50);
-		if (cur_col > 50) {
-			printk("\n");
-			cur_col = 0;
-		}
-		cur_col += printk("SHADDR = 0x%x%x, SHCNT = 0x%x ",
+		ahd_seqimode_print(ahd_inb(ahd, SEQIMODE), &buf);
+		ahd_seqintsrc_print(ahd_inb(ahd, SEQINTSRC), &buf);
+		ahd_dfcntrl_print(ahd_inb(ahd, DFCNTRL), &buf);
+		ahd_dfstatus_print(ahd_inb(ahd, DFSTATUS), &buf);
+		ahd_sg_cache_shadow_print(ahd_inb(ahd, SG_CACHE_SHADOW), &buf);
+		ahd_sg_state_print(ahd_inb(ahd, SG_STATE), &buf);
+		ahd_dffsxfrctl_print(ahd_inb(ahd, DFFSXFRCTL), &buf);
+		ahd_soffcnt_print(ahd_inb(ahd, SOFFCNT), &buf);
+		ahd_mdffstat_print(ahd_inb(ahd, MDFFSTAT), &buf);
+		aic_printbuf_push(&buf, "SHADDR = 0x%x%x, SHCNT = 0x%x ",
 				  ahd_inl(ahd, SHADDR+4),
 				  ahd_inl(ahd, SHADDR),
 				  (ahd_inb(ahd, SHCNT)
 				| (ahd_inb(ahd, SHCNT + 1) << 8)
 				| (ahd_inb(ahd, SHCNT + 2) << 16)));
-		if (cur_col > 50) {
-			printk("\n");
-			cur_col = 0;
-		}
-		cur_col += printk("HADDR = 0x%x%x, HCNT = 0x%x ",
+		aic_printbuf_push(&buf, "HADDR = 0x%x%x, HCNT = 0x%x ",
 				  ahd_inl(ahd, HADDR+4),
 				  ahd_inl(ahd, HADDR),
 				  (ahd_inb(ahd, HCNT)
 				| (ahd_inb(ahd, HCNT + 1) << 8)
 				| (ahd_inb(ahd, HCNT + 2) << 16)));
-		ahd_ccsgctl_print(ahd_inb(ahd, CCSGCTL), &cur_col, 50);
+		ahd_ccsgctl_print(ahd_inb(ahd, CCSGCTL), &buf);
+		aic_printbuf_finish(&buf);
 #ifdef AHD_DEBUG
 		if ((ahd_debug & AHD_SHOW_SG) != 0) {
 			fifo_scb = ahd_lookup_scb(ahd, fifo_scbptr);
@@ -9936,10 +9876,10 @@ ahd_dump_card_state(struct ahd_softc *ahd)
 		}
 #endif
 	}
-	printk("\nLQIN: ");
+	aic_printbuf_push(&buf, "\nLQIN: ");
 	for (i = 0; i < 20; i++)
-		printk("0x%x ", ahd_inb(ahd, LQIN + i));
-	printk("\n");
+		aic_printbuf_push(&buf, "0x%x ", ahd_inb(ahd, LQIN + i));
+	aic_printbuf_finish(&buf);
 	ahd_set_modes(ahd, AHD_MODE_CFG, AHD_MODE_CFG);
 	printk("%s: LQISTATE = 0x%x, LQOSTATE = 0x%x, OPTIONMODE = 0x%x\n",
 	       ahd_name(ahd), ahd_inb(ahd, LQISTATE), ahd_inb(ahd, LQOSTATE),
@@ -9950,12 +9890,11 @@ ahd_dump_card_state(struct ahd_softc *ahd)
 	printk("%s: SAVED_SCSIID = 0x%x SAVED_LUN = 0x%x\n",
 	       ahd_name(ahd), ahd_inb(ahd, SAVED_SCSIID),
 	       ahd_inb(ahd, SAVED_LUN));
-	ahd_simode0_print(ahd_inb(ahd, SIMODE0), &cur_col, 50);
-	printk("\n");
+	ahd_simode0_print(ahd_inb(ahd, SIMODE0), &buf);
+	aic_printbuf_finish(&buf);
 	ahd_set_modes(ahd, AHD_MODE_CCHAN, AHD_MODE_CCHAN);
-	cur_col = 0;
-	ahd_ccscbctl_print(ahd_inb(ahd, CCSCBCTL), &cur_col, 50);
-	printk("\n");
+	ahd_ccscbctl_print(ahd_inb(ahd, CCSCBCTL), &buf);
+	aic_printbuf_finish(&buf);
 	ahd_set_modes(ahd, ahd->saved_src_mode, ahd->saved_dst_mode);
 	printk("%s: REG0 == 0x%x, SINDEX = 0x%x, DINDEX = 0x%x\n",
 	       ahd_name(ahd), ahd_inw(ahd, REG0), ahd_inw(ahd, SINDEX),
@@ -9971,17 +9910,18 @@ ahd_dump_card_state(struct ahd_softc *ahd)
 	       ahd_inb_scbram(ahd, SCB_CDB_STORE+3),
 	       ahd_inb_scbram(ahd, SCB_CDB_STORE+4),
 	       ahd_inb_scbram(ahd, SCB_CDB_STORE+5));
-	printk("STACK:");
+	aic_printbuf_push(&buf, "STACK:");
 	for (i = 0; i < ahd->stack_size; i++) {
 		ahd->saved_stack[i] =
 		    ahd_inb(ahd, STACK)|(ahd_inb(ahd, STACK) << 8);
-		printk(" 0x%x", ahd->saved_stack[i]);
+		aic_printbuf_push(&buf, " 0x%x", ahd->saved_stack[i]);
 	}
 	for (i = ahd->stack_size-1; i >= 0; i--) {
 		ahd_outb(ahd, STACK, ahd->saved_stack[i] & 0xFF);
 		ahd_outb(ahd, STACK, (ahd->saved_stack[i] >> 8) & 0xFF);
 	}
-	printk("\n<<<<<<<<<<<<<<<<< Dump Card State Ends >>>>>>>>>>>>>>>>>>\n");
+	aic_printbuf_finish(&buf);
+	printk("<<<<<<<<<<<<<<<<< Dump Card State Ends >>>>>>>>>>>>>>>>>>\n");
 	ahd_restore_modes(ahd, saved_modes);
 	if (paused == 0)
 		ahd_unpause(ahd);
diff --git a/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped b/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped
index ddcd5a7701ac..fef0196f0986 100644
--- a/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped
+++ b/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped
@@ -5,361 +5,354 @@
  * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#120 $
  * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#77 $
  */
-typedef int (ahd_reg_print_t)(u_int, u_int *, u_int);
-typedef struct ahd_reg_parse_entry {
-	char	*name;
-	uint8_t	 value;
-	uint8_t	 mask;
-} ahd_reg_parse_entry_t;
-
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_intstat_print;
+aic_reg_print_t ahd_intstat_print;
 #else
-#define ahd_intstat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "INTSTAT", 0x01, regvalue, cur_col, wrap)
+#define ahd_intstat_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "INTSTAT", 0x01, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_hs_mailbox_print;
+aic_reg_print_t ahd_hs_mailbox_print;
 #else
-#define ahd_hs_mailbox_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "HS_MAILBOX", 0x0b, regvalue, cur_col, wrap)
+#define ahd_hs_mailbox_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "HS_MAILBOX", 0x0b, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_seqintstat_print;
+aic_reg_print_t ahd_seqintstat_print;
 #else
-#define ahd_seqintstat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SEQINTSTAT", 0x0c, regvalue, cur_col, wrap)
+#define ahd_seqintstat_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SEQINTSTAT", 0x0c, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_intctl_print;
+aic_reg_print_t ahd_intctl_print;
 #else
-#define ahd_intctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "INTCTL", 0x18, regvalue, cur_col, wrap)
+#define ahd_intctl_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "INTCTL", 0x18, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dfcntrl_print;
+aic_reg_print_t ahd_dfcntrl_print;
 #else
-#define ahd_dfcntrl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFCNTRL", 0x19, regvalue, cur_col, wrap)
+#define ahd_dfcntrl_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "DFCNTRL", 0x19, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dfstatus_print;
+aic_reg_print_t ahd_dfstatus_print;
 #else
-#define ahd_dfstatus_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFSTATUS", 0x1a, regvalue, cur_col, wrap)
+#define ahd_dfstatus_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "DFSTATUS", 0x1a, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sg_cache_shadow_print;
+aic_reg_print_t ahd_sg_cache_shadow_print;
 #else
-#define ahd_sg_cache_shadow_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SG_CACHE_SHADOW", 0x1b, regvalue, cur_col, wrap)
+#define ahd_sg_cache_shadow_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SG_CACHE_SHADOW", 0x1b, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scsiseq0_print;
+aic_reg_print_t ahd_scsiseq0_print;
 #else
-#define ahd_scsiseq0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCSISEQ0", 0x3a, regvalue, cur_col, wrap)
+#define ahd_scsiseq0_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCSISEQ0", 0x3a, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scsiseq1_print;
+aic_reg_print_t ahd_scsiseq1_print;
 #else
-#define ahd_scsiseq1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCSISEQ1", 0x3b, regvalue, cur_col, wrap)
+#define ahd_scsiseq1_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCSISEQ1", 0x3b, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dffstat_print;
+aic_reg_print_t ahd_dffstat_print;
 #else
-#define ahd_dffstat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFFSTAT", 0x3f, regvalue, cur_col, wrap)
+#define ahd_dffstat_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "DFFSTAT", 0x3f, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scsisigi_print;
+aic_reg_print_t ahd_scsisigi_print;
 #else
-#define ahd_scsisigi_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCSISIGI", 0x41, regvalue, cur_col, wrap)
+#define ahd_scsisigi_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCSISIGI", 0x41, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scsiphase_print;
+aic_reg_print_t ahd_scsiphase_print;
 #else
-#define ahd_scsiphase_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCSIPHASE", 0x42, regvalue, cur_col, wrap)
+#define ahd_scsiphase_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCSIPHASE", 0x42, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scsibus_print;
+aic_reg_print_t ahd_scsibus_print;
 #else
-#define ahd_scsibus_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCSIBUS", 0x46, regvalue, cur_col, wrap)
+#define ahd_scsibus_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCSIBUS", 0x46, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_selid_print;
+aic_reg_print_t ahd_selid_print;
 #else
-#define ahd_selid_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SELID", 0x49, regvalue, cur_col, wrap)
+#define ahd_selid_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SELID", 0x49, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_simode0_print;
+aic_reg_print_t ahd_simode0_print;
 #else
-#define ahd_simode0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SIMODE0", 0x4b, regvalue, cur_col, wrap)
+#define ahd_simode0_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SIMODE0", 0x4b, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sstat0_print;
+aic_reg_print_t ahd_sstat0_print;
 #else
-#define ahd_sstat0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SSTAT0", 0x4b, regvalue, cur_col, wrap)
+#define ahd_sstat0_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SSTAT0", 0x4b, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sstat1_print;
+aic_reg_print_t ahd_sstat1_print;
 #else
-#define ahd_sstat1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SSTAT1", 0x4c, regvalue, cur_col, wrap)
+#define ahd_sstat1_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SSTAT1", 0x4c, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sstat2_print;
+aic_reg_print_t ahd_sstat2_print;
 #else
-#define ahd_sstat2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SSTAT2", 0x4d, regvalue, cur_col, wrap)
+#define ahd_sstat2_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SSTAT2", 0x4d, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_perrdiag_print;
+aic_reg_print_t ahd_perrdiag_print;
 #else
-#define ahd_perrdiag_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "PERRDIAG", 0x4e, regvalue, cur_col, wrap)
+#define ahd_perrdiag_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "PERRDIAG", 0x4e, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_soffcnt_print;
+aic_reg_print_t ahd_soffcnt_print;
 #else
-#define ahd_soffcnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SOFFCNT", 0x4f, regvalue, cur_col, wrap)
+#define ahd_soffcnt_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SOFFCNT", 0x4f, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lqistat0_print;
+aic_reg_print_t ahd_lqistat0_print;
 #else
-#define ahd_lqistat0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LQISTAT0", 0x50, regvalue, cur_col, wrap)
+#define ahd_lqistat0_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "LQISTAT0", 0x50, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lqistat1_print;
+aic_reg_print_t ahd_lqistat1_print;
 #else
-#define ahd_lqistat1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LQISTAT1", 0x51, regvalue, cur_col, wrap)
+#define ahd_lqistat1_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "LQISTAT1", 0x51, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lqistat2_print;
+aic_reg_print_t ahd_lqistat2_print;
 #else
-#define ahd_lqistat2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LQISTAT2", 0x52, regvalue, cur_col, wrap)
+#define ahd_lqistat2_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "LQISTAT2", 0x52, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sstat3_print;
+aic_reg_print_t ahd_sstat3_print;
 #else
-#define ahd_sstat3_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SSTAT3", 0x53, regvalue, cur_col, wrap)
+#define ahd_sstat3_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SSTAT3", 0x53, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lqostat0_print;
+aic_reg_print_t ahd_lqostat0_print;
 #else
-#define ahd_lqostat0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LQOSTAT0", 0x54, regvalue, cur_col, wrap)
+#define ahd_lqostat0_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "LQOSTAT0", 0x54, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lqostat1_print;
+aic_reg_print_t ahd_lqostat1_print;
 #else
-#define ahd_lqostat1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LQOSTAT1", 0x55, regvalue, cur_col, wrap)
+#define ahd_lqostat1_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "LQOSTAT1", 0x55, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lqostat2_print;
+aic_reg_print_t ahd_lqostat2_print;
 #else
-#define ahd_lqostat2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LQOSTAT2", 0x56, regvalue, cur_col, wrap)
+#define ahd_lqostat2_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "LQOSTAT2", 0x56, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_simode1_print;
+aic_reg_print_t ahd_simode1_print;
 #else
-#define ahd_simode1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SIMODE1", 0x57, regvalue, cur_col, wrap)
+#define ahd_simode1_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SIMODE1", 0x57, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dffsxfrctl_print;
+aic_reg_print_t ahd_dffsxfrctl_print;
 #else
-#define ahd_dffsxfrctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFFSXFRCTL", 0x5a, regvalue, cur_col, wrap)
+#define ahd_dffsxfrctl_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "DFFSXFRCTL", 0x5a, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_seqintsrc_print;
+aic_reg_print_t ahd_seqintsrc_print;
 #else
-#define ahd_seqintsrc_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SEQINTSRC", 0x5b, regvalue, cur_col, wrap)
+#define ahd_seqintsrc_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SEQINTSRC", 0x5b, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_seqimode_print;
+aic_reg_print_t ahd_seqimode_print;
 #else
-#define ahd_seqimode_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SEQIMODE", 0x5c, regvalue, cur_col, wrap)
+#define ahd_seqimode_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SEQIMODE", 0x5c, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_mdffstat_print;
+aic_reg_print_t ahd_mdffstat_print;
 #else
-#define ahd_mdffstat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "MDFFSTAT", 0x5d, regvalue, cur_col, wrap)
+#define ahd_mdffstat_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "MDFFSTAT", 0x5d, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_seloid_print;
+aic_reg_print_t ahd_seloid_print;
 #else
-#define ahd_seloid_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SELOID", 0x6b, regvalue, cur_col, wrap)
+#define ahd_seloid_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SELOID", 0x6b, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sg_state_print;
+aic_reg_print_t ahd_sg_state_print;
 #else
-#define ahd_sg_state_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SG_STATE", 0xa6, regvalue, cur_col, wrap)
+#define ahd_sg_state_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SG_STATE", 0xa6, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ccscbctl_print;
+aic_reg_print_t ahd_ccscbctl_print;
 #else
-#define ahd_ccscbctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CCSCBCTL", 0xad, regvalue, cur_col, wrap)
+#define ahd_ccscbctl_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "CCSCBCTL", 0xad, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ccsgctl_print;
+aic_reg_print_t ahd_ccsgctl_print;
 #else
-#define ahd_ccsgctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CCSGCTL", 0xad, regvalue, cur_col, wrap)
+#define ahd_ccsgctl_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "CCSGCTL", 0xad, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_seqctl0_print;
+aic_reg_print_t ahd_seqctl0_print;
 #else
-#define ahd_seqctl0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SEQCTL0", 0xd6, regvalue, cur_col, wrap)
+#define ahd_seqctl0_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SEQCTL0", 0xd6, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_seqintctl_print;
+aic_reg_print_t ahd_seqintctl_print;
 #else
-#define ahd_seqintctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SEQINTCTL", 0xd9, regvalue, cur_col, wrap)
+#define ahd_seqintctl_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SEQINTCTL", 0xd9, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sram_base_print;
+aic_reg_print_t ahd_sram_base_print;
 #else
-#define ahd_sram_base_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SRAM_BASE", 0x100, regvalue, cur_col, wrap)
+#define ahd_sram_base_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SRAM_BASE", 0x100, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_qfreeze_count_print;
+aic_reg_print_t ahd_qfreeze_count_print;
 #else
-#define ahd_qfreeze_count_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "QFREEZE_COUNT", 0x132, regvalue, cur_col, wrap)
+#define ahd_qfreeze_count_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "QFREEZE_COUNT", 0x132, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_kernel_qfreeze_count_print;
+aic_reg_print_t ahd_kernel_qfreeze_count_print;
 #else
-#define ahd_kernel_qfreeze_count_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "KERNEL_QFREEZE_COUNT", 0x134, regvalue, cur_col, wrap)
+#define ahd_kernel_qfreeze_count_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "KERNEL_QFREEZE_COUNT", 0x134, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_saved_mode_print;
+aic_reg_print_t ahd_saved_mode_print;
 #else
-#define ahd_saved_mode_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SAVED_MODE", 0x136, regvalue, cur_col, wrap)
+#define ahd_saved_mode_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SAVED_MODE", 0x136, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_seq_flags_print;
+aic_reg_print_t ahd_seq_flags_print;
 #else
-#define ahd_seq_flags_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SEQ_FLAGS", 0x139, regvalue, cur_col, wrap)
+#define ahd_seq_flags_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SEQ_FLAGS", 0x139, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lastphase_print;
+aic_reg_print_t ahd_lastphase_print;
 #else
-#define ahd_lastphase_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LASTPHASE", 0x13c, regvalue, cur_col, wrap)
+#define ahd_lastphase_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "LASTPHASE", 0x13c, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_seq_flags2_print;
+aic_reg_print_t ahd_seq_flags2_print;
 #else
-#define ahd_seq_flags2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SEQ_FLAGS2", 0x14d, regvalue, cur_col, wrap)
+#define ahd_seq_flags2_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SEQ_FLAGS2", 0x14d, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_mk_message_scb_print;
+aic_reg_print_t ahd_mk_message_scb_print;
 #else
-#define ahd_mk_message_scb_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "MK_MESSAGE_SCB", 0x160, regvalue, cur_col, wrap)
+#define ahd_mk_message_scb_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "MK_MESSAGE_SCB", 0x160, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_mk_message_scsiid_print;
+aic_reg_print_t ahd_mk_message_scsiid_print;
 #else
-#define ahd_mk_message_scsiid_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "MK_MESSAGE_SCSIID", 0x162, regvalue, cur_col, wrap)
+#define ahd_mk_message_scsiid_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "MK_MESSAGE_SCSIID", 0x162, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scb_base_print;
+aic_reg_print_t ahd_scb_base_print;
 #else
-#define ahd_scb_base_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCB_BASE", 0x180, regvalue, cur_col, wrap)
+#define ahd_scb_base_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCB_BASE", 0x180, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scb_control_print;
+aic_reg_print_t ahd_scb_control_print;
 #else
-#define ahd_scb_control_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCB_CONTROL", 0x192, regvalue, cur_col, wrap)
+#define ahd_scb_control_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCB_CONTROL", 0x192, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scb_scsiid_print;
+aic_reg_print_t ahd_scb_scsiid_print;
 #else
-#define ahd_scb_scsiid_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCB_SCSIID", 0x193, regvalue, cur_col, wrap)
+#define ahd_scb_scsiid_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCB_SCSIID", 0x193, regvalue, buf)
 #endif
 
 
diff --git a/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped b/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped
index 2e0c58905b9e..0f8e47a5169d 100644
--- a/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped
+++ b/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped
@@ -8,7 +8,7 @@
 
 #include "aic79xx_osm.h"
 
-static const ahd_reg_parse_entry_t INTSTAT_parse_table[] = {
+static const aic_reg_parse_entry_t INTSTAT_parse_table[] = {
 	{ "SPLTINT",		0x01, 0x01 },
 	{ "CMDCMPLT",		0x02, 0x02 },
 	{ "SEQINT",		0x04, 0x04 },
@@ -20,26 +20,26 @@ static const ahd_reg_parse_entry_t INTSTAT_parse_table[] = {
 	{ "INT_PEND",		0xff, 0xff }
 };
 
-int
-ahd_intstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_intstat_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(INTSTAT_parse_table, 9, "INTSTAT",
-	    0x01, regvalue, cur_col, wrap));
+	aic_print_register(INTSTAT_parse_table, 9, "INTSTAT",
+			   0x01, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t HS_MAILBOX_parse_table[] = {
+static const aic_reg_parse_entry_t HS_MAILBOX_parse_table[] = {
 	{ "ENINT_COALESCE",	0x40, 0x40 },
 	{ "HOST_TQINPOS",	0x80, 0x80 }
 };
 
-int
-ahd_hs_mailbox_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_hs_mailbox_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(HS_MAILBOX_parse_table, 2, "HS_MAILBOX",
-	    0x0b, regvalue, cur_col, wrap));
+	aic_print_register(HS_MAILBOX_parse_table, 2, "HS_MAILBOX",
+			   0x0b, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SEQINTSTAT_parse_table[] = {
+static const aic_reg_parse_entry_t SEQINTSTAT_parse_table[] = {
 	{ "SEQ_SPLTINT",	0x01, 0x01 },
 	{ "SEQ_PCIINT",		0x02, 0x02 },
 	{ "SEQ_SCSIINT",	0x04, 0x04 },
@@ -47,14 +47,14 @@ static const ahd_reg_parse_entry_t SEQINTSTAT_parse_table[] = {
 	{ "SEQ_SWTMRTO",	0x10, 0x10 }
 };
 
-int
-ahd_seqintstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_seqintstat_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SEQINTSTAT_parse_table, 5, "SEQINTSTAT",
-	    0x0c, regvalue, cur_col, wrap));
+	aic_print_register(SEQINTSTAT_parse_table, 5, "SEQINTSTAT",
+			   0x0c, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t INTCTL_parse_table[] = {
+static const aic_reg_parse_entry_t INTCTL_parse_table[] = {
 	{ "SPLTINTEN",		0x01, 0x01 },
 	{ "SEQINTEN",		0x02, 0x02 },
 	{ "SCSIINTEN",		0x04, 0x04 },
@@ -65,14 +65,14 @@ static const ahd_reg_parse_entry_t INTCTL_parse_table[] = {
 	{ "SWTMINTMASK",	0x80, 0x80 }
 };
 
-int
-ahd_intctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_intctl_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(INTCTL_parse_table, 8, "INTCTL",
-	    0x18, regvalue, cur_col, wrap));
+	aic_print_register(INTCTL_parse_table, 8, "INTCTL",
+			   0x18, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t DFCNTRL_parse_table[] = {
+static const aic_reg_parse_entry_t DFCNTRL_parse_table[] = {
 	{ "DIRECTIONEN",	0x01, 0x01 },
 	{ "FIFOFLUSH",		0x02, 0x02 },
 	{ "FIFOFLUSHACK",	0x02, 0x02 },
@@ -86,14 +86,14 @@ static const ahd_reg_parse_entry_t DFCNTRL_parse_table[] = {
 	{ "PRELOADEN",		0x80, 0x80 }
 };
 
-int
-ahd_dfcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_dfcntrl_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(DFCNTRL_parse_table, 11, "DFCNTRL",
-	    0x19, regvalue, cur_col, wrap));
+	aic_print_register(DFCNTRL_parse_table, 11, "DFCNTRL",
+			   0x19, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t DFSTATUS_parse_table[] = {
+static const aic_reg_parse_entry_t DFSTATUS_parse_table[] = {
 	{ "FIFOEMP",		0x01, 0x01 },
 	{ "FIFOFULL",		0x02, 0x02 },
 	{ "DFTHRESH",		0x04, 0x04 },
@@ -103,28 +103,28 @@ static const ahd_reg_parse_entry_t DFSTATUS_parse_table[] = {
 	{ "PRELOAD_AVAIL",	0x80, 0x80 }
 };
 
-int
-ahd_dfstatus_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_dfstatus_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(DFSTATUS_parse_table, 7, "DFSTATUS",
-	    0x1a, regvalue, cur_col, wrap));
+	aic_print_register(DFSTATUS_parse_table, 7, "DFSTATUS",
+			   0x1a, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SG_CACHE_SHADOW_parse_table[] = {
+static const aic_reg_parse_entry_t SG_CACHE_SHADOW_parse_table[] = {
 	{ "LAST_SEG_DONE",	0x01, 0x01 },
 	{ "LAST_SEG",		0x02, 0x02 },
 	{ "ODD_SEG",		0x04, 0x04 },
 	{ "SG_ADDR_MASK",	0xf8, 0xf8 }
 };
 
-int
-ahd_sg_cache_shadow_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_sg_cache_shadow_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SG_CACHE_SHADOW_parse_table, 4, "SG_CACHE_SHADOW",
-	    0x1b, regvalue, cur_col, wrap));
+	aic_print_register(SG_CACHE_SHADOW_parse_table, 4, "SG_CACHE_SHADOW",
+			   0x1b, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SCSISEQ0_parse_table[] = {
+static const aic_reg_parse_entry_t SCSISEQ0_parse_table[] = {
 	{ "SCSIRSTO",		0x01, 0x01 },
 	{ "FORCEBUSFREE",	0x10, 0x10 },
 	{ "ENARBO",		0x20, 0x20 },
@@ -132,14 +132,14 @@ static const ahd_reg_parse_entry_t SCSISEQ0_parse_table[] = {
 	{ "TEMODEO",		0x80, 0x80 }
 };
 
-int
-ahd_scsiseq0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_scsiseq0_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SCSISEQ0_parse_table, 5, "SCSISEQ0",
-	    0x3a, regvalue, cur_col, wrap));
+	aic_print_register(SCSISEQ0_parse_table, 5, "SCSISEQ0",
+			   0x3a, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SCSISEQ1_parse_table[] = {
+static const aic_reg_parse_entry_t SCSISEQ1_parse_table[] = {
 	{ "ALTSTIM",		0x01, 0x01 },
 	{ "ENAUTOATNP",		0x02, 0x02 },
 	{ "MANUALP",		0x0c, 0x0c },
@@ -148,14 +148,14 @@ static const ahd_reg_parse_entry_t SCSISEQ1_parse_table[] = {
 	{ "MANUALCTL",		0x40, 0x40 }
 };
 
-int
-ahd_scsiseq1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_scsiseq1_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SCSISEQ1_parse_table, 6, "SCSISEQ1",
-	    0x3b, regvalue, cur_col, wrap));
+	aic_print_register(SCSISEQ1_parse_table, 6, "SCSISEQ1",
+			   0x3b, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t DFFSTAT_parse_table[] = {
+static const aic_reg_parse_entry_t DFFSTAT_parse_table[] = {
 	{ "CURRFIFO_0",		0x00, 0x03 },
 	{ "CURRFIFO_1",		0x01, 0x03 },
 	{ "CURRFIFO_NONE",	0x03, 0x03 },
@@ -164,14 +164,14 @@ static const ahd_reg_parse_entry_t DFFSTAT_parse_table[] = {
 	{ "CURRFIFO",		0x03, 0x03 }
 };
 
-int
-ahd_dffstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_dffstat_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(DFFSTAT_parse_table, 6, "DFFSTAT",
-	    0x3f, regvalue, cur_col, wrap));
+	aic_print_register(DFFSTAT_parse_table, 6, "DFFSTAT",
+			   0x3f, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SCSISIGI_parse_table[] = {
+static const aic_reg_parse_entry_t SCSISIGI_parse_table[] = {
 	{ "P_DATAOUT",		0x00, 0xe0 },
 	{ "P_DATAOUT_DT",	0x20, 0xe0 },
 	{ "P_DATAIN",		0x40, 0xe0 },
@@ -191,14 +191,14 @@ static const ahd_reg_parse_entry_t SCSISIGI_parse_table[] = {
 	{ "PHASE_MASK",		0xe0, 0xe0 }
 };
 
-int
-ahd_scsisigi_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_scsisigi_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SCSISIGI_parse_table, 17, "SCSISIGI",
-	    0x41, regvalue, cur_col, wrap));
+	aic_print_register(SCSISIGI_parse_table, 17, "SCSISIGI",
+			   0x41, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SCSIPHASE_parse_table[] = {
+static const aic_reg_parse_entry_t SCSIPHASE_parse_table[] = {
 	{ "DATA_OUT_PHASE",	0x01, 0x03 },
 	{ "DATA_IN_PHASE",	0x02, 0x03 },
 	{ "DATA_PHASE_MASK",	0x03, 0x03 },
@@ -208,33 +208,33 @@ static const ahd_reg_parse_entry_t SCSIPHASE_parse_table[] = {
 	{ "STATUS_PHASE",	0x20, 0x20 }
 };
 
-int
-ahd_scsiphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_scsiphase_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SCSIPHASE_parse_table, 7, "SCSIPHASE",
-	    0x42, regvalue, cur_col, wrap));
+	aic_print_register(SCSIPHASE_parse_table, 7, "SCSIPHASE",
+			   0x42, regvalue, buf);
 }
 
-int
-ahd_scsibus_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_scsibus_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(NULL, 0, "SCSIBUS",
-	    0x46, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "SCSIBUS",
+			   0x46, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SELID_parse_table[] = {
+static const aic_reg_parse_entry_t SELID_parse_table[] = {
 	{ "ONEBIT",		0x08, 0x08 },
 	{ "SELID_MASK",		0xf0, 0xf0 }
 };
 
-int
-ahd_selid_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_selid_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SELID_parse_table, 2, "SELID",
-	    0x49, regvalue, cur_col, wrap));
+	aic_print_register(SELID_parse_table, 2, "SELID",
+			   0x49, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SIMODE0_parse_table[] = {
+static const aic_reg_parse_entry_t SIMODE0_parse_table[] = {
 	{ "ENARBDO",		0x01, 0x01 },
 	{ "ENSPIORDY",		0x02, 0x02 },
 	{ "ENOVERRUN",		0x04, 0x04 },
@@ -244,14 +244,14 @@ static const ahd_reg_parse_entry_t SIMODE0_parse_table[] = {
 	{ "ENSELDO",		0x40, 0x40 }
 };
 
-int
-ahd_simode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_simode0_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SIMODE0_parse_table, 7, "SIMODE0",
-	    0x4b, regvalue, cur_col, wrap));
+	aic_print_register(SIMODE0_parse_table, 7, "SIMODE0",
+			   0x4b, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SSTAT0_parse_table[] = {
+static const aic_reg_parse_entry_t SSTAT0_parse_table[] = {
 	{ "ARBDO",		0x01, 0x01 },
 	{ "SPIORDY",		0x02, 0x02 },
 	{ "OVERRUN",		0x04, 0x04 },
@@ -262,14 +262,14 @@ static const ahd_reg_parse_entry_t SSTAT0_parse_table[] = {
 	{ "TARGET",		0x80, 0x80 }
 };
 
-int
-ahd_sstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_sstat0_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SSTAT0_parse_table, 8, "SSTAT0",
-	    0x4b, regvalue, cur_col, wrap));
+	aic_print_register(SSTAT0_parse_table, 8, "SSTAT0",
+			   0x4b, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SSTAT1_parse_table[] = {
+static const aic_reg_parse_entry_t SSTAT1_parse_table[] = {
 	{ "REQINIT",		0x01, 0x01 },
 	{ "STRB2FAST",		0x02, 0x02 },
 	{ "SCSIPERR",		0x04, 0x04 },
@@ -280,14 +280,14 @@ static const ahd_reg_parse_entry_t SSTAT1_parse_table[] = {
 	{ "SELTO",		0x80, 0x80 }
 };
 
-int
-ahd_sstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_sstat1_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SSTAT1_parse_table, 8, "SSTAT1",
-	    0x4c, regvalue, cur_col, wrap));
+	aic_print_register(SSTAT1_parse_table, 8, "SSTAT1",
+			   0x4c, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SSTAT2_parse_table[] = {
+static const aic_reg_parse_entry_t SSTAT2_parse_table[] = {
 	{ "BUSFREE_LQO",	0x40, 0xc0 },
 	{ "BUSFREE_DFF0",	0x80, 0xc0 },
 	{ "BUSFREE_DFF1",	0xc0, 0xc0 },
@@ -300,14 +300,14 @@ static const ahd_reg_parse_entry_t SSTAT2_parse_table[] = {
 	{ "BUSFREETIME",	0xc0, 0xc0 }
 };
 
-int
-ahd_sstat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_sstat2_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SSTAT2_parse_table, 10, "SSTAT2",
-	    0x4d, regvalue, cur_col, wrap));
+	aic_print_register(SSTAT2_parse_table, 10, "SSTAT2",
+			   0x4d, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t PERRDIAG_parse_table[] = {
+static const aic_reg_parse_entry_t PERRDIAG_parse_table[] = {
 	{ "DTERR",		0x01, 0x01 },
 	{ "DGFORMERR",		0x02, 0x02 },
 	{ "CRCERR",		0x04, 0x04 },
@@ -318,21 +318,21 @@ static const ahd_reg_parse_entry_t PERRDIAG_parse_table[] = {
 	{ "HIZERO",		0x80, 0x80 }
 };
 
-int
-ahd_perrdiag_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_perrdiag_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(PERRDIAG_parse_table, 8, "PERRDIAG",
-	    0x4e, regvalue, cur_col, wrap));
+	aic_print_register(PERRDIAG_parse_table, 8, "PERRDIAG",
+			   0x4e, regvalue, buf);
 }
 
-int
-ahd_soffcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_soffcnt_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(NULL, 0, "SOFFCNT",
-	    0x4f, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "SOFFCNT",
+			   0x4f, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t LQISTAT0_parse_table[] = {
+static const aic_reg_parse_entry_t LQISTAT0_parse_table[] = {
 	{ "LQIATNCMD",		0x01, 0x01 },
 	{ "LQIATNLQ",		0x02, 0x02 },
 	{ "LQIBADLQT",		0x04, 0x04 },
@@ -341,14 +341,14 @@ static const ahd_reg_parse_entry_t LQISTAT0_parse_table[] = {
 	{ "LQIATNQAS",		0x20, 0x20 }
 };
 
-int
-ahd_lqistat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_lqistat0_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(LQISTAT0_parse_table, 6, "LQISTAT0",
-	    0x50, regvalue, cur_col, wrap));
+	aic_print_register(LQISTAT0_parse_table, 6, "LQISTAT0",
+			   0x50, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t LQISTAT1_parse_table[] = {
+static const aic_reg_parse_entry_t LQISTAT1_parse_table[] = {
 	{ "LQIOVERI_NLQ",	0x01, 0x01 },
 	{ "LQIOVERI_LQ",	0x02, 0x02 },
 	{ "LQIBADLQI",		0x04, 0x04 },
@@ -359,14 +359,14 @@ static const ahd_reg_parse_entry_t LQISTAT1_parse_table[] = {
 	{ "LQIPHASE_LQ",	0x80, 0x80 }
 };
 
-int
-ahd_lqistat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_lqistat1_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(LQISTAT1_parse_table, 8, "LQISTAT1",
-	    0x51, regvalue, cur_col, wrap));
+	aic_print_register(LQISTAT1_parse_table, 8, "LQISTAT1",
+			   0x51, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t LQISTAT2_parse_table[] = {
+static const aic_reg_parse_entry_t LQISTAT2_parse_table[] = {
 	{ "LQIGSAVAIL",		0x01, 0x01 },
 	{ "LQISTOPCMD",		0x02, 0x02 },
 	{ "LQISTOPLQ",		0x04, 0x04 },
@@ -377,26 +377,26 @@ static const ahd_reg_parse_entry_t LQISTAT2_parse_table[] = {
 	{ "PACKETIZED",		0x80, 0x80 }
 };
 
-int
-ahd_lqistat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_lqistat2_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(LQISTAT2_parse_table, 8, "LQISTAT2",
-	    0x52, regvalue, cur_col, wrap));
+	aic_print_register(LQISTAT2_parse_table, 8, "LQISTAT2",
+			   0x52, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SSTAT3_parse_table[] = {
+static const aic_reg_parse_entry_t SSTAT3_parse_table[] = {
 	{ "OSRAMPERR",		0x01, 0x01 },
 	{ "NTRAMPERR",		0x02, 0x02 }
 };
 
-int
-ahd_sstat3_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_sstat3_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SSTAT3_parse_table, 2, "SSTAT3",
-	    0x53, regvalue, cur_col, wrap));
+	aic_print_register(SSTAT3_parse_table, 2, "SSTAT3",
+			   0x53, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t LQOSTAT0_parse_table[] = {
+static const aic_reg_parse_entry_t LQOSTAT0_parse_table[] = {
 	{ "LQOTCRC",		0x01, 0x01 },
 	{ "LQOATNPKT",		0x02, 0x02 },
 	{ "LQOATNLQ",		0x04, 0x04 },
@@ -404,14 +404,14 @@ static const ahd_reg_parse_entry_t LQOSTAT0_parse_table[] = {
 	{ "LQOTARGSCBPERR",	0x10, 0x10 }
 };
 
-int
-ahd_lqostat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_lqostat0_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(LQOSTAT0_parse_table, 5, "LQOSTAT0",
-	    0x54, regvalue, cur_col, wrap));
+	aic_print_register(LQOSTAT0_parse_table, 5, "LQOSTAT0",
+			   0x54, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t LQOSTAT1_parse_table[] = {
+static const aic_reg_parse_entry_t LQOSTAT1_parse_table[] = {
 	{ "LQOPHACHGINPKT",	0x01, 0x01 },
 	{ "LQOBUSFREE",		0x02, 0x02 },
 	{ "LQOBADQAS",		0x04, 0x04 },
@@ -419,28 +419,28 @@ static const ahd_reg_parse_entry_t LQOSTAT1_parse_table[] = {
 	{ "LQOINITSCBPERR",	0x10, 0x10 }
 };
 
-int
-ahd_lqostat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_lqostat1_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(LQOSTAT1_parse_table, 5, "LQOSTAT1",
-	    0x55, regvalue, cur_col, wrap));
+	aic_print_register(LQOSTAT1_parse_table, 5, "LQOSTAT1",
+			   0x55, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t LQOSTAT2_parse_table[] = {
+static const aic_reg_parse_entry_t LQOSTAT2_parse_table[] = {
 	{ "LQOSTOP0",		0x01, 0x01 },
 	{ "LQOPHACHGOUTPKT",	0x02, 0x02 },
 	{ "LQOWAITFIFO",	0x10, 0x10 },
 	{ "LQOPKT",		0xe0, 0xe0 }
 };
 
-int
-ahd_lqostat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_lqostat2_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(LQOSTAT2_parse_table, 4, "LQOSTAT2",
-	    0x56, regvalue, cur_col, wrap));
+	aic_print_register(LQOSTAT2_parse_table, 4, "LQOSTAT2",
+			   0x56, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SIMODE1_parse_table[] = {
+static const aic_reg_parse_entry_t SIMODE1_parse_table[] = {
 	{ "ENREQINIT",		0x01, 0x01 },
 	{ "ENSTRB2FAST",	0x02, 0x02 },
 	{ "ENSCSIPERR",		0x04, 0x04 },
@@ -451,28 +451,28 @@ static const ahd_reg_parse_entry_t SIMODE1_parse_table[] = {
 	{ "ENSELTIMO",		0x80, 0x80 }
 };
 
-int
-ahd_simode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_simode1_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SIMODE1_parse_table, 8, "SIMODE1",
-	    0x57, regvalue, cur_col, wrap));
+	aic_print_register(SIMODE1_parse_table, 8, "SIMODE1",
+			   0x57, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t DFFSXFRCTL_parse_table[] = {
+static const aic_reg_parse_entry_t DFFSXFRCTL_parse_table[] = {
 	{ "RSTCHN",		0x01, 0x01 },
 	{ "CLRCHN",		0x02, 0x02 },
 	{ "CLRSHCNT",		0x04, 0x04 },
 	{ "DFFBITBUCKET",	0x08, 0x08 }
 };
 
-int
-ahd_dffsxfrctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_dffsxfrctl_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(DFFSXFRCTL_parse_table, 4, "DFFSXFRCTL",
-	    0x5a, regvalue, cur_col, wrap));
+	aic_print_register(DFFSXFRCTL_parse_table, 4, "DFFSXFRCTL",
+			   0x5a, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SEQINTSRC_parse_table[] = {
+static const aic_reg_parse_entry_t SEQINTSRC_parse_table[] = {
 	{ "CFG4TCMD",		0x01, 0x01 },
 	{ "CFG4ICMD",		0x02, 0x02 },
 	{ "CFG4TSTAT",		0x04, 0x04 },
@@ -482,14 +482,14 @@ static const ahd_reg_parse_entry_t SEQINTSRC_parse_table[] = {
 	{ "CTXTDONE",		0x40, 0x40 }
 };
 
-int
-ahd_seqintsrc_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_seqintsrc_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SEQINTSRC_parse_table, 7, "SEQINTSRC",
-	    0x5b, regvalue, cur_col, wrap));
+	aic_print_register(SEQINTSRC_parse_table, 7, "SEQINTSRC",
+			   0x5b, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SEQIMODE_parse_table[] = {
+static const aic_reg_parse_entry_t SEQIMODE_parse_table[] = {
 	{ "ENCFG4TCMD",		0x01, 0x01 },
 	{ "ENCFG4ICMD",		0x02, 0x02 },
 	{ "ENCFG4TSTAT",	0x04, 0x04 },
@@ -499,14 +499,14 @@ static const ahd_reg_parse_entry_t SEQIMODE_parse_table[] = {
 	{ "ENCTXTDONE",		0x40, 0x40 }
 };
 
-int
-ahd_seqimode_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_seqimode_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SEQIMODE_parse_table, 7, "SEQIMODE",
-	    0x5c, regvalue, cur_col, wrap));
+	aic_print_register(SEQIMODE_parse_table, 7, "SEQIMODE",
+			   0x5c, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t MDFFSTAT_parse_table[] = {
+static const aic_reg_parse_entry_t MDFFSTAT_parse_table[] = {
 	{ "FIFOFREE",		0x01, 0x01 },
 	{ "DATAINFIFO",		0x02, 0x02 },
 	{ "DLZERO",		0x04, 0x04 },
@@ -516,34 +516,34 @@ static const ahd_reg_parse_entry_t MDFFSTAT_parse_table[] = {
 	{ "SHCNTNEGATIVE",	0x40, 0x40 }
 };
 
-int
-ahd_mdffstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_mdffstat_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(MDFFSTAT_parse_table, 7, "MDFFSTAT",
-	    0x5d, regvalue, cur_col, wrap));
+	aic_print_register(MDFFSTAT_parse_table, 7, "MDFFSTAT",
+			   0x5d, regvalue, buf);
 }
 
-int
-ahd_seloid_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_seloid_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(NULL, 0, "SELOID",
-	    0x6b, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "SELOID",
+			   0x6b, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SG_STATE_parse_table[] = {
+static const aic_reg_parse_entry_t SG_STATE_parse_table[] = {
 	{ "SEGS_AVAIL",		0x01, 0x01 },
 	{ "LOADING_NEEDED",	0x02, 0x02 },
 	{ "FETCH_INPROG",	0x04, 0x04 }
 };
 
-int
-ahd_sg_state_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_sg_state_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SG_STATE_parse_table, 3, "SG_STATE",
-	    0xa6, regvalue, cur_col, wrap));
+	aic_print_register(SG_STATE_parse_table, 3, "SG_STATE",
+			   0xa6, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t CCSCBCTL_parse_table[] = {
+static const aic_reg_parse_entry_t CCSCBCTL_parse_table[] = {
 	{ "CCSCBRESET",		0x01, 0x01 },
 	{ "CCSCBDIR",		0x04, 0x04 },
 	{ "CCSCBEN",		0x08, 0x08 },
@@ -552,14 +552,14 @@ static const ahd_reg_parse_entry_t CCSCBCTL_parse_table[] = {
 	{ "CCSCBDONE",		0x80, 0x80 }
 };
 
-int
-ahd_ccscbctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_ccscbctl_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(CCSCBCTL_parse_table, 6, "CCSCBCTL",
-	    0xad, regvalue, cur_col, wrap));
+	aic_print_register(CCSCBCTL_parse_table, 6, "CCSCBCTL",
+			   0xad, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t CCSGCTL_parse_table[] = {
+static const aic_reg_parse_entry_t CCSGCTL_parse_table[] = {
 	{ "CCSGRESET",		0x01, 0x01 },
 	{ "SG_FETCH_REQ",	0x02, 0x02 },
 	{ "CCSGENACK",		0x08, 0x08 },
@@ -568,14 +568,14 @@ static const ahd_reg_parse_entry_t CCSGCTL_parse_table[] = {
 	{ "CCSGEN",		0x0c, 0x0c }
 };
 
-int
-ahd_ccsgctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_ccsgctl_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(CCSGCTL_parse_table, 6, "CCSGCTL",
-	    0xad, regvalue, cur_col, wrap));
+	aic_print_register(CCSGCTL_parse_table, 6, "CCSGCTL",
+			   0xad, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SEQCTL0_parse_table[] = {
+static const aic_reg_parse_entry_t SEQCTL0_parse_table[] = {
 	{ "LOADRAM",		0x01, 0x01 },
 	{ "SEQRESET",		0x02, 0x02 },
 	{ "STEP",		0x04, 0x04 },
@@ -586,14 +586,14 @@ static const ahd_reg_parse_entry_t SEQCTL0_parse_table[] = {
 	{ "PERRORDIS",		0x80, 0x80 }
 };
 
-int
-ahd_seqctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_seqctl0_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SEQCTL0_parse_table, 8, "SEQCTL0",
-	    0xd6, regvalue, cur_col, wrap));
+	aic_print_register(SEQCTL0_parse_table, 8, "SEQCTL0",
+			   0xd6, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SEQINTCTL_parse_table[] = {
+static const aic_reg_parse_entry_t SEQINTCTL_parse_table[] = {
 	{ "IRET",		0x01, 0x01 },
 	{ "INTMASK1",		0x02, 0x02 },
 	{ "INTMASK2",		0x04, 0x04 },
@@ -603,42 +603,42 @@ static const ahd_reg_parse_entry_t SEQINTCTL_parse_table[] = {
 	{ "INTVEC1DSL",		0x80, 0x80 }
 };
 
-int
-ahd_seqintctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_seqintctl_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SEQINTCTL_parse_table, 7, "SEQINTCTL",
-	    0xd9, regvalue, cur_col, wrap));
+	aic_print_register(SEQINTCTL_parse_table, 7, "SEQINTCTL",
+			   0xd9, regvalue, buf);
 }
 
-int
-ahd_sram_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_sram_base_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(NULL, 0, "SRAM_BASE",
-	    0x100, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "SRAM_BASE",
+			   0x100, regvalue, buf);
 }
 
-int
-ahd_qfreeze_count_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_qfreeze_count_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(NULL, 0, "QFREEZE_COUNT",
-	    0x132, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "QFREEZE_COUNT",
+			   0x132, regvalue, buf);
 }
 
-int
-ahd_kernel_qfreeze_count_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_kernel_qfreeze_count_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(NULL, 0, "KERNEL_QFREEZE_COUNT",
-	    0x134, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "KERNEL_QFREEZE_COUNT",
+			   0x134, regvalue, buf);
 }
 
-int
-ahd_saved_mode_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_saved_mode_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(NULL, 0, "SAVED_MODE",
-	    0x136, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "SAVED_MODE",
+			   0x136, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
+static const aic_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
 	{ "NO_DISCONNECT",	0x01, 0x01 },
 	{ "SPHASE_PENDING",	0x02, 0x02 },
 	{ "DPHASE_PENDING",	0x04, 0x04 },
@@ -650,14 +650,14 @@ static const ahd_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
 	{ "NOT_IDENTIFIED",	0x80, 0x80 }
 };
 
-int
-ahd_seq_flags_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_seq_flags_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SEQ_FLAGS_parse_table, 9, "SEQ_FLAGS",
-	    0x139, regvalue, cur_col, wrap));
+	aic_print_register(SEQ_FLAGS_parse_table, 9, "SEQ_FLAGS",
+			   0x139, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t LASTPHASE_parse_table[] = {
+static const aic_reg_parse_entry_t LASTPHASE_parse_table[] = {
 	{ "P_DATAOUT",		0x00, 0xe0 },
 	{ "P_DATAOUT_DT",	0x20, 0xe0 },
 	{ "P_DATAIN",		0x40, 0xe0 },
@@ -673,48 +673,48 @@ static const ahd_reg_parse_entry_t LASTPHASE_parse_table[] = {
 	{ "PHASE_MASK",		0xe0, 0xe0 }
 };
 
-int
-ahd_lastphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_lastphase_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(LASTPHASE_parse_table, 13, "LASTPHASE",
-	    0x13c, regvalue, cur_col, wrap));
+	aic_print_register(LASTPHASE_parse_table, 13, "LASTPHASE",
+			   0x13c, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SEQ_FLAGS2_parse_table[] = {
+static const aic_reg_parse_entry_t SEQ_FLAGS2_parse_table[] = {
 	{ "PENDING_MK_MESSAGE",	0x01, 0x01 },
 	{ "TARGET_MSG_PENDING",	0x02, 0x02 },
 	{ "SELECTOUT_QFROZEN",	0x04, 0x04 }
 };
 
-int
-ahd_seq_flags2_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_seq_flags2_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SEQ_FLAGS2_parse_table, 3, "SEQ_FLAGS2",
-	    0x14d, regvalue, cur_col, wrap));
+	aic_print_register(SEQ_FLAGS2_parse_table, 3, "SEQ_FLAGS2",
+			   0x14d, regvalue, buf);
 }
 
-int
-ahd_mk_message_scb_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_mk_message_scb_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(NULL, 0, "MK_MESSAGE_SCB",
-	    0x160, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "MK_MESSAGE_SCB",
+			   0x160, regvalue, buf);
 }
 
-int
-ahd_mk_message_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_mk_message_scsiid_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(NULL, 0, "MK_MESSAGE_SCSIID",
-	    0x162, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "MK_MESSAGE_SCSIID",
+			   0x162, regvalue, buf);
 }
 
-int
-ahd_scb_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_scb_base_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(NULL, 0, "SCB_BASE",
-	    0x180, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "SCB_BASE",
+			   0x180, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
+static const aic_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
 	{ "SCB_TAG_TYPE",	0x03, 0x03 },
 	{ "DISCONNECTED",	0x04, 0x04 },
 	{ "STATUS_RCVD",	0x08, 0x08 },
@@ -724,22 +724,22 @@ static const ahd_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
 	{ "TARGET_SCB",		0x80, 0x80 }
 };
 
-int
-ahd_scb_control_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_scb_control_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SCB_CONTROL_parse_table, 7, "SCB_CONTROL",
-	    0x192, regvalue, cur_col, wrap));
+	aic_print_register(SCB_CONTROL_parse_table, 7, "SCB_CONTROL",
+			   0x192, regvalue, buf);
 }
 
-static const ahd_reg_parse_entry_t SCB_SCSIID_parse_table[] = {
+static const aic_reg_parse_entry_t SCB_SCSIID_parse_table[] = {
 	{ "OID",		0x0f, 0x0f },
 	{ "TID",		0xf0, 0xf0 }
 };
 
-int
-ahd_scb_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahd_scb_scsiid_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahd_print_register(SCB_SCSIID_parse_table, 2, "SCB_SCSIID",
-	    0x193, regvalue, cur_col, wrap));
+	aic_print_register(SCB_SCSIID_parse_table, 2, "SCB_SCSIID",
+			   0x193, regvalue, buf);
 }
 
diff --git a/drivers/scsi/aic7xxx/aic7xxx.h b/drivers/scsi/aic7xxx/aic7xxx.h
index 4ce4e903a759..bdf902a3b7be 100644
--- a/drivers/scsi/aic7xxx/aic7xxx.h
+++ b/drivers/scsi/aic7xxx/aic7xxx.h
@@ -1270,13 +1270,6 @@ extern uint32_t ahc_debug;
 void			ahc_print_devinfo(struct ahc_softc *ahc,
 					  struct ahc_devinfo *dev);
 void			ahc_dump_card_state(struct ahc_softc *ahc);
-int			ahc_print_register(const ahc_reg_parse_entry_t *table,
-					   u_int num_entries,
-					   const char *name,
-					   u_int address,
-					   u_int value,
-					   u_int *cur_column,
-					   u_int wrap_point);
 /******************************* SEEPROM *************************************/
 int		ahc_acquire_seeprom(struct ahc_softc *ahc,
 				    struct seeprom_descriptor *sd);
diff --git a/drivers/scsi/aic7xxx/aic7xxx_core.c b/drivers/scsi/aic7xxx/aic7xxx_core.c
index 381846164003..b0e66707fef7 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_core.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_core.c
@@ -7116,60 +7116,12 @@ ahc_download_instr(struct ahc_softc *ahc, u_int instrptr, uint8_t *dconsts)
 	}
 }
 
-int
-ahc_print_register(const ahc_reg_parse_entry_t *table, u_int num_entries,
-		   const char *name, u_int address, u_int value,
-		   u_int *cur_column, u_int wrap_point)
-{
-	int	printed;
-	u_int	printed_mask;
-
-	if (cur_column != NULL && *cur_column >= wrap_point) {
-		printk("\n");
-		*cur_column = 0;
-	}
-	printed  = printk("%s[0x%x]", name, value);
-	if (table == NULL) {
-		printed += printk(" ");
-		*cur_column += printed;
-		return (printed);
-	}
-	printed_mask = 0;
-	while (printed_mask != 0xFF) {
-		int entry;
-
-		for (entry = 0; entry < num_entries; entry++) {
-			if (((value & table[entry].mask)
-			  != table[entry].value)
-			 || ((printed_mask & table[entry].mask)
-			  == table[entry].mask))
-				continue;
-
-			printed += printk("%s%s",
-					  printed_mask == 0 ? ":(" : "|",
-					  table[entry].name);
-			printed_mask |= table[entry].mask;
-			
-			break;
-		}
-		if (entry >= num_entries)
-			break;
-	}
-	if (printed_mask != 0)
-		printed += printk(") ");
-	else
-		printed += printk(" ");
-	if (cur_column != NULL)
-		*cur_column += printed;
-	return (printed);
-}
-
 void
 ahc_dump_card_state(struct ahc_softc *ahc)
 {
+	struct aic_dump_buffer buf;
 	struct	scb *scb;
 	struct	scb_tailq *untagged_q;
-	u_int	cur_col;
 	int	paused;
 	int	target;
 	int	maxtarget;
@@ -7201,37 +7153,39 @@ ahc_dump_card_state(struct ahc_softc *ahc)
 	       ahc_inb(ahc, ARG_2));
 	printk("HCNT = 0x%x SCBPTR = 0x%x\n", ahc_inb(ahc, HCNT),
 	       ahc_inb(ahc, SCBPTR));
-	cur_col = 0;
+
+	aic_printbuf_init(&buf, 60);
 	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_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);
-	ahc_sstat1_print(ahc_inb(ahc, SSTAT1), &cur_col, 50);
-	ahc_sstat2_print(ahc_inb(ahc, SSTAT2), &cur_col, 50);
-	ahc_sstat3_print(ahc_inb(ahc, SSTAT3), &cur_col, 50);
-	ahc_simode0_print(ahc_inb(ahc, SIMODE0), &cur_col, 50);
-	ahc_simode1_print(ahc_inb(ahc, SIMODE1), &cur_col, 50);
-	ahc_sxfrctl0_print(ahc_inb(ahc, SXFRCTL0), &cur_col, 50);
-	ahc_dfcntrl_print(ahc_inb(ahc, DFCNTRL), &cur_col, 50);
-	ahc_dfstatus_print(ahc_inb(ahc, DFSTATUS), &cur_col, 50);
-	if (cur_col != 0)
-		printk("\n");
-	printk("STACK:");
+		ahc_scsiphase_print(ahc_inb(ahc, SCSIPHASE), &buf);
+	ahc_scsisigi_print(ahc_inb(ahc, SCSISIGI), &buf);
+	ahc_error_print(ahc_inb(ahc, ERROR), &buf);
+	ahc_scsibusl_print(ahc_inb(ahc, SCSIBUSL), &buf);
+	ahc_lastphase_print(ahc_inb(ahc, LASTPHASE), &buf);
+	ahc_scsiseq_print(ahc_inb(ahc, SCSISEQ), &buf);
+	ahc_sblkctl_print(ahc_inb(ahc, SBLKCTL), &buf);
+	ahc_scsirate_print(ahc_inb(ahc, SCSIRATE), &buf);
+	ahc_seqctl_print(ahc_inb(ahc, SEQCTL), &buf);
+	ahc_seq_flags_print(ahc_inb(ahc, SEQ_FLAGS), &buf);
+	ahc_sstat0_print(ahc_inb(ahc, SSTAT0), &buf);
+	ahc_sstat1_print(ahc_inb(ahc, SSTAT1), &buf);
+	ahc_sstat2_print(ahc_inb(ahc, SSTAT2), &buf);
+	ahc_sstat3_print(ahc_inb(ahc, SSTAT3), &buf);
+	ahc_simode0_print(ahc_inb(ahc, SIMODE0), &buf);
+	ahc_simode1_print(ahc_inb(ahc, SIMODE1), &buf);
+	ahc_sxfrctl0_print(ahc_inb(ahc, SXFRCTL0), &buf);
+	ahc_dfcntrl_print(ahc_inb(ahc, DFCNTRL), &buf);
+	ahc_dfstatus_print(ahc_inb(ahc, DFSTATUS), &buf);
+	aic_printbuf_finish(&buf);
+	aic_printbuf_push(&buf, "STACK:");
 	for (i = 0; i < STACK_SIZE; i++)
-		printk(" 0x%x", ahc_inb(ahc, STACK)|(ahc_inb(ahc, STACK) << 8));
+		aic_printbuf_push(&buf, " 0x%x",
+				  ahc_inb(ahc, STACK)|(ahc_inb(ahc, STACK) << 8));
+	aic_printbuf_finish(&buf);
 	printk("\nSCB count = %d\n", ahc->scb_data->numscbs);
 	printk("Kernel NEXTQSCB = %d\n", ahc->next_queued_scb->hscb->tag);
 	printk("Card NEXTQSCB = %d\n", ahc_inb(ahc, NEXT_QUEUED_SCB));
 	/* QINFIFO */
-	printk("QINFIFO entries: ");
+	aic_printbuf_push(&buf, "QINFIFO entries: ");
 	if ((ahc->features & AHC_QUEUE_REGS) != 0) {
 		qinpos = ahc_inb(ahc, SNSCB_QOFF);
 		ahc_outb(ahc, SNSCB_QOFF, qinpos);
@@ -7239,105 +7193,104 @@ ahc_dump_card_state(struct ahc_softc *ahc)
 		qinpos = ahc_inb(ahc, QINPOS);
 	qintail = ahc->qinfifonext;
 	while (qinpos != qintail) {
-		printk("%d ", ahc->qinfifo[qinpos]);
+		aic_printbuf_push(&buf, "%d ", ahc->qinfifo[qinpos]);
 		qinpos++;
 	}
-	printk("\n");
+	aic_printbuf_finish(&buf);
 
-	printk("Waiting Queue entries: ");
+	aic_printbuf_push(&buf, "Waiting Queue entries: ");
 	scb_index = ahc_inb(ahc, WAITING_SCBH);
 	i = 0;
 	while (scb_index != SCB_LIST_NULL && i++ < 256) {
 		ahc_outb(ahc, SCBPTR, scb_index);
-		printk("%d:%d ", scb_index, ahc_inb(ahc, SCB_TAG));
+		aic_printbuf_push(&buf, "%d:%d ", scb_index,
+				  ahc_inb(ahc, SCB_TAG));
 		scb_index = ahc_inb(ahc, SCB_NEXT);
 	}
-	printk("\n");
+	aic_printbuf_finish(&buf);
 
-	printk("Disconnected Queue entries: ");
+	aic_printbuf_push(&buf, "Disconnected Queue entries: ");
 	scb_index = ahc_inb(ahc, DISCONNECTED_SCBH);
 	i = 0;
 	while (scb_index != SCB_LIST_NULL && i++ < 256) {
 		ahc_outb(ahc, SCBPTR, scb_index);
-		printk("%d:%d ", scb_index, ahc_inb(ahc, SCB_TAG));
+		aic_printbuf_push(&buf, "%d:%d ", scb_index, ahc_inb(ahc, SCB_TAG));
 		scb_index = ahc_inb(ahc, SCB_NEXT);
 	}
-	printk("\n");
-		
+	aic_printbuf_finish(&buf);
+
 	ahc_sync_qoutfifo(ahc, BUS_DMASYNC_POSTREAD);
-	printk("QOUTFIFO entries: ");
+	aic_printbuf_push(&buf, "QOUTFIFO entries: ");
 	qoutpos = ahc->qoutfifonext;
 	i = 0;
 	while (ahc->qoutfifo[qoutpos] != SCB_LIST_NULL && i++ < 256) {
-		printk("%d ", ahc->qoutfifo[qoutpos]);
+		aic_printbuf_push(&buf, "%d ", ahc->qoutfifo[qoutpos]);
 		qoutpos++;
 	}
-	printk("\n");
+	aic_printbuf_finish(&buf);
 
-	printk("Sequencer Free SCB List: ");
+	aic_printbuf_push(&buf, "Sequencer Free SCB List: ");
 	scb_index = ahc_inb(ahc, FREE_SCBH);
 	i = 0;
 	while (scb_index != SCB_LIST_NULL && i++ < 256) {
 		ahc_outb(ahc, SCBPTR, scb_index);
-		printk("%d ", scb_index);
+		aic_printbuf_push(&buf, "%d ", scb_index);
 		scb_index = ahc_inb(ahc, SCB_NEXT);
 	}
-	printk("\n");
+	aic_printbuf_finish(&buf);
 
-	printk("Sequencer SCB Info: ");
+	printk("Sequencer SCB Info:\n");
 	for (i = 0; i < ahc->scb_data->maxhscbs; i++) {
 		ahc_outb(ahc, SCBPTR, i);
-		cur_col  = printk("\n%3d ", i);
-
-		ahc_scb_control_print(ahc_inb(ahc, SCB_CONTROL), &cur_col, 60);
-		ahc_scb_scsiid_print(ahc_inb(ahc, SCB_SCSIID), &cur_col, 60);
-		ahc_scb_lun_print(ahc_inb(ahc, SCB_LUN), &cur_col, 60);
-		ahc_scb_tag_print(ahc_inb(ahc, SCB_TAG), &cur_col, 60);
+		aic_printbuf_push(&buf, "%3d ", i);
+		ahc_scb_control_print(ahc_inb(ahc, SCB_CONTROL), &buf);
+		ahc_scb_scsiid_print(ahc_inb(ahc, SCB_SCSIID), &buf);
+		ahc_scb_lun_print(ahc_inb(ahc, SCB_LUN), &buf);
+		ahc_scb_tag_print(ahc_inb(ahc, SCB_TAG), &buf);
+		aic_printbuf_finish(&buf);
 	}
-	printk("\n");
 
-	printk("Pending list: ");
+	printk("Pending list:\n");
 	i = 0;
 	LIST_FOREACH(scb, &ahc->pending_scbs, pending_links) {
 		if (i++ > 256)
 			break;
-		cur_col  = printk("\n%3d ", scb->hscb->tag);
-		ahc_scb_control_print(scb->hscb->control, &cur_col, 60);
-		ahc_scb_scsiid_print(scb->hscb->scsiid, &cur_col, 60);
-		ahc_scb_lun_print(scb->hscb->lun, &cur_col, 60);
+		aic_printbuf_push(&buf, "%3d ", scb->hscb->tag);
+		ahc_scb_control_print(scb->hscb->control, &buf);
+		ahc_scb_scsiid_print(scb->hscb->scsiid, &buf);
+		ahc_scb_lun_print(scb->hscb->lun, &buf);
 		if ((ahc->flags & AHC_PAGESCBS) == 0) {
 			ahc_outb(ahc, SCBPTR, scb->hscb->tag);
-			printk("(");
-			ahc_scb_control_print(ahc_inb(ahc, SCB_CONTROL),
-					      &cur_col, 60);
-			ahc_scb_tag_print(ahc_inb(ahc, SCB_TAG), &cur_col, 60);
-			printk(")");
+			aic_printbuf_push(&buf, "(");
+			ahc_scb_control_print(ahc_inb(ahc, SCB_CONTROL), &buf);
+			ahc_scb_tag_print(ahc_inb(ahc, SCB_TAG), &buf);
+			aic_printbuf_push(&buf, ")");
 		}
+		aic_printbuf_finish(&buf);
 	}
-	printk("\n");
 
-	printk("Kernel Free SCB list: ");
+	aic_printbuf_push(&buf, "Kernel Free SCB list: ");
 	i = 0;
 	SLIST_FOREACH(scb, &ahc->scb_data->free_scbs, links.sle) {
 		if (i++ > 256)
 			break;
-		printk("%d ", scb->hscb->tag);
+		aic_printbuf_push(&buf, "%d ", scb->hscb->tag);
 	}
-	printk("\n");
+	aic_printbuf_finish(&buf);
 
 	maxtarget = (ahc->features & (AHC_WIDE|AHC_TWIN)) ? 15 : 7;
 	for (target = 0; target <= maxtarget; target++) {
 		untagged_q = &ahc->untagged_queues[target];
 		if (TAILQ_FIRST(untagged_q) == NULL)
 			continue;
-		printk("Untagged Q(%d): ", target);
+		aic_printbuf_push(&buf, "Untagged Q(%d): ", target);
 		i = 0;
 		TAILQ_FOREACH(scb, untagged_q, links.tqe) {
 			if (i++ > 256)
 				break;
-			printk("%d ", scb->hscb->tag);
+			aic_printbuf_push(&buf, "%d ", scb->hscb->tag);
 		}
-		printk("\n");
+		aic_printbuf_finish(&buf);
 	}
 
 	printk("\n<<<<<<<<<<<<<<<<< Dump Card State Ends >>>>>>>>>>>>>>>>>>\n");
diff --git a/drivers/scsi/aic7xxx/aic7xxx_reg.h_shipped b/drivers/scsi/aic7xxx/aic7xxx_reg.h_shipped
index 473039df0ed5..44902ac70ac5 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_reg.h_shipped
+++ b/drivers/scsi/aic7xxx/aic7xxx_reg.h_shipped
@@ -5,186 +5,179 @@
  * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.seq#58 $
  * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.reg#40 $
  */
-typedef int (ahc_reg_print_t)(u_int, u_int *, u_int);
-typedef struct ahc_reg_parse_entry {
-	char	*name;
-	uint8_t	 value;
-	uint8_t	 mask;
-} ahc_reg_parse_entry_t;
-
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_scsiseq_print;
+aic_reg_print_t ahc_scsiseq_print;
 #else
-#define ahc_scsiseq_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SCSISEQ", 0x00, regvalue, cur_col, wrap)
+#define ahc_scsiseq_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCSISEQ", 0x00, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_sxfrctl0_print;
+aic_reg_print_t ahc_sxfrctl0_print;
 #else
-#define ahc_sxfrctl0_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SXFRCTL0", 0x01, regvalue, cur_col, wrap)
+#define ahc_sxfrctl0_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SXFRCTL0", 0x01, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_scsisigi_print;
+aic_reg_print_t ahc_scsisigi_print;
 #else
-#define ahc_scsisigi_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SCSISIGI", 0x03, regvalue, cur_col, wrap)
+#define ahc_scsisigi_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCSISIGI", 0x03, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_scsirate_print;
+aic_reg_print_t ahc_scsirate_print;
 #else
-#define ahc_scsirate_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SCSIRATE", 0x04, regvalue, cur_col, wrap)
+#define ahc_scsirate_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCSIRATE", 0x04, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_sstat0_print;
+aic_reg_print_t ahc_sstat0_print;
 #else
-#define ahc_sstat0_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SSTAT0", 0x0b, regvalue, cur_col, wrap)
+#define ahc_sstat0_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SSTAT0", 0x0b, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_sstat1_print;
+aic_reg_print_t ahc_sstat1_print;
 #else
-#define ahc_sstat1_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SSTAT1", 0x0c, regvalue, cur_col, wrap)
+#define ahc_sstat1_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SSTAT1", 0x0c, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_sstat2_print;
+aic_reg_print_t ahc_sstat2_print;
 #else
-#define ahc_sstat2_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SSTAT2", 0x0d, regvalue, cur_col, wrap)
+#define ahc_sstat2_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SSTAT2", 0x0d, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_sstat3_print;
+aic_reg_print_t ahc_sstat3_print;
 #else
-#define ahc_sstat3_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SSTAT3", 0x0e, regvalue, cur_col, wrap)
+#define ahc_sstat3_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SSTAT3", 0x0e, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_simode0_print;
+aic_reg_print_t ahc_simode0_print;
 #else
-#define ahc_simode0_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SIMODE0", 0x10, regvalue, cur_col, wrap)
+#define ahc_simode0_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SIMODE0", 0x10, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_simode1_print;
+aic_reg_print_t ahc_simode1_print;
 #else
-#define ahc_simode1_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SIMODE1", 0x11, regvalue, cur_col, wrap)
+#define ahc_simode1_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SIMODE1", 0x11, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_scsibusl_print;
+aic_reg_print_t ahc_scsibusl_print;
 #else
-#define ahc_scsibusl_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SCSIBUSL", 0x12, regvalue, cur_col, wrap)
+#define ahc_scsibusl_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCSIBUSL", 0x12, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_sblkctl_print;
+aic_reg_print_t ahc_sblkctl_print;
 #else
-#define ahc_sblkctl_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SBLKCTL", 0x1f, regvalue, cur_col, wrap)
+#define ahc_sblkctl_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SBLKCTL", 0x1f, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_seq_flags_print;
+aic_reg_print_t ahc_seq_flags_print;
 #else
-#define ahc_seq_flags_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SEQ_FLAGS", 0x3c, regvalue, cur_col, wrap)
+#define ahc_seq_flags_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SEQ_FLAGS", 0x3c, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_lastphase_print;
+aic_reg_print_t ahc_lastphase_print;
 #else
-#define ahc_lastphase_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "LASTPHASE", 0x3f, regvalue, cur_col, wrap)
+#define ahc_lastphase_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "LASTPHASE", 0x3f, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_seqctl_print;
+aic_reg_print_t ahc_seqctl_print;
 #else
-#define ahc_seqctl_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SEQCTL", 0x60, regvalue, cur_col, wrap)
+#define ahc_seqctl_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SEQCTL", 0x60, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_sram_base_print;
+aic_reg_print_t ahc_sram_base_print;
 #else
-#define ahc_sram_base_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SRAM_BASE", 0x70, regvalue, cur_col, wrap)
+#define ahc_sram_base_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SRAM_BASE", 0x70, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_error_print;
+aic_reg_print_t ahc_error_print;
 #else
-#define ahc_error_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "ERROR", 0x92, regvalue, cur_col, wrap)
+#define ahc_error_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "ERROR", 0x92, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_dfcntrl_print;
+aic_reg_print_t ahc_dfcntrl_print;
 #else
-#define ahc_dfcntrl_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "DFCNTRL", 0x93, regvalue, cur_col, wrap)
+#define ahc_dfcntrl_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "DFCNTRL", 0x93, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_dfstatus_print;
+aic_reg_print_t ahc_dfstatus_print;
 #else
-#define ahc_dfstatus_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "DFSTATUS", 0x94, regvalue, cur_col, wrap)
+#define ahc_dfstatus_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "DFSTATUS", 0x94, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_scsiphase_print;
+aic_reg_print_t ahc_scsiphase_print;
 #else
-#define ahc_scsiphase_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SCSIPHASE", 0x9e, regvalue, cur_col, wrap)
+#define ahc_scsiphase_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCSIPHASE", 0x9e, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_scb_base_print;
+aic_reg_print_t ahc_scb_base_print;
 #else
-#define ahc_scb_base_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SCB_BASE", 0xa0, regvalue, cur_col, wrap)
+#define ahc_scb_base_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCB_BASE", 0xa0, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_scb_control_print;
+aic_reg_print_t ahc_scb_control_print;
 #else
-#define ahc_scb_control_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SCB_CONTROL", 0xb8, regvalue, cur_col, wrap)
+#define ahc_scb_control_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCB_CONTROL", 0xb8, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_scb_scsiid_print;
+aic_reg_print_t ahc_scb_scsiid_print;
 #else
-#define ahc_scb_scsiid_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SCB_SCSIID", 0xb9, regvalue, cur_col, wrap)
+#define ahc_scb_scsiid_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCB_SCSIID", 0xb9, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_scb_lun_print;
+aic_reg_print_t ahc_scb_lun_print;
 #else
-#define ahc_scb_lun_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SCB_LUN", 0xba, regvalue, cur_col, wrap)
+#define ahc_scb_lun_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCB_LUN", 0xba, regvalue, buf)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahc_reg_print_t ahc_scb_tag_print;
+aic_reg_print_t ahc_scb_tag_print;
 #else
-#define ahc_scb_tag_print(regvalue, cur_col, wrap) \
-    ahc_print_register(NULL, 0, "SCB_TAG", 0xbb, regvalue, cur_col, wrap)
+#define ahc_scb_tag_print(regvalue, buf) \
+    aic_print_register(NULL, 0, "SCB_TAG", 0xbb, regvalue, buf)
 #endif
 
 
diff --git a/drivers/scsi/aic7xxx/aic7xxx_reg_print.c_shipped b/drivers/scsi/aic7xxx/aic7xxx_reg_print.c_shipped
index 9f9b88047d0c..7e35960857c5 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_reg_print.c_shipped
+++ b/drivers/scsi/aic7xxx/aic7xxx_reg_print.c_shipped
@@ -8,7 +8,7 @@
 
 #include "aic7xxx_osm.h"
 
-static const ahc_reg_parse_entry_t SCSISEQ_parse_table[] = {
+static const aic_reg_parse_entry_t SCSISEQ_parse_table[] = {
 	{ "SCSIRSTO",		0x01, 0x01 },
 	{ "ENAUTOATNP",		0x02, 0x02 },
 	{ "ENAUTOATNI",		0x04, 0x04 },
@@ -19,14 +19,14 @@ static const ahc_reg_parse_entry_t SCSISEQ_parse_table[] = {
 	{ "TEMODE",		0x80, 0x80 }
 };
 
-int
-ahc_scsiseq_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_scsiseq_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SCSISEQ_parse_table, 8, "SCSISEQ",
-	    0x00, regvalue, cur_col, wrap));
+	aic_print_register(SCSISEQ_parse_table, 8, "SCSISEQ",
+			   0x00, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SXFRCTL0_parse_table[] = {
+static const aic_reg_parse_entry_t SXFRCTL0_parse_table[] = {
 	{ "CLRCHN",		0x02, 0x02 },
 	{ "SCAMEN",		0x04, 0x04 },
 	{ "SPIOEN",		0x08, 0x08 },
@@ -36,14 +36,14 @@ static const ahc_reg_parse_entry_t SXFRCTL0_parse_table[] = {
 	{ "DFON",		0x80, 0x80 }
 };
 
-int
-ahc_sxfrctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_sxfrctl0_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SXFRCTL0_parse_table, 7, "SXFRCTL0",
-	    0x01, regvalue, cur_col, wrap));
+	aic_print_register(SXFRCTL0_parse_table, 7, "SXFRCTL0",
+			   0x01, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SCSISIGI_parse_table[] = {
+static const aic_reg_parse_entry_t SCSISIGI_parse_table[] = {
 	{ "ACKI",		0x01, 0x01 },
 	{ "REQI",		0x02, 0x02 },
 	{ "BSYI",		0x04, 0x04 },
@@ -63,14 +63,14 @@ static const ahc_reg_parse_entry_t SCSISIGI_parse_table[] = {
 	{ "P_MESGIN",		0xe0, 0xe0 }
 };
 
-int
-ahc_scsisigi_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_scsisigi_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SCSISIGI_parse_table, 17, "SCSISIGI",
-	    0x03, regvalue, cur_col, wrap));
+	aic_print_register(SCSISIGI_parse_table, 17, "SCSISIGI",
+			   0x03, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SCSIRATE_parse_table[] = {
+static const aic_reg_parse_entry_t SCSIRATE_parse_table[] = {
 	{ "SINGLE_EDGE",	0x10, 0x10 },
 	{ "ENABLE_CRC",		0x40, 0x40 },
 	{ "WIDEXFER",		0x80, 0x80 },
@@ -79,14 +79,14 @@ static const ahc_reg_parse_entry_t SCSIRATE_parse_table[] = {
 	{ "SXFR",		0x70, 0x70 }
 };
 
-int
-ahc_scsirate_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_scsirate_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SCSIRATE_parse_table, 6, "SCSIRATE",
-	    0x04, regvalue, cur_col, wrap));
+	aic_print_register(SCSIRATE_parse_table, 6, "SCSIRATE",
+			   0x04, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SSTAT0_parse_table[] = {
+static const aic_reg_parse_entry_t SSTAT0_parse_table[] = {
 	{ "DMADONE",		0x01, 0x01 },
 	{ "SPIORDY",		0x02, 0x02 },
 	{ "SDONE",		0x04, 0x04 },
@@ -98,14 +98,14 @@ static const ahc_reg_parse_entry_t SSTAT0_parse_table[] = {
 	{ "TARGET",		0x80, 0x80 }
 };
 
-int
-ahc_sstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_sstat0_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SSTAT0_parse_table, 9, "SSTAT0",
-	    0x0b, regvalue, cur_col, wrap));
+	aic_print_register(SSTAT0_parse_table, 9, "SSTAT0",
+			   0x0b, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SSTAT1_parse_table[] = {
+static const aic_reg_parse_entry_t SSTAT1_parse_table[] = {
 	{ "REQINIT",		0x01, 0x01 },
 	{ "PHASECHG",		0x02, 0x02 },
 	{ "SCSIPERR",		0x04, 0x04 },
@@ -116,14 +116,14 @@ static const ahc_reg_parse_entry_t SSTAT1_parse_table[] = {
 	{ "SELTO",		0x80, 0x80 }
 };
 
-int
-ahc_sstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_sstat1_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SSTAT1_parse_table, 8, "SSTAT1",
-	    0x0c, regvalue, cur_col, wrap));
+	aic_print_register(SSTAT1_parse_table, 8, "SSTAT1",
+			   0x0c, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SSTAT2_parse_table[] = {
+static const aic_reg_parse_entry_t SSTAT2_parse_table[] = {
 	{ "DUAL_EDGE_ERR",	0x01, 0x01 },
 	{ "CRCREQERR",		0x02, 0x02 },
 	{ "CRCENDERR",		0x04, 0x04 },
@@ -134,27 +134,27 @@ static const ahc_reg_parse_entry_t SSTAT2_parse_table[] = {
 	{ "SFCNT",		0x1f, 0x1f }
 };
 
-int
-ahc_sstat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_sstat2_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SSTAT2_parse_table, 8, "SSTAT2",
-	    0x0d, regvalue, cur_col, wrap));
+	aic_print_register(SSTAT2_parse_table, 8, "SSTAT2",
+			   0x0d, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SSTAT3_parse_table[] = {
+static const aic_reg_parse_entry_t SSTAT3_parse_table[] = {
 	{ "OFFCNT",		0x0f, 0x0f },
 	{ "U2OFFCNT",		0x7f, 0x7f },
 	{ "SCSICNT",		0xf0, 0xf0 }
 };
 
-int
-ahc_sstat3_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_sstat3_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SSTAT3_parse_table, 3, "SSTAT3",
-	    0x0e, regvalue, cur_col, wrap));
+	aic_print_register(SSTAT3_parse_table, 3, "SSTAT3",
+			   0x0e, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SIMODE0_parse_table[] = {
+static const aic_reg_parse_entry_t SIMODE0_parse_table[] = {
 	{ "ENDMADONE",		0x01, 0x01 },
 	{ "ENSPIORDY",		0x02, 0x02 },
 	{ "ENSDONE",		0x04, 0x04 },
@@ -165,14 +165,14 @@ static const ahc_reg_parse_entry_t SIMODE0_parse_table[] = {
 	{ "ENSELDO",		0x40, 0x40 }
 };
 
-int
-ahc_simode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_simode0_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SIMODE0_parse_table, 8, "SIMODE0",
-	    0x10, regvalue, cur_col, wrap));
+	aic_print_register(SIMODE0_parse_table, 8, "SIMODE0",
+			   0x10, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SIMODE1_parse_table[] = {
+static const aic_reg_parse_entry_t SIMODE1_parse_table[] = {
 	{ "ENREQINIT",		0x01, 0x01 },
 	{ "ENPHASECHG",		0x02, 0x02 },
 	{ "ENSCSIPERR",		0x04, 0x04 },
@@ -183,21 +183,21 @@ static const ahc_reg_parse_entry_t SIMODE1_parse_table[] = {
 	{ "ENSELTIMO",		0x80, 0x80 }
 };
 
-int
-ahc_simode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_simode1_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SIMODE1_parse_table, 8, "SIMODE1",
-	    0x11, regvalue, cur_col, wrap));
+	aic_print_register(SIMODE1_parse_table, 8, "SIMODE1",
+			   0x11, regvalue, buf);
 }
 
-int
-ahc_scsibusl_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_scsibusl_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(NULL, 0, "SCSIBUSL",
-	    0x12, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "SCSIBUSL",
+			   0x12, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SBLKCTL_parse_table[] = {
+static const aic_reg_parse_entry_t SBLKCTL_parse_table[] = {
 	{ "XCVR",		0x01, 0x01 },
 	{ "SELWIDE",		0x02, 0x02 },
 	{ "ENAB20",		0x04, 0x04 },
@@ -208,14 +208,14 @@ static const ahc_reg_parse_entry_t SBLKCTL_parse_table[] = {
 	{ "DIAGLEDEN",		0x80, 0x80 }
 };
 
-int
-ahc_sblkctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_sblkctl_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SBLKCTL_parse_table, 8, "SBLKCTL",
-	    0x1f, regvalue, cur_col, wrap));
+	aic_print_register(SBLKCTL_parse_table, 8, "SBLKCTL",
+			   0x1f, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
+static const aic_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
 	{ "NO_DISCONNECT",	0x01, 0x01 },
 	{ "SPHASE_PENDING",	0x02, 0x02 },
 	{ "DPHASE_PENDING",	0x04, 0x04 },
@@ -227,14 +227,14 @@ static const ahc_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
 	{ "NOT_IDENTIFIED",	0x80, 0x80 }
 };
 
-int
-ahc_seq_flags_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_seq_flags_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SEQ_FLAGS_parse_table, 9, "SEQ_FLAGS",
-	    0x3c, regvalue, cur_col, wrap));
+	aic_print_register(SEQ_FLAGS_parse_table, 9, "SEQ_FLAGS",
+			   0x3c, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t LASTPHASE_parse_table[] = {
+static const aic_reg_parse_entry_t LASTPHASE_parse_table[] = {
 	{ "MSGI",		0x20, 0x20 },
 	{ "IOI",		0x40, 0x40 },
 	{ "CDI",		0x80, 0x80 },
@@ -248,14 +248,14 @@ static const ahc_reg_parse_entry_t LASTPHASE_parse_table[] = {
 	{ "P_MESGIN",		0xe0, 0xe0 }
 };
 
-int
-ahc_lastphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_lastphase_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(LASTPHASE_parse_table, 11, "LASTPHASE",
-	    0x3f, regvalue, cur_col, wrap));
+	aic_print_register(LASTPHASE_parse_table, 11, "LASTPHASE",
+			   0x3f, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SEQCTL_parse_table[] = {
+static const aic_reg_parse_entry_t SEQCTL_parse_table[] = {
 	{ "LOADRAM",		0x01, 0x01 },
 	{ "SEQRESET",		0x02, 0x02 },
 	{ "STEP",		0x04, 0x04 },
@@ -266,21 +266,21 @@ static const ahc_reg_parse_entry_t SEQCTL_parse_table[] = {
 	{ "PERRORDIS",		0x80, 0x80 }
 };
 
-int
-ahc_seqctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_seqctl_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SEQCTL_parse_table, 8, "SEQCTL",
-	    0x60, regvalue, cur_col, wrap));
+	aic_print_register(SEQCTL_parse_table, 8, "SEQCTL",
+			   0x60, regvalue, buf);
 }
 
-int
-ahc_sram_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_sram_base_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(NULL, 0, "SRAM_BASE",
-	    0x70, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "SRAM_BASE",
+			   0x70, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t ERROR_parse_table[] = {
+static const aic_reg_parse_entry_t ERROR_parse_table[] = {
 	{ "ILLHADDR",		0x01, 0x01 },
 	{ "ILLSADDR",		0x02, 0x02 },
 	{ "ILLOPCODE",		0x04, 0x04 },
@@ -291,14 +291,14 @@ static const ahc_reg_parse_entry_t ERROR_parse_table[] = {
 	{ "CIOPARERR",		0x80, 0x80 }
 };
 
-int
-ahc_error_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_error_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(ERROR_parse_table, 8, "ERROR",
-	    0x92, regvalue, cur_col, wrap));
+	aic_print_register(ERROR_parse_table, 8, "ERROR",
+			   0x92, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t DFCNTRL_parse_table[] = {
+static const aic_reg_parse_entry_t DFCNTRL_parse_table[] = {
 	{ "FIFORESET",		0x01, 0x01 },
 	{ "FIFOFLUSH",		0x02, 0x02 },
 	{ "DIRECTION",		0x04, 0x04 },
@@ -311,14 +311,14 @@ static const ahc_reg_parse_entry_t DFCNTRL_parse_table[] = {
 	{ "PRELOADEN",		0x80, 0x80 }
 };
 
-int
-ahc_dfcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_dfcntrl_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(DFCNTRL_parse_table, 10, "DFCNTRL",
-	    0x93, regvalue, cur_col, wrap));
+	aic_print_register(DFCNTRL_parse_table, 10, "DFCNTRL",
+			   0x93, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t DFSTATUS_parse_table[] = {
+static const aic_reg_parse_entry_t DFSTATUS_parse_table[] = {
 	{ "FIFOEMP",		0x01, 0x01 },
 	{ "FIFOFULL",		0x02, 0x02 },
 	{ "DFTHRESH",		0x04, 0x04 },
@@ -329,14 +329,14 @@ static const ahc_reg_parse_entry_t DFSTATUS_parse_table[] = {
 	{ "PRELOAD_AVAIL",	0x80, 0x80 }
 };
 
-int
-ahc_dfstatus_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_dfstatus_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(DFSTATUS_parse_table, 8, "DFSTATUS",
-	    0x94, regvalue, cur_col, wrap));
+	aic_print_register(DFSTATUS_parse_table, 8, "DFSTATUS",
+			   0x94, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SCSIPHASE_parse_table[] = {
+static const aic_reg_parse_entry_t SCSIPHASE_parse_table[] = {
 	{ "DATA_OUT_PHASE",	0x01, 0x01 },
 	{ "DATA_IN_PHASE",	0x02, 0x02 },
 	{ "MSG_OUT_PHASE",	0x04, 0x04 },
@@ -346,21 +346,21 @@ static const ahc_reg_parse_entry_t SCSIPHASE_parse_table[] = {
 	{ "DATA_PHASE_MASK",	0x03, 0x03 }
 };
 
-int
-ahc_scsiphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_scsiphase_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SCSIPHASE_parse_table, 7, "SCSIPHASE",
-	    0x9e, regvalue, cur_col, wrap));
+	aic_print_register(SCSIPHASE_parse_table, 7, "SCSIPHASE",
+			   0x9e, regvalue, buf);
 }
 
-int
-ahc_scb_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_scb_base_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(NULL, 0, "SCB_BASE",
-	    0xa0, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "SCB_BASE",
+			   0xa0, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
+static const aic_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
 	{ "DISCONNECTED",	0x04, 0x04 },
 	{ "ULTRAENB",		0x08, 0x08 },
 	{ "MK_MESSAGE",		0x10, 0x10 },
@@ -371,43 +371,43 @@ static const ahc_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
 	{ "SCB_TAG_TYPE",	0x03, 0x03 }
 };
 
-int
-ahc_scb_control_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_scb_control_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SCB_CONTROL_parse_table, 8, "SCB_CONTROL",
-	    0xb8, regvalue, cur_col, wrap));
+	aic_print_register(SCB_CONTROL_parse_table, 8, "SCB_CONTROL",
+			   0xb8, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SCB_SCSIID_parse_table[] = {
+static const aic_reg_parse_entry_t SCB_SCSIID_parse_table[] = {
 	{ "TWIN_CHNLB",		0x80, 0x80 },
 	{ "OID",		0x0f, 0x0f },
 	{ "TWIN_TID",		0x70, 0x70 },
 	{ "TID",		0xf0, 0xf0 }
 };
 
-int
-ahc_scb_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_scb_scsiid_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SCB_SCSIID_parse_table, 4, "SCB_SCSIID",
-	    0xb9, regvalue, cur_col, wrap));
+	aic_print_register(SCB_SCSIID_parse_table, 4, "SCB_SCSIID",
+			   0xb9, regvalue, buf);
 }
 
-static const ahc_reg_parse_entry_t SCB_LUN_parse_table[] = {
+static const aic_reg_parse_entry_t SCB_LUN_parse_table[] = {
 	{ "SCB_XFERLEN_ODD",	0x80, 0x80 },
 	{ "LID",		0x3f, 0x3f }
 };
 
-int
-ahc_scb_lun_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_scb_lun_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(SCB_LUN_parse_table, 2, "SCB_LUN",
-	    0xba, regvalue, cur_col, wrap));
+	aic_print_register(SCB_LUN_parse_table, 2, "SCB_LUN",
+			   0xba, regvalue, buf);
 }
 
-int
-ahc_scb_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
+void
+ahc_scb_tag_print(u_int regvalue, struct aic_dump_buffer *buf)
 {
-	return (ahc_print_register(NULL, 0, "SCB_TAG",
-	    0xbb, regvalue, cur_col, wrap));
+	aic_print_register(NULL, 0, "SCB_TAG",
+			   0xbb, regvalue, buf);
 }
 
diff --git a/drivers/scsi/aic7xxx/aicasm/aicasm_symbol.c b/drivers/scsi/aic7xxx/aicasm/aicasm_symbol.c
index 232aff1fe784..207aa6ca6d2e 100644
--- a/drivers/scsi/aic7xxx/aicasm/aicasm_symbol.c
+++ b/drivers/scsi/aic7xxx/aicasm/aicasm_symbol.c
@@ -52,6 +52,7 @@
 #include <fcntl.h>
 #include <inttypes.h>
 #include <regex.h>
+#include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -353,23 +354,6 @@ aic_print_include(FILE *dfile, char *include_file)
 	fprintf(dfile, "\n#include \"%s\"\n\n", include_file);
 }
 
-void
-aic_print_reg_dump_types(FILE *ofile)
-{
-	if (ofile == NULL)
-		return;
-
-	fprintf(ofile,
-"typedef int (%sreg_print_t)(u_int, u_int *, u_int);\n"
-"typedef struct %sreg_parse_entry {\n"
-"	char	*name;\n"
-"	uint8_t	 value;\n"
-"	uint8_t	 mask;\n"
-"} %sreg_parse_entry_t;\n"
-"\n",
-		prefix, prefix, prefix);
-}
-
 static void
 aic_print_reg_dump_start(FILE *dfile, symbol_node_t *regnode)
 {
@@ -377,8 +361,7 @@ aic_print_reg_dump_start(FILE *dfile, symbol_node_t *regnode)
 		return;
 
 	fprintf(dfile,
-"static const %sreg_parse_entry_t %s_parse_table[] = {\n",
-		prefix,
+"static const aic_reg_parse_entry_t %s_parse_table[] = {\n",
 		regnode->symbol->name);
 }
 
@@ -404,16 +387,15 @@ aic_print_reg_dump_end(FILE *ofile, FILE *dfile,
 "\n");
 
 		fprintf(dfile,
-"int\n"
-"%s%s_print(u_int regvalue, u_int *cur_col, u_int wrap)\n"
+"void\n"
+"%s%s_print(u_int regvalue, struct aic_dump_buffer *buf)\n"
 "{\n"
-"	return (%sprint_register(%s%s, %d, \"%s\",\n"
-"	    0x%02x, regvalue, cur_col, wrap));\n"
+"	aic_print_register(%s%s, %d, \"%s\",\n"
+"			   0x%02x, regvalue, buf);\n"
 "}\n"
 "\n",
 			prefix,
 			lower_name,
-			prefix,
 			num_entries != 0 ? regnode->symbol->name : "NULL",
 			num_entries != 0 ? "_parse_table" : "",
 			num_entries,
@@ -423,18 +405,16 @@ aic_print_reg_dump_end(FILE *ofile, FILE *dfile,
 
 	fprintf(ofile,
 "#if AIC_DEBUG_REGISTERS\n"
-"%sreg_print_t %s%s_print;\n"
+"aic_reg_print_t %s%s_print;\n"
 "#else\n"
-"#define %s%s_print(regvalue, cur_col, wrap) \\\n"
-"    %sprint_register(NULL, 0, \"%s\", 0x%02x, regvalue, cur_col, wrap)\n"
+"#define %s%s_print(regvalue, buf) \\\n"
+"    aic_print_register(NULL, 0, \"%s\", 0x%02x, regvalue, buf)\n"
 "#endif\n"
 "\n",
 		prefix,
-		prefix,
 		lower_name,
 		prefix,
 		lower_name,
-		prefix,
 		regnode->symbol->name,
 		regnode->symbol->info.rinfo->address);
 }
@@ -534,7 +514,6 @@ symtable_dump(FILE *ofile, FILE *dfile)
 
 	/* Register dianostic functions/declarations first. */
 	aic_print_file_prologue(ofile);
-	aic_print_reg_dump_types(ofile);
 	aic_print_file_prologue(dfile);
 	aic_print_include(dfile, stock_include_file);
 	SLIST_FOREACH(curnode, &registers, links) {
diff --git a/drivers/scsi/aic7xxx/aiclib.c b/drivers/scsi/aic7xxx/aiclib.c
index 828ae3d9a510..5869de7a1673 100644
--- a/drivers/scsi/aic7xxx/aiclib.c
+++ b/drivers/scsi/aic7xxx/aiclib.c
@@ -1,34 +1,83 @@
 /*
- * Implementation of Utility functions for all SCSI device types.
+ * Utility functions for AIC driver
  *
- * Copyright (c) 1997, 1998, 1999 Justin T. Gibbs.
- * Copyright (c) 1997, 1998 Kenneth D. Merry.
- * All rights reserved.
+ * Copyright (c) 2017 Michał Mirosław
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions, and the following disclaimer,
- *    without modification, immediately at the beginning of the file.
- * 2. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
- * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD: src/sys/cam/scsi/scsi_all.c,v 1.38 2002/09/23 04:56:35 mjacob Exp $
- * $Id$
+ * License: GPLv2
  */
 
 #include "aiclib.h"
 
+void aic_printbuf_push(struct aic_dump_buffer *buf, const char *fmt, ...)
+{
+	va_list args;
+	char *ptr;
+	int len;
+
+	ptr = buf->buf + buf->cur_col;
+
+	va_start(args, fmt);
+	len = vscnprintf(ptr, sizeof(buf->buf) - buf->cur_col, fmt, args);
+	buf->cur_col += len;
+	va_end(args);
+}
+EXPORT_SYMBOL_GPL(aic_printbuf_push);
+
+void aic_printbuf_finish(struct aic_dump_buffer *buf)
+{
+	if (!buf->cur_col)
+		return;
+
+	printk("%s\n", buf->buf);
+	buf->cur_col = 0;
+}
+EXPORT_SYMBOL_GPL(aic_printbuf_finish);
+
+static void aic_printbuf_maybe_break(struct aic_dump_buffer *buf)
+{
+	if (buf->cur_col >= buf->wrap)
+		aic_printbuf_finish(buf);
+}
+
+void aic_print_register(const aic_reg_parse_entry_t *table, u_int num_entries,
+			const char *name, u_int address, u_int value,
+			struct aic_dump_buffer *buf)
+{
+	u_int	printed_mask;
+
+	aic_printbuf_push(buf, "%s[0x%x]", name, value);
+	if (table == NULL) {
+		aic_printbuf_push(buf, " ");
+		aic_printbuf_maybe_break(buf);
+		return;
+	}
+
+	printed_mask = 0;
+	while (printed_mask != 0xFF) {
+		int entry;
+
+		for (entry = 0; entry < num_entries; entry++) {
+			const aic_reg_parse_entry_t *e = &table[entry];
+			if (((value & e->mask) != e->value) ||
+			    ((printed_mask & e->mask) == e->mask))
+				continue;
+
+			aic_printbuf_push(buf, "%s%s",
+					  printed_mask == 0 ? ":(" : "|",
+					  e->name);
+			printed_mask |= e->mask;
+
+			break;
+		}
+
+		if (entry >= num_entries)
+			break;
+	}
+	if (printed_mask != 0)
+		aic_printbuf_push(buf, ") ");
+	else
+		aic_printbuf_push(buf, " ");
+
+	aic_printbuf_maybe_break(buf);
+}
+EXPORT_SYMBOL_GPL(aic_print_register);
diff --git a/drivers/scsi/aic7xxx/aiclib.h b/drivers/scsi/aic7xxx/aiclib.h
index f8fd198aafbc..f94981f9878a 100644
--- a/drivers/scsi/aic7xxx/aiclib.h
+++ b/drivers/scsi/aic7xxx/aiclib.h
@@ -57,6 +57,38 @@
 #ifndef	_AICLIB_H
 #define _AICLIB_H
 
+#include <linux/blkdev.h>
+#include <linux/types.h>
+
+struct aic_dump_buffer
+{
+	unsigned int cur_col;
+	unsigned int wrap;
+	char buf[256];
+};
+
+typedef void (aic_reg_print_t)(uint32_t, struct aic_dump_buffer *);
+
+typedef struct aic_reg_parse_entry {
+	char    *name;
+	uint8_t  value;
+	uint8_t  mask;
+} aic_reg_parse_entry_t;
+
+static inline void
+aic_printbuf_init(struct aic_dump_buffer *buf, unsigned int wrap)
+{
+	buf->cur_col = 0;
+	buf->wrap = wrap;
+}
+
+void __printf(2, 3) aic_printbuf_push(struct aic_dump_buffer *buf,
+				      const char *fmt, ...);
+void aic_printbuf_finish(struct aic_dump_buffer *buf);
+void aic_print_register(const aic_reg_parse_entry_t *table, u_int num_entries,
+			const char *name, u_int address, u_int value,
+			struct aic_dump_buffer *buf);
+
 struct scsi_sense
 {
 	uint8_t opcode;
-- 
2.11.0