drivers/scsi/mac_esp.c - kernel/msm-4.9 - Gitiles

 /*
  * 68k mac 53c9[46] scsi driver
  *
  * copyright (c) 1998, David Weis weisd3458@uni.edu
  *
  * debugging on Quadra 800 and 660AV Michael Schmitz, Dave Kilzer 7/98
  *
  * based loosely on cyber_esp.c
  */

 /* these are unused for now */
 #define myreadl(addr) (*(volatile unsigned int *) (addr))
 #define mywritel(b, addr) ((*(volatile unsigned int *) (addr)) = (b))


 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/types.h>
 #include <linux/ctype.h>
 #include <linux/string.h>
 #include <linux/slab.h>
 #include <linux/blkdev.h>
 #include <linux/proc_fs.h>
 #include <linux/stat.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>

 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include "NCR53C9x.h"

 #include <asm/io.h>

 #include <asm/setup.h>
 #include <asm/irq.h>
 #include <asm/macints.h>
 #include <asm/machw.h>
 #include <asm/mac_via.h>

 #include <asm/pgtable.h>

 #include <asm/macintosh.h>

 /* #define DEBUG_MAC_ESP */

 extern void esp_handle(struct NCR_ESP *esp);
 extern void mac_esp_intr(int irq, void *dev_id);

 static int  dma_bytes_sent(struct NCR_ESP * esp, int fifo_count);
 static int  dma_can_transfer(struct NCR_ESP * esp, Scsi_Cmnd *sp);
 static void dma_dump_state(struct NCR_ESP * esp);
 static void dma_init_read(struct NCR_ESP * esp, char * vaddress, int length);
 static void dma_init_write(struct NCR_ESP * esp, char * vaddress, int length);
 static void dma_ints_off(struct NCR_ESP * esp);
 static void dma_ints_on(struct NCR_ESP * esp);
 static int  dma_irq_p(struct NCR_ESP * esp);
 static int  dma_irq_p_quick(struct NCR_ESP * esp);
 static void dma_led_off(struct NCR_ESP * esp);
 static void dma_led_on(struct NCR_ESP *esp);
 static int  dma_ports_p(struct NCR_ESP *esp);
 static void dma_setup(struct NCR_ESP * esp, __u32 addr, int count, int write);
 static void dma_setup_quick(struct NCR_ESP * esp, __u32 addr, int count, int write);

 static int esp_dafb_dma_irq_p(struct NCR_ESP * espdev);
 static int esp_iosb_dma_irq_p(struct NCR_ESP * espdev);

 static volatile unsigned char cmd_buffer[16];
 				/* This is where all commands are put
 				 * before they are transferred to the ESP chip
 				 * via PIO.
 				 */

 static int esp_initialized = 0;

 static int setup_num_esps = -1;
 static int setup_disconnect = -1;
 static int setup_nosync = -1;
 static int setup_can_queue = -1;
 static int setup_cmd_per_lun = -1;
 static int setup_sg_tablesize = -1;
 #ifdef SUPPORT_TAGS
 static int setup_use_tagged_queuing = -1;
 #endif
 static int setup_hostid = -1;

 /*
  * Experimental ESP inthandler; check macints.c to make sure dev_id is
  * set up properly!
  */

 void mac_esp_intr(int irq, void *dev_id)
 {
 	struct NCR_ESP *esp = (struct NCR_ESP *) dev_id;
 	int irq_p = 0;

 	/* Handle the one ESP interrupt showing at this IRQ level. */
 	if(((esp)->irq & 0xff) == irq) {
 	/*
 	 * Debug ..
 	 */
 		irq_p = esp->dma_irq_p(esp);
 	 	printk("mac_esp: irq_p %x current %p disconnected %p\n",
 	 		irq_p, esp->current_SC, esp->disconnected_SC);

 		/*
 		 * Mac: if we're here, it's an ESP interrupt for sure!
 		 */
 		if((esp->current_SC || esp->disconnected_SC)) {
 			esp->dma_ints_off(esp);

 			ESPIRQ(("I%d(", esp->esp_id));
 			esp_handle(esp);
 			ESPIRQ((")"));

 			esp->dma_ints_on(esp);
 		}
 	}
 }

 /*
  * Debug hooks; use for playing with the interrupt flag testing and interrupt
  * acknowledge on the various machines
  */

 void scsi_esp_polled(int irq, void *dev_id)
 {
 	if (esp_initialized == 0)
 		return;

 	mac_esp_intr(irq, dev_id);
 }

 void fake_intr(int irq, void *dev_id)
 {
 #ifdef DEBUG_MAC_ESP
 	printk("mac_esp: got irq\n");
 #endif

 	mac_esp_intr(irq, dev_id);
 }

 irqreturn_t fake_drq(int irq, void *dev_id)
 {
 	printk("mac_esp: got drq\n");
 	return IRQ_HANDLED;
 }

 #define DRIVER_SETUP

 /*
  * Function : mac_esp_setup(char *str)
  *
  * Purpose : booter command line initialization of the overrides array,
  *
  * Inputs : str - parameters, separated by commas.
  *
  * Currently unused in the new driver; need to add settable parameters to the
  * detect function.
  *
  */

 static int __init mac_esp_setup(char *str) {
 #ifdef DRIVER_SETUP
 	/* Format of mac53c9x parameter is:
 	 *   mac53c9x=<num_esps>,<disconnect>,<nosync>,<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
 	 * Negative values mean don't change.
 	 */

 	char *this_opt;
 	long opt;

 	this_opt = strsep (&str, ",");
 	if(this_opt) {
 		opt = simple_strtol( this_opt, NULL, 0 );

 		if (opt >= 0 && opt <= 2)
 			setup_num_esps = opt;
 		else if (opt > 2)
 			printk( "mac_esp_setup: invalid number of hosts %ld !\n", opt );

 		this_opt = strsep (&str, ",");
 	}
 	if(this_opt) {
 		opt = simple_strtol( this_opt, NULL, 0 );

 		if (opt > 0)
 			setup_disconnect = opt;

 		this_opt = strsep (&str, ",");
 	}
 	if(this_opt) {
 		opt = simple_strtol( this_opt, NULL, 0 );

 		if (opt >= 0)
 			setup_nosync = opt;

 		this_opt = strsep (&str, ",");
 	}
 	if(this_opt) {
 		opt = simple_strtol( this_opt, NULL, 0 );

 		if (opt > 0)
 			setup_can_queue = opt;

 		this_opt = strsep (&str, ",");
 	}
 	if(this_opt) {
 		opt = simple_strtol( this_opt, NULL, 0 );

 		if (opt > 0)
 			setup_cmd_per_lun = opt;

 		this_opt = strsep (&str, ",");
 	}
 	if(this_opt) {
 		opt = simple_strtol( this_opt, NULL, 0 );

 		if (opt >= 0) {
 			setup_sg_tablesize = opt;
 			/* Must be <= SG_ALL (255) */
 			if (setup_sg_tablesize > SG_ALL)
 				setup_sg_tablesize = SG_ALL;
 		}

 		this_opt = strsep (&str, ",");
 	}
 	if(this_opt) {
 		opt = simple_strtol( this_opt, NULL, 0 );

 		/* Must be between 0 and 7 */
 		if (opt >= 0 && opt <= 7)
 			setup_hostid = opt;
 		else if (opt > 7)
 			printk( "mac_esp_setup: invalid host ID %ld !\n", opt);

 		this_opt = strsep (&str, ",");
 	}
 #ifdef SUPPORT_TAGS
 	if(this_opt) {
 		opt = simple_strtol( this_opt, NULL, 0 );
 		if (opt >= 0)
 			setup_use_tagged_queuing = !!opt;
 	}
 #endif
 #endif
 	return 1;
 }

 __setup("mac53c9x=", mac_esp_setup);


 /*
  * ESP address 'detection'
  */

 unsigned long get_base(int chip_num)
 {
 	/*
 	 * using the chip_num and mac model, figure out where the
 	 * chips are mapped
 	 */

 	unsigned long io_base = 0x50f00000;
 	unsigned int second_offset = 0x402;
 	unsigned long scsi_loc = 0;

 	switch (macintosh_config->scsi_type) {

 	/* 950, 900, 700 */
 	case MAC_SCSI_QUADRA2:
 		scsi_loc =  io_base + 0xf000 + ((chip_num == 0) ? 0 : second_offset);
 		break;

 	/* av's */
 	case MAC_SCSI_QUADRA3:
 		scsi_loc = io_base + 0x18000 + ((chip_num == 0) ? 0 : second_offset);
 		break;

 	/* most quadra/centris models are like this */
 	case MAC_SCSI_QUADRA:
 		scsi_loc = io_base + 0x10000;
 		break;

 	default:
 		printk("mac_esp: get_base: hit default!\n");
 		scsi_loc = io_base + 0x10000;
 		break;

 	} /* switch */

 	printk("mac_esp: io base at 0x%lx\n", scsi_loc);

 	return scsi_loc;
 }

 /*
  * Model dependent ESP setup
  */

 int mac_esp_detect(struct scsi_host_template * tpnt)
 {
 	int quick = 0;
 	int chipnum, chipspresent = 0;
 #if 0
 	unsigned long timeout;
 #endif

 	if (esp_initialized > 0)
 		return -ENODEV;

 	/* what do we have in this machine... */
 	if (MACHW_PRESENT(MAC_SCSI_96)) {
 		chipspresent ++;
 	}

 	if (MACHW_PRESENT(MAC_SCSI_96_2)) {
 		chipspresent ++;
 	}

 	/* number of ESPs present ? */
 	if (setup_num_esps >= 0) {
 	  if (chipspresent >= setup_num_esps)
 	    chipspresent = setup_num_esps;
 	  else
 	    printk("mac_esp_detect: num_hosts detected %d setup %d \n",
 		   chipspresent, setup_num_esps);
 	}

 	/* TODO: add disconnect / nosync flags */

 	/* setup variables */
 	tpnt->can_queue =
 	  (setup_can_queue > 0) ? setup_can_queue : 7;
 	tpnt->cmd_per_lun =
 	  (setup_cmd_per_lun > 0) ? setup_cmd_per_lun : 1;
 	tpnt->sg_tablesize =
 	  (setup_sg_tablesize >= 0) ? setup_sg_tablesize : SG_ALL;

 	if (setup_hostid >= 0)
 	  tpnt->this_id = setup_hostid;
 	else {
 	  /* use 7 as default */
 	  tpnt->this_id = 7;
 	}

 #ifdef SUPPORT_TAGS
 	if (setup_use_tagged_queuing < 0)
 		setup_use_tagged_queuing = DEFAULT_USE_TAGGED_QUEUING;
 #endif

 	for (chipnum = 0; chipnum < chipspresent; chipnum ++) {
 		struct NCR_ESP * esp;

 		esp = esp_allocate(tpnt, (void *) NULL);
 		esp->eregs = (struct ESP_regs *) get_base(chipnum);

 		esp->dma_irq_p = &esp_dafb_dma_irq_p;
 		if (chipnum == 0) {

 			if (macintosh_config->scsi_type == MAC_SCSI_QUADRA) {
 				/* most machines except those below :-) */
 				quick = 1;
 				esp->dma_irq_p = &esp_iosb_dma_irq_p;
 			} else if (macintosh_config->scsi_type == MAC_SCSI_QUADRA3) {
 				/* mostly av's */
 				quick = 0;
 			} else {
 				/* q950, 900, 700 */
 				quick = 1;
 				out_be32(0xf9800024, 0x1d1);
 				esp->dregs = (void *) 0xf9800024;
 			}

 		} else { /* chipnum */

 			quick = 1;
 			out_be32(0xf9800028, 0x1d1);
 			esp->dregs = (void *) 0xf9800028;

 		} /* chipnum == 0 */

 		/* use pio for command bytes; pio for message/data: TBI */
 		esp->do_pio_cmds = 1;

 		/* Set the command buffer */
 		esp->esp_command = (volatile unsigned char*) cmd_buffer;
 		esp->esp_command_dvma = (__u32) cmd_buffer;

 		/* various functions */
 		esp->dma_bytes_sent = &dma_bytes_sent;
 		esp->dma_can_transfer = &dma_can_transfer;
 		esp->dma_dump_state = &dma_dump_state;
 		esp->dma_init_read = NULL;
 		esp->dma_init_write = NULL;
 		esp->dma_ints_off = &dma_ints_off;
 		esp->dma_ints_on = &dma_ints_on;

 		esp->dma_ports_p = &dma_ports_p;


 		/* Optional functions */
 		esp->dma_barrier = NULL;
 		esp->dma_drain = NULL;
 		esp->dma_invalidate = NULL;
 		esp->dma_irq_entry = NULL;
 		esp->dma_irq_exit = NULL;
 		esp->dma_led_on = NULL;
 		esp->dma_led_off = NULL;
 		esp->dma_poll = NULL;
 		esp->dma_reset = NULL;

 		/* SCSI chip speed */
 		/* below esp->cfreq = 40000000; */


 		if (quick) {
 			/* 'quick' means there's handshake glue logic like in the 5380 case */
 			esp->dma_setup = &dma_setup_quick;
 		} else {
 			esp->dma_setup = &dma_setup;
 		}

 		if (chipnum == 0) {

 			esp->irq = IRQ_MAC_SCSI;

 			request_irq(IRQ_MAC_SCSI, esp_intr, 0, "Mac ESP SCSI", esp->ehost);
 #if 0	/* conflicts with IOP ADB */
 			request_irq(IRQ_MAC_SCSIDRQ, fake_drq, 0, "Mac ESP DRQ", esp->ehost);
 #endif

 			if (macintosh_config->scsi_type == MAC_SCSI_QUADRA) {
 				esp->cfreq = 16500000;
 			} else {
 				esp->cfreq = 25000000;
 			}


 		} else { /* chipnum == 1 */

 			esp->irq = IRQ_MAC_SCSIDRQ;
 #if 0	/* conflicts with IOP ADB */
 			request_irq(IRQ_MAC_SCSIDRQ, esp_intr, 0, "Mac ESP SCSI 2", esp->ehost);
 #endif

 			esp->cfreq = 25000000;

 		}

 		if (quick) {
 			printk("esp: using quick version\n");
 		}

 		printk("esp: addr at 0x%p\n", esp->eregs);

 		esp->scsi_id = 7;
 		esp->diff = 0;

 		esp_initialize(esp);

 	} /* for chipnum */

 	if (chipspresent)
 		printk("\nmac_esp: %d esp controllers found\n", chipspresent);

 	esp_initialized = chipspresent;

 	return chipspresent;
 }

 static int mac_esp_release(struct Scsi_Host *shost)
 {
 	if (shost->irq)
 		free_irq(shost->irq, NULL);
 	if (shost->io_port && shost->n_io_port)
 		release_region(shost->io_port, shost->n_io_port);
 	scsi_unregister(shost);
 	return 0;
 }

 /*
  * I've been wondering what this is supposed to do, for some time. Talking
  * to Allen Briggs: These machines have an extra register someplace where the
  * DRQ pin of the ESP can be monitored. That isn't useful for determining
  * anything else (such as reselect interrupt or other magic) though.
  * Maybe make the semantics should be changed like
  * if (esp->current_SC)
  *	... check DRQ flag ...
  * else
  *	... disconnected, check pending VIA interrupt ...
  *
  * There's a problem with using the dabf flag or mac_irq_pending() here: both
  * seem to return 1 even though no interrupt is currently pending, resulting
  * in esp_exec_cmd() holding off the next command, and possibly infinite loops
  * in esp_intr().
  * Short term fix: just use esp_status & ESP_STAT_INTR here, as long as we
  * use simple PIO. The DRQ status will be important when implementing pseudo
  * DMA mode (set up ESP transfer count, return, do a batch of bytes in PIO or
  * 'hardware handshake' mode upon DRQ).
  * If you plan on changing this (i.e. to save the esp_status register access in
  * favor of a VIA register access or a shadow register for the IFR), make sure
  * to try a debug version of this first to monitor what registers would be a good
  * indicator of the ESP interrupt.
  */

 static int esp_dafb_dma_irq_p(struct NCR_ESP * esp)
 {
 	unsigned int ret;
 	int sreg = esp_read(esp->eregs->esp_status);

 #ifdef DEBUG_MAC_ESP
 	printk("mac_esp: esp_dafb_dma_irq_p dafb %d irq %d\n",
 		readl(esp->dregs), mac_irq_pending(IRQ_MAC_SCSI));
 #endif

 	sreg &= ESP_STAT_INTR;

 	/*
 	 * maybe working; this is essentially what's used for iosb_dma_irq_p
 	 */
 	if (sreg)
 		return 1;
 	else
 		return 0;

 	/*
 	 * didn't work ...
 	 */
 #if 0
 	if (esp->current_SC)
 		ret = readl(esp->dregs) & 0x200;
 	else if (esp->disconnected_SC)
 		ret = 1; /* sreg ?? */
 	else
 		ret = mac_irq_pending(IRQ_MAC_SCSI);

 	return(ret);
 #endif

 }

 /*
  * See above: testing mac_irq_pending always returned 8 (SCSI IRQ) regardless
  * of the actual ESP status.
  */

 static int esp_iosb_dma_irq_p(struct NCR_ESP * esp)
 {
 	int ret  = mac_irq_pending(IRQ_MAC_SCSI) || mac_irq_pending(IRQ_MAC_SCSIDRQ);
 	int sreg = esp_read(esp->eregs->esp_status);

 #ifdef DEBUG_MAC_ESP
 	printk("mac_esp: dma_irq_p drq %d irq %d sreg %x curr %p disc %p\n",
 		mac_irq_pending(IRQ_MAC_SCSIDRQ), mac_irq_pending(IRQ_MAC_SCSI),
 		sreg, esp->current_SC, esp->disconnected_SC);
 #endif

 	sreg &= ESP_STAT_INTR;

 	if (sreg)
 		return (sreg);
 	else
 		return 0;
 }

 /*
  * This seems to be OK for PIO at least ... usually 0 after PIO.
  */

 static int dma_bytes_sent(struct NCR_ESP * esp, int fifo_count)
 {

 #ifdef DEBUG_MAC_ESP
 	printk("mac_esp: dma bytes sent = %x\n", fifo_count);
 #endif

 	return fifo_count;
 }

 /*
  * dma_can_transfer is used to switch between DMA and PIO, if DMA (pseudo)
  * is ever implemented. Returning 0 here will use PIO.
  */

 static int dma_can_transfer(struct NCR_ESP * esp, Scsi_Cmnd * sp)
 {
 	unsigned long sz = sp->SCp.this_residual;
 #if 0	/* no DMA yet; make conditional */
 	if (sz > 0x10000000) {
 		sz = 0x10000000;
 	}
 	printk("mac_esp: dma can transfer = 0lx%x\n", sz);
 #else

 #ifdef DEBUG_MAC_ESP
 	printk("mac_esp: pio to transfer = %ld\n", sz);
 #endif

 	sz = 0;
 #endif
 	return sz;
 }

 /*
  * Not yet ...
  */

 static void dma_dump_state(struct NCR_ESP * esp)
 {
 #ifdef DEBUG_MAC_ESP
 	printk("mac_esp: dma_dump_state: called\n");
 #endif
 #if 0
 	ESPLOG(("esp%d: dma -- cond_reg<%02x>\n",
 		esp->esp_id, ((struct mac_dma_registers *)
 		(esp->dregs))->cond_reg));
 #endif
 }

 /*
  * DMA setup: should be used to set up the ESP transfer count for pseudo
  * DMA transfers; need a DRQ transfer function to do the actual transfer
  */

 static void dma_init_read(struct NCR_ESP * esp, char * vaddress, int length)
 {
 	printk("mac_esp: dma_init_read\n");
 }


 static void dma_init_write(struct NCR_ESP * esp, char * vaddress, int length)
 {
 	printk("mac_esp: dma_init_write\n");
 }


 static void dma_ints_off(struct NCR_ESP * esp)
 {
 	disable_irq(esp->irq);
 }


 static void dma_ints_on(struct NCR_ESP * esp)
 {
 	enable_irq(esp->irq);
 }

 /*
  * generic dma_irq_p(), unused
  */

 static int dma_irq_p(struct NCR_ESP * esp)
 {
 	int i = esp_read(esp->eregs->esp_status);

 #ifdef DEBUG_MAC_ESP
 	printk("mac_esp: dma_irq_p status %d\n", i);
 #endif

 	return (i & ESP_STAT_INTR);
 }

 static int dma_irq_p_quick(struct NCR_ESP * esp)
 {
 	/*
 	 * Copied from iosb_dma_irq_p()
 	 */
 	int ret  = mac_irq_pending(IRQ_MAC_SCSI) || mac_irq_pending(IRQ_MAC_SCSIDRQ);
 	int sreg = esp_read(esp->eregs->esp_status);

 #ifdef DEBUG_MAC_ESP
 	printk("mac_esp: dma_irq_p drq %d irq %d sreg %x curr %p disc %p\n",
 		mac_irq_pending(IRQ_MAC_SCSIDRQ), mac_irq_pending(IRQ_MAC_SCSI),
 		sreg, esp->current_SC, esp->disconnected_SC);
 #endif

 	sreg &= ESP_STAT_INTR;

 	if (sreg)
 		return (sreg);
 	else
 		return 0;

 }

 static void dma_led_off(struct NCR_ESP * esp)
 {
 #ifdef DEBUG_MAC_ESP
 	printk("mac_esp: dma_led_off: called\n");
 #endif
 }


 static void dma_led_on(struct NCR_ESP * esp)
 {
 #ifdef DEBUG_MAC_ESP
 	printk("mac_esp: dma_led_on: called\n");
 #endif
 }


 static int dma_ports_p(struct NCR_ESP * esp)
 {
 	return 0;
 }


 static void dma_setup(struct NCR_ESP * esp, __u32 addr, int count, int write)
 {

 #ifdef DEBUG_MAC_ESP
 	printk("mac_esp: dma_setup\n");
 #endif

 	if (write) {
 		dma_init_read(esp, (char *) addr, count);
 	} else {
 		dma_init_write(esp, (char *) addr, count);
 	}
 }


 static void dma_setup_quick(struct NCR_ESP * esp, __u32 addr, int count, int write)
 {
 #ifdef DEBUG_MAC_ESP
 	printk("mac_esp: dma_setup_quick\n");
 #endif
 }

 static struct scsi_host_template driver_template = {
 	.proc_name		= "mac_esp",
 	.name			= "Mac 53C9x SCSI",
 	.detect			= mac_esp_detect,
 	.slave_alloc		= esp_slave_alloc,
 	.slave_destroy		= esp_slave_destroy,
 	.release		= mac_esp_release,
 	.info			= esp_info,
 	.queuecommand		= esp_queue,
 	.eh_abort_handler	= esp_abort,
 	.eh_bus_reset_handler	= esp_reset,
 	.can_queue		= 7,
 	.this_id		= 7,
 	.sg_tablesize		= SG_ALL,
 	.cmd_per_lun		= 1,
 	.use_clustering		= DISABLE_CLUSTERING
 };


 #include "scsi_module.c"

 MODULE_LICENSE("GPL");
	/*
	* 68k mac 53c9[46] scsi driver
	*
	* copyright (c) 1998, David Weis weisd3458@uni.edu
	*
	* debugging on Quadra 800 and 660AV Michael Schmitz, Dave Kilzer 7/98
	*
	* based loosely on cyber_esp.c
	*/

	/* these are unused for now */
	#define myreadl(addr) ((volatile unsigned int ) (addr))
	#define mywritel(b, addr) (((volatile unsigned int ) (addr)) = (b))


	#include <linux/kernel.h>
	#include <linux/delay.h>
	#include <linux/types.h>
	#include <linux/ctype.h>
	#include <linux/string.h>
	#include <linux/slab.h>
	#include <linux/blkdev.h>
	#include <linux/proc_fs.h>
	#include <linux/stat.h>
	#include <linux/init.h>
	#include <linux/interrupt.h>

	#include "scsi.h"
	#include <scsi/scsi_host.h>
	#include "NCR53C9x.h"

	#include <asm/io.h>

	#include <asm/setup.h>
	#include <asm/irq.h>
	#include <asm/macints.h>
	#include <asm/machw.h>
	#include <asm/mac_via.h>

	#include <asm/pgtable.h>

	#include <asm/macintosh.h>

	/* #define DEBUG_MAC_ESP */

	extern void esp_handle(struct NCR_ESP *esp);
	extern void mac_esp_intr(int irq, void *dev_id);

	static int dma_bytes_sent(struct NCR_ESP * esp, int fifo_count);
	static int dma_can_transfer(struct NCR_ESP * esp, Scsi_Cmnd *sp);
	static void dma_dump_state(struct NCR_ESP * esp);
	static void dma_init_read(struct NCR_ESP * esp, char * vaddress, int length);
	static void dma_init_write(struct NCR_ESP * esp, char * vaddress, int length);
	static void dma_ints_off(struct NCR_ESP * esp);
	static void dma_ints_on(struct NCR_ESP * esp);
	static int dma_irq_p(struct NCR_ESP * esp);
	static int dma_irq_p_quick(struct NCR_ESP * esp);
	static void dma_led_off(struct NCR_ESP * esp);
	static void dma_led_on(struct NCR_ESP *esp);
	static int dma_ports_p(struct NCR_ESP *esp);
	static void dma_setup(struct NCR_ESP * esp, __u32 addr, int count, int write);
	static void dma_setup_quick(struct NCR_ESP * esp, __u32 addr, int count, int write);

	static int esp_dafb_dma_irq_p(struct NCR_ESP * espdev);
	static int esp_iosb_dma_irq_p(struct NCR_ESP * espdev);

	static volatile unsigned char cmd_buffer[16];
	/* This is where all commands are put
	* before they are transferred to the ESP chip
	* via PIO.
	*/

	static int esp_initialized = 0;

	static int setup_num_esps = -1;
	static int setup_disconnect = -1;
	static int setup_nosync = -1;
	static int setup_can_queue = -1;
	static int setup_cmd_per_lun = -1;
	static int setup_sg_tablesize = -1;
	#ifdef SUPPORT_TAGS
	static int setup_use_tagged_queuing = -1;
	#endif
	static int setup_hostid = -1;

	/*
	* Experimental ESP inthandler; check macints.c to make sure dev_id is
	* set up properly!
	*/

	void mac_esp_intr(int irq, void *dev_id)
	{
	struct NCR_ESP esp = (struct NCR_ESP ) dev_id;
	int irq_p = 0;

	/* Handle the one ESP interrupt showing at this IRQ level. */
	if(((esp)->irq & 0xff) == irq) {
	/*
	* Debug ..
	*/
	irq_p = esp->dma_irq_p(esp);
	printk("mac_esp: irq_p %x current %p disconnected %p\n",
	irq_p, esp->current_SC, esp->disconnected_SC);

	/*
	* Mac: if we're here, it's an ESP interrupt for sure!
	*/
	if((esp->current_SC \|\| esp->disconnected_SC)) {
	esp->dma_ints_off(esp);

	ESPIRQ(("I%d(", esp->esp_id));
	esp_handle(esp);
	ESPIRQ((")"));

	esp->dma_ints_on(esp);
	}
	}
	}

	/*
	* Debug hooks; use for playing with the interrupt flag testing and interrupt
	* acknowledge on the various machines
	*/

	void scsi_esp_polled(int irq, void *dev_id)
	{
	if (esp_initialized == 0)
	return;

	mac_esp_intr(irq, dev_id);
	}

	void fake_intr(int irq, void *dev_id)
	{
	#ifdef DEBUG_MAC_ESP
	printk("mac_esp: got irq\n");
	#endif

	mac_esp_intr(irq, dev_id);
	}

	irqreturn_t fake_drq(int irq, void *dev_id)
	{
	printk("mac_esp: got drq\n");
	return IRQ_HANDLED;
	}

	#define DRIVER_SETUP

	/*
	* Function : mac_esp_setup(char *str)
	*
	* Purpose : booter command line initialization of the overrides array,
	*
	* Inputs : str - parameters, separated by commas.
	*
	* Currently unused in the new driver; need to add settable parameters to the
	* detect function.
	*
	*/

	static int __init mac_esp_setup(char *str) {
	#ifdef DRIVER_SETUP
	/* Format of mac53c9x parameter is:
	* mac53c9x=<num_esps>,<disconnect>,<nosync>,<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
	* Negative values mean don't change.
	*/

	char *this_opt;
	long opt;

	this_opt = strsep (&str, ",");
	if(this_opt) {
	opt = simple_strtol( this_opt, NULL, 0 );

	if (opt >= 0 && opt <= 2)
	setup_num_esps = opt;
	else if (opt > 2)
	printk( "mac_esp_setup: invalid number of hosts %ld !\n", opt );

	this_opt = strsep (&str, ",");
	}
	if(this_opt) {
	opt = simple_strtol( this_opt, NULL, 0 );

	if (opt > 0)
	setup_disconnect = opt;

	this_opt = strsep (&str, ",");
	}
	if(this_opt) {
	opt = simple_strtol( this_opt, NULL, 0 );

	if (opt >= 0)
	setup_nosync = opt;

	this_opt = strsep (&str, ",");
	}
	if(this_opt) {
	opt = simple_strtol( this_opt, NULL, 0 );

	if (opt > 0)
	setup_can_queue = opt;

	this_opt = strsep (&str, ",");
	}
	if(this_opt) {
	opt = simple_strtol( this_opt, NULL, 0 );

	if (opt > 0)
	setup_cmd_per_lun = opt;

	this_opt = strsep (&str, ",");
	}
	if(this_opt) {
	opt = simple_strtol( this_opt, NULL, 0 );

	if (opt >= 0) {
	setup_sg_tablesize = opt;
	/* Must be <= SG_ALL (255) */
	if (setup_sg_tablesize > SG_ALL)
	setup_sg_tablesize = SG_ALL;
	}

	this_opt = strsep (&str, ",");
	}
	if(this_opt) {
	opt = simple_strtol( this_opt, NULL, 0 );

	/* Must be between 0 and 7 */
	if (opt >= 0 && opt <= 7)
	setup_hostid = opt;
	else if (opt > 7)
	printk( "mac_esp_setup: invalid host ID %ld !\n", opt);

	this_opt = strsep (&str, ",");
	}
	#ifdef SUPPORT_TAGS
	if(this_opt) {
	opt = simple_strtol( this_opt, NULL, 0 );
	if (opt >= 0)
	setup_use_tagged_queuing = !!opt;
	}
	#endif
	#endif
	return 1;
	}

	__setup("mac53c9x=", mac_esp_setup);


	/*
	* ESP address 'detection'
	*/

	unsigned long get_base(int chip_num)
	{
	/*
	* using the chip_num and mac model, figure out where the
	* chips are mapped
	*/

	unsigned long io_base = 0x50f00000;
	unsigned int second_offset = 0x402;
	unsigned long scsi_loc = 0;

	switch (macintosh_config->scsi_type) {

	/* 950, 900, 700 */
	case MAC_SCSI_QUADRA2:
	scsi_loc = io_base + 0xf000 + ((chip_num == 0) ? 0 : second_offset);
	break;

	/* av's */
	case MAC_SCSI_QUADRA3:
	scsi_loc = io_base + 0x18000 + ((chip_num == 0) ? 0 : second_offset);
	break;

	/* most quadra/centris models are like this */
	case MAC_SCSI_QUADRA:
	scsi_loc = io_base + 0x10000;
	break;

	default:
	printk("mac_esp: get_base: hit default!\n");
	scsi_loc = io_base + 0x10000;
	break;

	} /* switch */

	printk("mac_esp: io base at 0x%lx\n", scsi_loc);

	return scsi_loc;
	}

	/*
	* Model dependent ESP setup
	*/

	int mac_esp_detect(struct scsi_host_template * tpnt)
	{
	int quick = 0;
	int chipnum, chipspresent = 0;
	#if 0
	unsigned long timeout;
	#endif

	if (esp_initialized > 0)
	return -ENODEV;

	/* what do we have in this machine... */
	if (MACHW_PRESENT(MAC_SCSI_96)) {
	chipspresent ++;
	}

	if (MACHW_PRESENT(MAC_SCSI_96_2)) {
	chipspresent ++;
	}

	/* number of ESPs present ? */
	if (setup_num_esps >= 0) {
	if (chipspresent >= setup_num_esps)
	chipspresent = setup_num_esps;
	else
	printk("mac_esp_detect: num_hosts detected %d setup %d \n",
	chipspresent, setup_num_esps);
	}

	/* TODO: add disconnect / nosync flags */

	/* setup variables */
	tpnt->can_queue =
	(setup_can_queue > 0) ? setup_can_queue : 7;
	tpnt->cmd_per_lun =
	(setup_cmd_per_lun > 0) ? setup_cmd_per_lun : 1;
	tpnt->sg_tablesize =
	(setup_sg_tablesize >= 0) ? setup_sg_tablesize : SG_ALL;

	if (setup_hostid >= 0)
	tpnt->this_id = setup_hostid;
	else {
	/* use 7 as default */
	tpnt->this_id = 7;
	}

	#ifdef SUPPORT_TAGS
	if (setup_use_tagged_queuing < 0)
	setup_use_tagged_queuing = DEFAULT_USE_TAGGED_QUEUING;
	#endif

	for (chipnum = 0; chipnum < chipspresent; chipnum ++) {
	struct NCR_ESP * esp;

	esp = esp_allocate(tpnt, (void *) NULL);
	esp->eregs = (struct ESP_regs *) get_base(chipnum);

	esp->dma_irq_p = &esp_dafb_dma_irq_p;
	if (chipnum == 0) {

	if (macintosh_config->scsi_type == MAC_SCSI_QUADRA) {
	/* most machines except those below :-) */
	quick = 1;
	esp->dma_irq_p = &esp_iosb_dma_irq_p;
	} else if (macintosh_config->scsi_type == MAC_SCSI_QUADRA3) {
	/* mostly av's */
	quick = 0;
	} else {
	/* q950, 900, 700 */
	quick = 1;
	out_be32(0xf9800024, 0x1d1);
	esp->dregs = (void *) 0xf9800024;
	}

	} else { /* chipnum */

	quick = 1;
	out_be32(0xf9800028, 0x1d1);
	esp->dregs = (void *) 0xf9800028;

	} /* chipnum == 0 */

	/* use pio for command bytes; pio for message/data: TBI */
	esp->do_pio_cmds = 1;

	/* Set the command buffer */
	esp->esp_command = (volatile unsigned char*) cmd_buffer;
	esp->esp_command_dvma = (__u32) cmd_buffer;

	/* various functions */
	esp->dma_bytes_sent = &dma_bytes_sent;
	esp->dma_can_transfer = &dma_can_transfer;
	esp->dma_dump_state = &dma_dump_state;
	esp->dma_init_read = NULL;
	esp->dma_init_write = NULL;
	esp->dma_ints_off = &dma_ints_off;
	esp->dma_ints_on = &dma_ints_on;

	esp->dma_ports_p = &dma_ports_p;


	/* Optional functions */
	esp->dma_barrier = NULL;
	esp->dma_drain = NULL;
	esp->dma_invalidate = NULL;
	esp->dma_irq_entry = NULL;
	esp->dma_irq_exit = NULL;
	esp->dma_led_on = NULL;
	esp->dma_led_off = NULL;
	esp->dma_poll = NULL;
	esp->dma_reset = NULL;

	/* SCSI chip speed */
	/* below esp->cfreq = 40000000; */


	if (quick) {
	/* 'quick' means there's handshake glue logic like in the 5380 case */
	esp->dma_setup = &dma_setup_quick;
	} else {
	esp->dma_setup = &dma_setup;
	}

	if (chipnum == 0) {

	esp->irq = IRQ_MAC_SCSI;

	request_irq(IRQ_MAC_SCSI, esp_intr, 0, "Mac ESP SCSI", esp->ehost);
	#if 0 /* conflicts with IOP ADB */
	request_irq(IRQ_MAC_SCSIDRQ, fake_drq, 0, "Mac ESP DRQ", esp->ehost);
	#endif

	if (macintosh_config->scsi_type == MAC_SCSI_QUADRA) {
	esp->cfreq = 16500000;
	} else {
	esp->cfreq = 25000000;
	}


	} else { /* chipnum == 1 */

	esp->irq = IRQ_MAC_SCSIDRQ;
	#if 0 /* conflicts with IOP ADB */
	request_irq(IRQ_MAC_SCSIDRQ, esp_intr, 0, "Mac ESP SCSI 2", esp->ehost);
	#endif

	esp->cfreq = 25000000;

	}

	if (quick) {
	printk("esp: using quick version\n");
	}

	printk("esp: addr at 0x%p\n", esp->eregs);

	esp->scsi_id = 7;
	esp->diff = 0;

	esp_initialize(esp);

	} /* for chipnum */

	if (chipspresent)
	printk("\nmac_esp: %d esp controllers found\n", chipspresent);

	esp_initialized = chipspresent;

	return chipspresent;
	}

	static int mac_esp_release(struct Scsi_Host *shost)
	{
	if (shost->irq)
	free_irq(shost->irq, NULL);
	if (shost->io_port && shost->n_io_port)
	release_region(shost->io_port, shost->n_io_port);
	scsi_unregister(shost);
	return 0;
	}

	/*
	* I've been wondering what this is supposed to do, for some time. Talking
	* to Allen Briggs: These machines have an extra register someplace where the
	* DRQ pin of the ESP can be monitored. That isn't useful for determining
	* anything else (such as reselect interrupt or other magic) though.
	* Maybe make the semantics should be changed like
	* if (esp->current_SC)
	* ... check DRQ flag ...
	* else
	* ... disconnected, check pending VIA interrupt ...
	*
	* There's a problem with using the dabf flag or mac_irq_pending() here: both
	* seem to return 1 even though no interrupt is currently pending, resulting
	* in esp_exec_cmd() holding off the next command, and possibly infinite loops
	* in esp_intr().
	* Short term fix: just use esp_status & ESP_STAT_INTR here, as long as we
	* use simple PIO. The DRQ status will be important when implementing pseudo
	* DMA mode (set up ESP transfer count, return, do a batch of bytes in PIO or
	* 'hardware handshake' mode upon DRQ).
	* If you plan on changing this (i.e. to save the esp_status register access in
	* favor of a VIA register access or a shadow register for the IFR), make sure
	* to try a debug version of this first to monitor what registers would be a good
	* indicator of the ESP interrupt.
	*/

	static int esp_dafb_dma_irq_p(struct NCR_ESP * esp)
	{
	unsigned int ret;
	int sreg = esp_read(esp->eregs->esp_status);

	#ifdef DEBUG_MAC_ESP
	printk("mac_esp: esp_dafb_dma_irq_p dafb %d irq %d\n",
	readl(esp->dregs), mac_irq_pending(IRQ_MAC_SCSI));
	#endif

	sreg &= ESP_STAT_INTR;

	/*
	* maybe working; this is essentially what's used for iosb_dma_irq_p
	*/
	if (sreg)
	return 1;
	else
	return 0;

	/*
	* didn't work ...
	*/
	#if 0
	if (esp->current_SC)
	ret = readl(esp->dregs) & 0x200;
	else if (esp->disconnected_SC)
	ret = 1; /* sreg ?? */
	else
	ret = mac_irq_pending(IRQ_MAC_SCSI);

	return(ret);
	#endif

	}

	/*
	* See above: testing mac_irq_pending always returned 8 (SCSI IRQ) regardless
	* of the actual ESP status.
	*/

	static int esp_iosb_dma_irq_p(struct NCR_ESP * esp)
	{
	int ret = mac_irq_pending(IRQ_MAC_SCSI) \|\| mac_irq_pending(IRQ_MAC_SCSIDRQ);
	int sreg = esp_read(esp->eregs->esp_status);

	#ifdef DEBUG_MAC_ESP
	printk("mac_esp: dma_irq_p drq %d irq %d sreg %x curr %p disc %p\n",
	mac_irq_pending(IRQ_MAC_SCSIDRQ), mac_irq_pending(IRQ_MAC_SCSI),
	sreg, esp->current_SC, esp->disconnected_SC);
	#endif

	sreg &= ESP_STAT_INTR;

	if (sreg)
	return (sreg);
	else
	return 0;
	}

	/*
	* This seems to be OK for PIO at least ... usually 0 after PIO.
	*/

	static int dma_bytes_sent(struct NCR_ESP * esp, int fifo_count)
	{

	#ifdef DEBUG_MAC_ESP
	printk("mac_esp: dma bytes sent = %x\n", fifo_count);
	#endif

	return fifo_count;
	}

	/*
	* dma_can_transfer is used to switch between DMA and PIO, if DMA (pseudo)
	* is ever implemented. Returning 0 here will use PIO.
	*/

	static int dma_can_transfer(struct NCR_ESP * esp, Scsi_Cmnd * sp)
	{
	unsigned long sz = sp->SCp.this_residual;
	#if 0 /* no DMA yet; make conditional */
	if (sz > 0x10000000) {
	sz = 0x10000000;
	}
	printk("mac_esp: dma can transfer = 0lx%x\n", sz);
	#else

	#ifdef DEBUG_MAC_ESP
	printk("mac_esp: pio to transfer = %ld\n", sz);
	#endif

	sz = 0;
	#endif
	return sz;
	}

	/*
	* Not yet ...
	*/

	static void dma_dump_state(struct NCR_ESP * esp)
	{
	#ifdef DEBUG_MAC_ESP
	printk("mac_esp: dma_dump_state: called\n");
	#endif
	#if 0
	ESPLOG(("esp%d: dma -- cond_reg<%02x>\n",
	esp->esp_id, ((struct mac_dma_registers *)
	(esp->dregs))->cond_reg));
	#endif
	}

	/*
	* DMA setup: should be used to set up the ESP transfer count for pseudo
	* DMA transfers; need a DRQ transfer function to do the actual transfer
	*/

	static void dma_init_read(struct NCR_ESP * esp, char * vaddress, int length)
	{
	printk("mac_esp: dma_init_read\n");
	}


	static void dma_init_write(struct NCR_ESP * esp, char * vaddress, int length)
	{
	printk("mac_esp: dma_init_write\n");
	}


	static void dma_ints_off(struct NCR_ESP * esp)
	{
	disable_irq(esp->irq);
	}


	static void dma_ints_on(struct NCR_ESP * esp)
	{
	enable_irq(esp->irq);
	}

	/*
	* generic dma_irq_p(), unused
	*/

	static int dma_irq_p(struct NCR_ESP * esp)
	{
	int i = esp_read(esp->eregs->esp_status);

	#ifdef DEBUG_MAC_ESP
	printk("mac_esp: dma_irq_p status %d\n", i);
	#endif

	return (i & ESP_STAT_INTR);
	}

	static int dma_irq_p_quick(struct NCR_ESP * esp)
	{
	/*
	* Copied from iosb_dma_irq_p()
	*/
	int ret = mac_irq_pending(IRQ_MAC_SCSI) \|\| mac_irq_pending(IRQ_MAC_SCSIDRQ);
	int sreg = esp_read(esp->eregs->esp_status);

	#ifdef DEBUG_MAC_ESP
	printk("mac_esp: dma_irq_p drq %d irq %d sreg %x curr %p disc %p\n",
	mac_irq_pending(IRQ_MAC_SCSIDRQ), mac_irq_pending(IRQ_MAC_SCSI),
	sreg, esp->current_SC, esp->disconnected_SC);
	#endif

	sreg &= ESP_STAT_INTR;

	if (sreg)
	return (sreg);
	else
	return 0;

	}

	static void dma_led_off(struct NCR_ESP * esp)
	{
	#ifdef DEBUG_MAC_ESP
	printk("mac_esp: dma_led_off: called\n");
	#endif
	}


	static void dma_led_on(struct NCR_ESP * esp)
	{
	#ifdef DEBUG_MAC_ESP
	printk("mac_esp: dma_led_on: called\n");
	#endif
	}


	static int dma_ports_p(struct NCR_ESP * esp)
	{
	return 0;
	}


	static void dma_setup(struct NCR_ESP * esp, __u32 addr, int count, int write)
	{

	#ifdef DEBUG_MAC_ESP
	printk("mac_esp: dma_setup\n");
	#endif

	if (write) {
	dma_init_read(esp, (char *) addr, count);
	} else {
	dma_init_write(esp, (char *) addr, count);
	}
	}


	static void dma_setup_quick(struct NCR_ESP * esp, __u32 addr, int count, int write)
	{
	#ifdef DEBUG_MAC_ESP
	printk("mac_esp: dma_setup_quick\n");
	#endif
	}

	static struct scsi_host_template driver_template = {
	.proc_name = "mac_esp",
	.name = "Mac 53C9x SCSI",
	.detect = mac_esp_detect,
	.slave_alloc = esp_slave_alloc,
	.slave_destroy = esp_slave_destroy,
	.release = mac_esp_release,
	.info = esp_info,
	.queuecommand = esp_queue,
	.eh_abort_handler = esp_abort,
	.eh_bus_reset_handler = esp_reset,
	.can_queue = 7,
	.this_id = 7,
	.sg_tablesize = SG_ALL,
	.cmd_per_lun = 1,
	.use_clustering = DISABLE_CLUSTERING
	};


	#include "scsi_module.c"

	MODULE_LICENSE("GPL");