#endif
 
 #include "scsi.h"
+#include <scsi/scsi_dbg.h>
 #include <scsi/scsi_host.h>
 #include "53c7xx.h"
 #include <linux/stat.h>
                printk ("scsi%d : test 2 INQUIRY to target %d, lun 0 : %s\n",
                    host->host_no, i, data + 8);
                printk ("scsi%d : status ", host->host_no);
-               print_status (status);
+               scsi_print_status (status);
                printk ("\nscsi%d : message ", host->host_no);
-               print_msg (&msg);
+               scsi_print_msg (&msg);
                printk ("\n");
            } else if (hostdata->test_completed == 3) {
                printk("scsi%d : test 2 no connection with target %d\n",
            printk ("scsi%d : received message", host->host_no);
            if (c) 
                printk (" from target %d lun %d ", c->device->id, c->device->lun);
-           print_msg ((unsigned char *) hostdata->msg_buf);
+           scsi_print_msg ((unsigned char *) hostdata->msg_buf);
            printk("\n");
        }
        
     case WRITE_10:
 #if 0
        printk("scsi%d : command is ", host->host_no);
-       print_command(cmd->cmnd);
+       __scsi_print_command(cmd->cmnd);
 #endif
 #if 0
        printk ("scsi%d : %d scatter/gather segments\n", host->host_no,
      */
     default:
        printk("scsi%d : datain+dataout for command ", host->host_no);
-       print_command(cmd->cmnd);
+       __scsi_print_command(cmd->cmnd);
        datain = dataout = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
     }
 
            if (cmd) {
                printk("scsi%d : target %d, lun %d, command ",
                    host->host_no, cmd->cmd->device->id, cmd->cmd->device->lun);
-               print_command (cmd->cmd->cmnd);
+               __scsi_print_command (cmd->cmd->cmnd);
                printk("scsi%d : dsp = 0x%x (virt 0x%p)\n", host->host_no,
                    NCR53c7x0_read32(DSP_REG),
                    bus_to_virt(NCR53c7x0_read32(DSP_REG)));
        if (hostdata->options & OPTION_DEBUG_INTR) {
            printk ("scsi%d : command complete : pid %lu, id %d,lun %d result 0x%x ", 
                  host->host_no, tmp->pid, tmp->device->id, tmp->device->lun, tmp->result);
-           print_command (tmp->cmnd);
+           __scsi_print_command (tmp->cmnd);
        }
 
        tmp->scsi_done(tmp);
                printk("scsi%d : interrupt for pid %lu, id %d, lun %d ", 
                    host->host_no, cmd->cmd->pid, (int) cmd->cmd->device->id,
                    (int) cmd->cmd->device->lun);
-               print_command (cmd->cmd->cmnd);
+               __scsi_print_command (cmd->cmd->cmnd);
            } else {
                printk("scsi%d : no active command\n", host->host_no);
            }
            i > 0 && !check_address ((unsigned long) ptr, 1);
            ptr += len, i -= len) {
            printk("               ");
-           len = print_msg (ptr);
+           len = scsi_print_msg (ptr);
            printk("\n");
            if (!len)
                break;
     if (cmd) {
        printk("               result = 0x%x, target = %d, lun = %d, cmd = ",
            cmd->result, cmd->device->id, cmd->device->lun);
-       print_command(cmd->cmnd);
+       __scsi_print_command(cmd->cmnd);
     } else
        printk("\n");
     printk("        + %d : dsa_next = 0x%x\n", hostdata->dsa_next,
                    virt_to_bus(event.dsa), event.dsa);
            if (event.pid != -1) {
                printk ("         event for pid %ld ", event.pid);
-               print_command (event.cmnd);
+               __scsi_print_command (event.cmnd);
            }
        }
     }
 
  * 5.  Test linked command handling code after Eric is ready with 
  *      the high level code.
  */
+#include <scsi/scsi_dbg.h>
 
 #if (NDEBUG & NDEBUG_LISTS)
 #define LIST(x,y) {printk("LINE:%d   Adding %p to %p\n", __LINE__, (void*)(x), (void*)(y)); if ((x)==(y)) udelay(5); }
  * 3..length+1  arguments
  *
  * Start the extended message buffer with the EXTENDED_MESSAGE
- * byte, since print_msg() wants the whole thing.  
+ * byte, since scsi_print_msg() wants the whole thing.  
  */
                                        extended_msg[0] = EXTENDED_MESSAGE;
                                        /* Accept first byte by clearing ACK */
                                default:
                                        if (!tmp) {
                                                printk("scsi%d: rejecting message ", instance->host_no);
-                                               print_msg(extended_msg);
+                                               scsi_print_msg(extended_msg);
                                                printk("\n");
                                        } else if (tmp != EXTENDED_MESSAGE)
                                                printk("scsi%d: rejecting unknown message %02x from target %d, lun %d\n", instance->host_no, tmp, cmd->device->id, cmd->device->lun);
 
        if (!(msg[0] & 0x80)) {
                printk(KERN_ERR "scsi%d : expecting IDENTIFY message, got ", instance->host_no);
-               print_msg(msg);
+               scsi_print_msg(msg);
                abort = 1;
        } else {
                /* Accept message by clearing ACK */
        Scsi_Cmnd *tmp, **prev;
        
        printk(KERN_WARNING "scsi%d : aborting command\n", instance->host_no);
-       print_Scsi_Cmnd(cmd);
+       scsi_print_command(cmd);
 
        NCR5380_print_status(instance);
 
 
 #include <scsi/scsicam.h>
 
 #include "scsi.h"
+#include <scsi/scsi_dbg.h>
 #include <scsi/scsi_host.h>
 #include "aha152x.h"
 
        if (HOSTDATA(shpnt)->debug & debug_queue) {
                printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
                       CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len, SCpnt->use_sg, SCpnt->request_bufflen);
-               print_command(SCpnt->cmnd);
+               __scsi_print_command(SCpnt->cmnd);
        }
 #endif
 
 #if 0
                        if(HOSTDATA(shpnt)->debug & debug_eh) {
                                printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
-                               print_sense("bh", DONE_SC);
+                               scsi_print_sense("bh", DONE_SC);
                        }
 #endif
 
 #if defined(AHA152X_DEBUG)
                if (HOSTDATA(shpnt)->debug & debug_msgi) {
                        printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
-                       print_msg(&MSGI(0));
+                       scsi_print_msg(&MSGI(0));
                        printk("\n");
                }
 #endif
                                                break;
 
                                        printk(INFO_LEAD, CMDINFO(CURRENT_SC));
-                                       print_msg(&MSGI(0));
+                                       scsi_print_msg(&MSGI(0));
                                        printk("\n");
 
                                        ticks = (MSGI(3) * 4 + 49) / 50;
                int i;
 
                printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
-               for (i=0; i<MSGOLEN; i+=print_msg(&MSGO(i)), printk(" "))
+               for (i=0; i<MSGOLEN; i+=scsi_print_msg(&MSGO(i)), printk(" "))
                        ;
                printk(")\n");
        }
 #if defined(AHA152X_DEBUG)
        if (HOSTDATA(shpnt)->debug & debug_cmd) {
                printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
-               print_command(CURRENT_SC->cmnd);
+               __scsi_print_command(CURRENT_SC->cmnd);
        }
 #endif
 
 #if defined(AHA152X_DEBUG)
        if (HOSTDATA(shpnt)->debug & debug_status) {
                printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
-               print_status(CURRENT_SC->SCp.Status);
+               scsi_print_status(CURRENT_SC->SCp.Status);
                printk("\n");
        }
 #endif
        printk(KERN_DEBUG "0x%08x: target=%d; lun=%d; cmnd=(",
               (unsigned int) ptr, ptr->device->id, ptr->device->lun);
 
-       print_command(ptr->cmnd);
+       __scsi_print_command(ptr->cmnd);
 
        printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
               ptr->request_bufflen, ptr->resid);
 
 #include <asm/ecard.h>
 
 #include "../scsi.h"
+#include <scsi/scsi_dbg.h>
 #include <scsi/scsi_host.h>
 #include "acornscsi.h"
 #include "msgqueue.h"
                    default:
                        printk(KERN_ERR "scsi%d.H: incomplete data transfer detected: result=%08X command=",
                                host->host->host_no, SCpnt->result);
-                       print_command(SCpnt->cmnd);
+                       __scsi_print_command(SCpnt->cmnd);
                        acornscsi_dumpdma(host, "done");
                        acornscsi_dumplog(host, SCpnt->device->id);
                        SCpnt->result &= 0xffff;
 
        host->scsi.last_message = msg->msg[0];
 #if (DEBUG & DEBUG_MESSAGES)
-       print_msg(msg->msg);
+       scsi_print_msg(msg->msg);
 #endif
        break;
 
        while ((msg = msgqueue_getmsg(&host->scsi.msgs, msgnr++)) != NULL) {
            unsigned int i;
 #if (DEBUG & DEBUG_MESSAGES)
-           print_msg(msg);
+           scsi_print_msg(msg);
 #endif
            i = 0;
            if (acornscsi_write_pio(host, msg->msg, &i, msg->length, 1000000))
 #if (DEBUG & DEBUG_MESSAGES)
     printk("scsi%d.%c: message in: ",
            host->host->host_no, acornscsi_target(host));
-    print_msg(message);
+    scsi_print_msg(message);
     printk("\n");
 #endif
 
 
 #include <asm/ecard.h>
 
 #include "../scsi.h"
+#include <scsi/scsi_dbg.h>
 #include <scsi/scsi_host.h>
 #include "fas216.h"
 #include "scsi.h"
        va_end(args);
 
        printk(" CDB: ");
-       print_command(SCpnt->cmnd);
+       __scsi_print_command(SCpnt->cmnd);
 }
 
 static void
                                info->host->host_no, '0' + SCpnt->device->id,
                                SCpnt->result, info->scsi.SCp.ptr,
                                info->scsi.SCp.this_residual);
-                       print_command(SCpnt->cmnd);
+                       __scsi_print_command(SCpnt->cmnd);
                        SCpnt->result &= ~(255 << 16);
                        SCpnt->result |= DID_BAD_TARGET << 16;
                        goto request_sense;
                       info->host->host_no, '0' + SCpnt->device->id,
                       info->scsi.SCp.ptr, info->scsi.SCp.this_residual);
                info->scsi.SCp.ptr = NULL;
-               print_command(SCpnt->cmnd);
+               __scsi_print_command(SCpnt->cmnd);
        }
 
        /*
        info->stats.aborts += 1;
 
        printk(KERN_WARNING "scsi%d: abort command ", info->host->host_no);
-       print_command(SCpnt->data_cmnd);
+       __scsi_print_command(SCpnt->data_cmnd);
 
        print_debug_list();
        fas216_dumpstate(info);
 
 #if 0 //def BELT_AND_BRACES
                printk(KERN_WARNING "scsi%d.%c: zero length buffer passed for "
                       "command ", SCpnt->host->host_no, '0' + SCpnt->target);
-               print_command(SCpnt->cmnd);
+               __scsi_print_command(SCpnt->cmnd);
 #endif
                SCpnt->SCp.ptr = NULL;
        }
 
  * 1.  Test linked command handling code after Eric is ready with 
  *     the high level code.
  */
+#include <scsi/scsi_dbg.h>
 
 #if (NDEBUG & NDEBUG_LISTS)
 #define LIST(x,y) \
  * 3..length+1 arguments
  *
  * Start the extended message buffer with the EXTENDED_MESSAGE
- * byte, since print_msg() wants the whole thing.  
+ * byte, since scsi_print_msg() wants the whole thing.  
  */
                    extended_msg[0] = EXTENDED_MESSAGE;
                    /* Accept first byte by clearing ACK */
                default:
                    if (!tmp) {
                        printk(KERN_DEBUG "scsi%d: rejecting message ", HOSTNO);
-                       print_msg (extended_msg);
+                       scsi_print_msg (extended_msg);
                        printk("\n");
                    } else if (tmp != EXTENDED_MESSAGE)
                        printk(KERN_DEBUG "scsi%d: rejecting unknown "
 
     if (!(msg[0] & 0x80)) {
        printk(KERN_DEBUG "scsi%d: expecting IDENTIFY message, got ", HOSTNO);
-       print_msg(msg);
+       scsi_print_msg(msg);
        do_abort(instance);
        return;
     }
     unsigned long flags;
 
     printk(KERN_NOTICE "scsi%d: aborting command\n", HOSTNO);
-    print_Scsi_Cmnd (cmd);
+    scsi_print_command(cmd);
 
     NCR5380_print_status (instance);
 
 
 
 /**
  *
- *     print_status - print scsi status description
+ *     scsi_print_status - print scsi status description
  *     @scsi_status: scsi status value
  *
  *     If the status is recognized, the description is printed.
 
                        scsi_print_command(cmd);
                        if (status_byte(cmd->result) & CHECK_CONDITION) {
                                /*
-                                * XXX The print_sense formatting/prefix
+                                * XXX The scsi_print_sense formatting/prefix
                                 * doesn't match this function.
                                 */
                                scsi_print_sense("", cmd);
 
 #include <linux/config.h>          /* for CONFIG_SCSI_LOGGING */
 
 #include <scsi/scsi_cmnd.h>
-#include <scsi/scsi_dbg.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_request.h>
 #define scsi_to_pci_dma_dir(scsi_dir)  ((int)(scsi_dir))
 #define scsi_to_sbus_dma_dir(scsi_dir) ((int)(scsi_dir))
 
-/*
- * Old names for debug prettyprinting functions.
- */
-static inline void print_Scsi_Cmnd(struct scsi_cmnd *cmd)
-{
-       return scsi_print_command(cmd);
-}
-static inline void print_command(unsigned char *cdb)
-{
-       return __scsi_print_command(cdb);
-}
-static inline void print_sense(const char *devclass, struct scsi_cmnd *cmd)
-{
-       return scsi_print_sense(devclass, cmd);
-}
-static inline void print_req_sense(const char *devclass, struct scsi_request *req)
-{
-       return scsi_print_req_sense(devclass, req);
-}
-static inline void print_driverbyte(int scsiresult)
-{
-       return scsi_print_driverbyte(scsiresult);
-}
-static inline void print_hostbyte(int scsiresult)
-{
-       return scsi_print_hostbyte(scsiresult);
-}
-static inline void print_status(unsigned char status)
-{
-       return scsi_print_status(status);
-}
-static inline int print_msg(const unsigned char *msg)
-{
-       return scsi_print_msg(msg);
-}
-
 /*
  * This is the crap from the old error handling code.  We have it in a special
  * place so that we can more easily delete it later on.
 
 #include <asm/uaccess.h>
 
 #include "scsi.h"
+#include <scsi/scsi_dbg.h>
 #include <scsi/scsi_host.h>
 #include "seagate.h"
 
 
 #if (DEBUG & PRINT_COMMAND)
        printk("scsi%d : target = %d, command = ", hostno, target);
-       print_command((unsigned char *) cmnd);
+       __scsi_print_command((unsigned char *) cmnd);
 #endif
 
 #if (DEBUG & PHASE_RESELECT)
        printk("\n");
 #endif
        printk("scsi%d : status = ", hostno);
-       print_status(status);
+       scsi_print_status(status);
        printk(" message = %02x\n", message);
 #endif
 
 
 #include <linux/delay.h>
 
 #include "scsi.h"
+#include <scsi/scsi_dbg.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_driver.h>
 #include <scsi/scsi_ioctl.h>
                if ((sdp->sgdebug > 0) &&
                    ((CHECK_CONDITION == srp->header.masked_status) ||
                     (COMMAND_TERMINATED == srp->header.masked_status)))
-                       print_req_sense("sg_cmd_done", SRpnt);
+                       scsi_print_req_sense("sg_cmd_done", SRpnt);
 
                /* Following if statement is a patch supplied by Eric Youngdale */
                if (driver_byte(SRpnt->sr_result) != 0
 
  *   finally replaced that by the *_PRINTK() macros.
  *
  */
+#include <scsi/scsi_dbg.h>
 
 /*
  * Further development / testing that should be done : 
  * 3..length+1 arguments
  *
  * Start the extended message buffer with the EXTENDED_MESSAGE
- * byte, since print_msg() wants the whole thing.  
+ * byte, since scsi_print_msg() wants the whole thing.  
  */
                    extended_msg[0] = EXTENDED_MESSAGE;
                    /* Accept first byte by clearing ACK */
                default:
                    if (!tmp) {
                        printk(KERN_DEBUG "scsi%d: rejecting message ", HOSTNO);
-                       print_msg (extended_msg);
+                       scsi_print_msg (extended_msg);
                        printk("\n");
                    } else if (tmp != EXTENDED_MESSAGE)
                        printk(KERN_DEBUG "scsi%d: rejecting unknown "
 
     if (!(msg[0] & 0x80)) {
        printk(KERN_DEBUG "scsi%d: expecting IDENTIFY message, got ", HOSTNO);
-       print_msg(msg);
+       scsi_print_msg(msg);
        do_abort(instance);
        return;
     }
     unsigned long flags;
 
     printk(KERN_NOTICE "scsi%d: aborting command\n", HOSTNO);
-    print_Scsi_Cmnd (cmd);
+    scsi_print_command(cmd);
 
     NCR5380_print_status (instance);