[linux.git] / drivers / scsi / mac_esp.c

/*
 * 68k mac 53c9[46] scsi driver
 *
 * copyright (c) 1998, David Weis [email protected]
 *
 * 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, NULL, 0);
		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");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* 68k mac 53c9[46] scsi driver
	3	*
	4	* copyright (c) 1998, David Weis [email protected]
	5	*
	6	* debugging on Quadra 800 and 660AV Michael Schmitz, Dave Kilzer 7/98
	7	*
	8	* based loosely on cyber_esp.c
	9	*/
	10
	11	/* these are unused for now */
	12	#define myreadl(addr) ((volatile unsigned int ) (addr))
	13	#define mywritel(b, addr) (((volatile unsigned int ) (addr)) = (b))
	14
	15
	16	#include <linux/kernel.h>
	17	#include <linux/delay.h>
	18	#include <linux/types.h>
	19	#include <linux/ctype.h>
	20	#include <linux/string.h>
	21	#include <linux/slab.h>
	22	#include <linux/blkdev.h>
	23	#include <linux/proc_fs.h>
	24	#include <linux/stat.h>
	25	#include <linux/init.h>
	26	#include <linux/interrupt.h>
	27
	28	#include "scsi.h"
	29	#include <scsi/scsi_host.h>
	30	#include "NCR53C9x.h"
	31
	32	#include <asm/io.h>
	33
	34	#include <asm/setup.h>
	35	#include <asm/irq.h>
	36	#include <asm/macints.h>
	37	#include <asm/machw.h>
	38	#include <asm/mac_via.h>
	39
	40	#include <asm/pgtable.h>
	41
	42	#include <asm/macintosh.h>
	43
	44	/* #define DEBUG_MAC_ESP */
	45
1da177e4	46	extern void esp_handle(struct NCR_ESP *esp);
7d12e780	47	extern void mac_esp_intr(int irq, void *dev_id);
1da177e4 LT	48
	49	static int dma_bytes_sent(struct NCR_ESP * esp, int fifo_count);
	50	static int dma_can_transfer(struct NCR_ESP * esp, Scsi_Cmnd *sp);
	51	static void dma_dump_state(struct NCR_ESP * esp);
	52	static void dma_init_read(struct NCR_ESP * esp, char * vaddress, int length);
	53	static void dma_init_write(struct NCR_ESP * esp, char * vaddress, int length);
	54	static void dma_ints_off(struct NCR_ESP * esp);
	55	static void dma_ints_on(struct NCR_ESP * esp);
	56	static int dma_irq_p(struct NCR_ESP * esp);
	57	static int dma_irq_p_quick(struct NCR_ESP * esp);
	58	static void dma_led_off(struct NCR_ESP * esp);
	59	static void dma_led_on(struct NCR_ESP *esp);
	60	static int dma_ports_p(struct NCR_ESP *esp);
	61	static void dma_setup(struct NCR_ESP * esp, __u32 addr, int count, int write);
	62	static void dma_setup_quick(struct NCR_ESP * esp, __u32 addr, int count, int write);
	63
	64	static int esp_dafb_dma_irq_p(struct NCR_ESP * espdev);
	65	static int esp_iosb_dma_irq_p(struct NCR_ESP * espdev);
	66
	67	static volatile unsigned char cmd_buffer[16];
	68	/* This is where all commands are put
	69	* before they are transferred to the ESP chip
	70	* via PIO.
	71	*/
	72
	73	static int esp_initialized = 0;
	74
	75	static int setup_num_esps = -1;
	76	static int setup_disconnect = -1;
	77	static int setup_nosync = -1;
	78	static int setup_can_queue = -1;
	79	static int setup_cmd_per_lun = -1;
	80	static int setup_sg_tablesize = -1;
	81	#ifdef SUPPORT_TAGS
	82	static int setup_use_tagged_queuing = -1;
	83	#endif
	84	static int setup_hostid = -1;
	85
	86	/*
	87	* Experimental ESP inthandler; check macints.c to make sure dev_id is
	88	* set up properly!
	89	*/
	90
7d12e780	91	void mac_esp_intr(int irq, void *dev_id)
1da177e4 LT	92	{
	93	struct NCR_ESP esp = (struct NCR_ESP ) dev_id;
	94	int irq_p = 0;
	95
	96	/* Handle the one ESP interrupt showing at this IRQ level. */
	97	if(((esp)->irq & 0xff) == irq) {
	98	/*
	99	* Debug ..
	100	*/
	101	irq_p = esp->dma_irq_p(esp);
	102	printk("mac_esp: irq_p %x current %p disconnected %p\n",
	103	irq_p, esp->current_SC, esp->disconnected_SC);
	104
	105	/*
	106	* Mac: if we're here, it's an ESP interrupt for sure!
	107	*/
	108	if((esp->current_SC \|\| esp->disconnected_SC)) {
	109	esp->dma_ints_off(esp);
	110
	111	ESPIRQ(("I%d(", esp->esp_id));
	112	esp_handle(esp);
	113	ESPIRQ((")"));
	114
	115	esp->dma_ints_on(esp);
	116	}
	117	}
	118	}
	119
	120	/*
	121	* Debug hooks; use for playing with the interrupt flag testing and interrupt
	122	* acknowledge on the various machines
	123	*/
	124
7d12e780	125	void scsi_esp_polled(int irq, void *dev_id)
1da177e4 LT	126	{
	127	if (esp_initialized == 0)
	128	return;
	129
7d12e780	130	mac_esp_intr(irq, dev_id);
1da177e4 LT	131	}
1da177e4 LT	132
7d12e780	133	void fake_intr(int irq, void *dev_id)
1da177e4 LT	134	{
	135	#ifdef DEBUG_MAC_ESP
	136	printk("mac_esp: got irq\n");
	137	#endif
	138
7d12e780	139	mac_esp_intr(irq, dev_id);
1da177e4 LT	140	}
1da177e4 LT	141
7d12e780	142	irqreturn_t fake_drq(int irq, void *dev_id)
1da177e4 LT	143	{
	144	printk("mac_esp: got drq\n");
	145	return IRQ_HANDLED;
	146	}
	147
	148	#define DRIVER_SETUP
	149
	150	/*
	151	* Function : mac_esp_setup(char *str)
	152	*
	153	* Purpose : booter command line initialization of the overrides array,
	154	*
	155	* Inputs : str - parameters, separated by commas.
	156	*
	157	* Currently unused in the new driver; need to add settable parameters to the
	158	* detect function.
	159	*
	160	*/
	161
	162	static int __init mac_esp_setup(char *str) {
	163	#ifdef DRIVER_SETUP
	164	/* Format of mac53c9x parameter is:
	165	* mac53c9x=<num_esps>,<disconnect>,<nosync>,<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
	166	* Negative values mean don't change.
	167	*/
	168
	169	char *this_opt;
	170	long opt;
	171
	172	this_opt = strsep (&str, ",");
	173	if(this_opt) {
	174	opt = simple_strtol( this_opt, NULL, 0 );
	175
	176	if (opt >= 0 && opt <= 2)
	177	setup_num_esps = opt;
	178	else if (opt > 2)
	179	printk( "mac_esp_setup: invalid number of hosts %ld !\n", opt );
	180
	181	this_opt = strsep (&str, ",");
	182	}
	183	if(this_opt) {
	184	opt = simple_strtol( this_opt, NULL, 0 );
	185
	186	if (opt > 0)
	187	setup_disconnect = opt;
	188
	189	this_opt = strsep (&str, ",");
	190	}
	191	if(this_opt) {
	192	opt = simple_strtol( this_opt, NULL, 0 );
	193
	194	if (opt >= 0)
	195	setup_nosync = opt;
	196
	197	this_opt = strsep (&str, ",");
	198	}
	199	if(this_opt) {
	200	opt = simple_strtol( this_opt, NULL, 0 );
	201
	202	if (opt > 0)
	203	setup_can_queue = opt;
	204
	205	this_opt = strsep (&str, ",");
	206	}
207	if(this_opt) {
208	opt = simple_strtol( this_opt, NULL, 0 );
209
210	if (opt > 0)
211	setup_cmd_per_lun = opt;
212
213	this_opt = strsep (&str, ",");
214	}
215	if(this_opt) {
216	opt = simple_strtol( this_opt, NULL, 0 );
217
218	if (opt >= 0) {
219	setup_sg_tablesize = opt;
220	/* Must be <= SG_ALL (255) */
221	if (setup_sg_tablesize > SG_ALL)
222	setup_sg_tablesize = SG_ALL;
223	}
224
225	this_opt = strsep (&str, ",");
226	}
227	if(this_opt) {
228	opt = simple_strtol( this_opt, NULL, 0 );
229
230	/* Must be between 0 and 7 */
231	if (opt >= 0 && opt <= 7)
232	setup_hostid = opt;
233	else if (opt > 7)
234	printk( "mac_esp_setup: invalid host ID %ld !\n", opt);
235
236	this_opt = strsep (&str, ",");
237	}
238	#ifdef SUPPORT_TAGS
239	if(this_opt) {
240	opt = simple_strtol( this_opt, NULL, 0 );
241	if (opt >= 0)
242	setup_use_tagged_queuing = !!opt;
243	}
244	#endif
245	#endif
246	return 1;
247	}
248
249	__setup("mac53c9x=", mac_esp_setup);
250
251
252	/*
253	* ESP address 'detection'
254	*/
255
256	unsigned long get_base(int chip_num)
257	{
258	/*
259	* using the chip_num and mac model, figure out where the
260	* chips are mapped
261	*/
262
263	unsigned long io_base = 0x50f00000;
264	unsigned int second_offset = 0x402;
265	unsigned long scsi_loc = 0;
266
267	switch (macintosh_config->scsi_type) {
268
269	/* 950, 900, 700 */
270	case MAC_SCSI_QUADRA2:
271	scsi_loc = io_base + 0xf000 + ((chip_num == 0) ? 0 : second_offset);
272	break;
273
274	/* av's */
275	case MAC_SCSI_QUADRA3:
276	scsi_loc = io_base + 0x18000 + ((chip_num == 0) ? 0 : second_offset);
277	break;
278
279	/* most quadra/centris models are like this */
280	case MAC_SCSI_QUADRA:
281	scsi_loc = io_base + 0x10000;
282	break;
283
284	default:
285	printk("mac_esp: get_base: hit default!\n");
286	scsi_loc = io_base + 0x10000;
287	break;
288
289	} /* switch */
290
291	printk("mac_esp: io base at 0x%lx\n", scsi_loc);
292
293	return scsi_loc;
294	}
295
296	/*
297	* Model dependent ESP setup
298	*/
299
d0be4a7d	300	int mac_esp_detect(struct scsi_host_template * tpnt)
1da177e4 LT	301	{
	302	int quick = 0;
	303	int chipnum, chipspresent = 0;
	304	#if 0
	305	unsigned long timeout;
	306	#endif
	307
	308	if (esp_initialized > 0)
	309	return -ENODEV;
	310
	311	/* what do we have in this machine... */
	312	if (MACHW_PRESENT(MAC_SCSI_96)) {
	313	chipspresent ++;
	314	}
	315
	316	if (MACHW_PRESENT(MAC_SCSI_96_2)) {
	317	chipspresent ++;
	318	}
	319
	320	/* number of ESPs present ? */
	321	if (setup_num_esps >= 0) {
	322	if (chipspresent >= setup_num_esps)
	323	chipspresent = setup_num_esps;
	324	else
	325	printk("mac_esp_detect: num_hosts detected %d setup %d \n",
	326	chipspresent, setup_num_esps);
	327	}
	328
	329	/* TODO: add disconnect / nosync flags */
	330
	331	/* setup variables */
	332	tpnt->can_queue =
	333	(setup_can_queue > 0) ? setup_can_queue : 7;
	334	tpnt->cmd_per_lun =
	335	(setup_cmd_per_lun > 0) ? setup_cmd_per_lun : 1;
	336	tpnt->sg_tablesize =
	337	(setup_sg_tablesize >= 0) ? setup_sg_tablesize : SG_ALL;
	338
	339	if (setup_hostid >= 0)
	340	tpnt->this_id = setup_hostid;
	341	else {
	342	/* use 7 as default */
	343	tpnt->this_id = 7;
	344	}
	345
	346	#ifdef SUPPORT_TAGS
	347	if (setup_use_tagged_queuing < 0)
	348	setup_use_tagged_queuing = DEFAULT_USE_TAGGED_QUEUING;
	349	#endif
	350
	351	for (chipnum = 0; chipnum < chipspresent; chipnum ++) {
	352	struct NCR_ESP * esp;
	353
4df4db5c	354	esp = esp_allocate(tpnt, NULL, 0);
1da177e4 LT	355	esp->eregs = (struct ESP_regs *) get_base(chipnum);
	356
	357	esp->dma_irq_p = &esp_dafb_dma_irq_p;
	358	if (chipnum == 0) {
	359
	360	if (macintosh_config->scsi_type == MAC_SCSI_QUADRA) {
	361	/* most machines except those below :-) */
	362	quick = 1;
	363	esp->dma_irq_p = &esp_iosb_dma_irq_p;
	364	} else if (macintosh_config->scsi_type == MAC_SCSI_QUADRA3) {
	365	/* mostly av's */
	366	quick = 0;
	367	} else {
	368	/* q950, 900, 700 */
	369	quick = 1;
	370	out_be32(0xf9800024, 0x1d1);
	371	esp->dregs = (void *) 0xf9800024;
	372	}
	373
	374	} else { /* chipnum */
	375
	376	quick = 1;
	377	out_be32(0xf9800028, 0x1d1);
	378	esp->dregs = (void *) 0xf9800028;
	379
	380	} /* chipnum == 0 */
	381
	382	/* use pio for command bytes; pio for message/data: TBI */
	383	esp->do_pio_cmds = 1;
	384
	385	/* Set the command buffer */
	386	esp->esp_command = (volatile unsigned char*) cmd_buffer;
	387	esp->esp_command_dvma = (__u32) cmd_buffer;
	388
	389	/* various functions */
	390	esp->dma_bytes_sent = &dma_bytes_sent;
	391	esp->dma_can_transfer = &dma_can_transfer;
	392	esp->dma_dump_state = &dma_dump_state;
	393	esp->dma_init_read = NULL;
	394	esp->dma_init_write = NULL;
	395	esp->dma_ints_off = &dma_ints_off;
	396	esp->dma_ints_on = &dma_ints_on;
	397
	398	esp->dma_ports_p = &dma_ports_p;
	399
	400
	401	/* Optional functions */
	402	esp->dma_barrier = NULL;
	403	esp->dma_drain = NULL;
	404	esp->dma_invalidate = NULL;
	405	esp->dma_irq_entry = NULL;
	406	esp->dma_irq_exit = NULL;
	407	esp->dma_led_on = NULL;
	408	esp->dma_led_off = NULL;
	409	esp->dma_poll = NULL;
	410	esp->dma_reset = NULL;
	411
	412	/* SCSI chip speed */
	413	/* below esp->cfreq = 40000000; */
	414
	415
	416	if (quick) {
	417	/* 'quick' means there's handshake glue logic like in the 5380 case */
	418	esp->dma_setup = &dma_setup_quick;
419	} else {
420	esp->dma_setup = &dma_setup;
421	}
422
423	if (chipnum == 0) {
424
425	esp->irq = IRQ_MAC_SCSI;
426
427	request_irq(IRQ_MAC_SCSI, esp_intr, 0, "Mac ESP SCSI", esp->ehost);
428	#if 0 /* conflicts with IOP ADB */
429	request_irq(IRQ_MAC_SCSIDRQ, fake_drq, 0, "Mac ESP DRQ", esp->ehost);
430	#endif
431
432	if (macintosh_config->scsi_type == MAC_SCSI_QUADRA) {
433	esp->cfreq = 16500000;
434	} else {
435	esp->cfreq = 25000000;
436	}
437
438
439	} else { /* chipnum == 1 */
440
441	esp->irq = IRQ_MAC_SCSIDRQ;
442	#if 0 /* conflicts with IOP ADB */
443	request_irq(IRQ_MAC_SCSIDRQ, esp_intr, 0, "Mac ESP SCSI 2", esp->ehost);
444	#endif
445
446	esp->cfreq = 25000000;
447
448	}
449
450	if (quick) {
451	printk("esp: using quick version\n");
452	}
453
454	printk("esp: addr at 0x%p\n", esp->eregs);
455
456	esp->scsi_id = 7;
457	esp->diff = 0;
458
459	esp_initialize(esp);
460
461	} /* for chipnum */
462
463	if (chipspresent)
464	printk("\nmac_esp: %d esp controllers found\n", chipspresent);
465
466	esp_initialized = chipspresent;
467
468	return chipspresent;
469	}
470
471	static int mac_esp_release(struct Scsi_Host *shost)
472	{
473	if (shost->irq)
474	free_irq(shost->irq, NULL);
475	if (shost->io_port && shost->n_io_port)
476	release_region(shost->io_port, shost->n_io_port);
477	scsi_unregister(shost);
478	return 0;
479	}
480
481	/*
482	* I've been wondering what this is supposed to do, for some time. Talking
483	* to Allen Briggs: These machines have an extra register someplace where the
484	* DRQ pin of the ESP can be monitored. That isn't useful for determining
485	* anything else (such as reselect interrupt or other magic) though.
486	* Maybe make the semantics should be changed like
487	* if (esp->current_SC)
488	* ... check DRQ flag ...
489	* else
490	* ... disconnected, check pending VIA interrupt ...
491	*
492	* There's a problem with using the dabf flag or mac_irq_pending() here: both
493	* seem to return 1 even though no interrupt is currently pending, resulting
494	* in esp_exec_cmd() holding off the next command, and possibly infinite loops
495	* in esp_intr().
496	* Short term fix: just use esp_status & ESP_STAT_INTR here, as long as we
497	* use simple PIO. The DRQ status will be important when implementing pseudo
498	* DMA mode (set up ESP transfer count, return, do a batch of bytes in PIO or
499	* 'hardware handshake' mode upon DRQ).
500	* If you plan on changing this (i.e. to save the esp_status register access in
501	* favor of a VIA register access or a shadow register for the IFR), make sure
502	* to try a debug version of this first to monitor what registers would be a good
503	* indicator of the ESP interrupt.
504	*/
505
506	static int esp_dafb_dma_irq_p(struct NCR_ESP * esp)
507	{
508	unsigned int ret;
509	int sreg = esp_read(esp->eregs->esp_status);
510
511	#ifdef DEBUG_MAC_ESP
512	printk("mac_esp: esp_dafb_dma_irq_p dafb %d irq %d\n",
513	readl(esp->dregs), mac_irq_pending(IRQ_MAC_SCSI));
514	#endif
515
516	sreg &= ESP_STAT_INTR;
517
518	/*
519	* maybe working; this is essentially what's used for iosb_dma_irq_p
520	*/
521	if (sreg)
522	return 1;
523	else
524	return 0;
525
526	/*
527	* didn't work ...
528	*/
529	#if 0
530	if (esp->current_SC)
531	ret = readl(esp->dregs) & 0x200;
532	else if (esp->disconnected_SC)
533	ret = 1; /* sreg ?? */
534	else
535	ret = mac_irq_pending(IRQ_MAC_SCSI);
536
537	return(ret);
538	#endif
539
540	}
541
542	/*
543	* See above: testing mac_irq_pending always returned 8 (SCSI IRQ) regardless
544	* of the actual ESP status.
545	*/
546
547	static int esp_iosb_dma_irq_p(struct NCR_ESP * esp)
548	{
549	int ret = mac_irq_pending(IRQ_MAC_SCSI) \|\| mac_irq_pending(IRQ_MAC_SCSIDRQ);
550	int sreg = esp_read(esp->eregs->esp_status);
551
552	#ifdef DEBUG_MAC_ESP
553	printk("mac_esp: dma_irq_p drq %d irq %d sreg %x curr %p disc %p\n",
554	mac_irq_pending(IRQ_MAC_SCSIDRQ), mac_irq_pending(IRQ_MAC_SCSI),
555	sreg, esp->current_SC, esp->disconnected_SC);
556	#endif
557
558	sreg &= ESP_STAT_INTR;
559
560	if (sreg)
561	return (sreg);
562	else
563	return 0;
564	}
565
566	/*
567	* This seems to be OK for PIO at least ... usually 0 after PIO.
568	*/
569
570	static int dma_bytes_sent(struct NCR_ESP * esp, int fifo_count)
571	{
572
573	#ifdef DEBUG_MAC_ESP
574	printk("mac_esp: dma bytes sent = %x\n", fifo_count);
575	#endif
576
577	return fifo_count;
578	}
579
580	/*
581	* dma_can_transfer is used to switch between DMA and PIO, if DMA (pseudo)
582	* is ever implemented. Returning 0 here will use PIO.
583	*/
584
585	static int dma_can_transfer(struct NCR_ESP * esp, Scsi_Cmnd * sp)
586	{
587	unsigned long sz = sp->SCp.this_residual;
588	#if 0 /* no DMA yet; make conditional */
589	if (sz > 0x10000000) {
590	sz = 0x10000000;
591	}
592	printk("mac_esp: dma can transfer = 0lx%x\n", sz);
593	#else
594
595	#ifdef DEBUG_MAC_ESP
596	printk("mac_esp: pio to transfer = %ld\n", sz);
597	#endif
598
599	sz = 0;
600	#endif
601	return sz;
602	}
603
604	/*
605	* Not yet ...
606	*/
607
608	static void dma_dump_state(struct NCR_ESP * esp)
609	{
610	#ifdef DEBUG_MAC_ESP
611	printk("mac_esp: dma_dump_state: called\n");
612	#endif
613	#if 0
614	ESPLOG(("esp%d: dma -- cond_reg<%02x>\n",
615	esp->esp_id, ((struct mac_dma_registers *)
616	(esp->dregs))->cond_reg));
617	#endif
618	}
619
620	/*
621	* DMA setup: should be used to set up the ESP transfer count for pseudo
622	* DMA transfers; need a DRQ transfer function to do the actual transfer
623	*/
624
625	static void dma_init_read(struct NCR_ESP * esp, char * vaddress, int length)
626	{
627	printk("mac_esp: dma_init_read\n");
628	}
629
630
631	static void dma_init_write(struct NCR_ESP * esp, char * vaddress, int length)
632	{
633	printk("mac_esp: dma_init_write\n");
634	}
635
636
637	static void dma_ints_off(struct NCR_ESP * esp)
638	{
9c5f4afd	639	disable_irq(esp->irq);
1da177e4 LT	640	}
	641
	642
	643	static void dma_ints_on(struct NCR_ESP * esp)
	644	{
9c5f4afd	645	enable_irq(esp->irq);
1da177e4 LT	646	}
	647
	648	/*
	649	* generic dma_irq_p(), unused
	650	*/
	651
	652	static int dma_irq_p(struct NCR_ESP * esp)
	653	{
	654	int i = esp_read(esp->eregs->esp_status);
	655
	656	#ifdef DEBUG_MAC_ESP
	657	printk("mac_esp: dma_irq_p status %d\n", i);
	658	#endif
	659
	660	return (i & ESP_STAT_INTR);
	661	}
	662
	663	static int dma_irq_p_quick(struct NCR_ESP * esp)
	664	{
	665	/*
	666	* Copied from iosb_dma_irq_p()
	667	*/
	668	int ret = mac_irq_pending(IRQ_MAC_SCSI) \|\| mac_irq_pending(IRQ_MAC_SCSIDRQ);
	669	int sreg = esp_read(esp->eregs->esp_status);
	670
	671	#ifdef DEBUG_MAC_ESP
	672	printk("mac_esp: dma_irq_p drq %d irq %d sreg %x curr %p disc %p\n",
	673	mac_irq_pending(IRQ_MAC_SCSIDRQ), mac_irq_pending(IRQ_MAC_SCSI),
	674	sreg, esp->current_SC, esp->disconnected_SC);
	675	#endif
	676
	677	sreg &= ESP_STAT_INTR;
	678
	679	if (sreg)
	680	return (sreg);
	681	else
	682	return 0;
	683
	684	}
	685
	686	static void dma_led_off(struct NCR_ESP * esp)
	687	{
	688	#ifdef DEBUG_MAC_ESP
	689	printk("mac_esp: dma_led_off: called\n");
	690	#endif
	691	}
	692
	693
	694	static void dma_led_on(struct NCR_ESP * esp)
	695	{
	696	#ifdef DEBUG_MAC_ESP
	697	printk("mac_esp: dma_led_on: called\n");
	698	#endif
	699	}
	700
	701
	702	static int dma_ports_p(struct NCR_ESP * esp)
	703	{
	704	return 0;
	705	}
	706
	707
	708	static void dma_setup(struct NCR_ESP * esp, __u32 addr, int count, int write)
	709	{
710
711	#ifdef DEBUG_MAC_ESP
712	printk("mac_esp: dma_setup\n");
713	#endif
714
715	if (write) {
716	dma_init_read(esp, (char *) addr, count);
717	} else {
718	dma_init_write(esp, (char *) addr, count);
719	}
720	}
721
722
723	static void dma_setup_quick(struct NCR_ESP * esp, __u32 addr, int count, int write)
724	{
725	#ifdef DEBUG_MAC_ESP
726	printk("mac_esp: dma_setup_quick\n");
727	#endif
728	}
729
d0be4a7d	730	static struct scsi_host_template driver_template = {
1da177e4 LT	731	.proc_name = "mac_esp",
	732	.name = "Mac 53C9x SCSI",
	733	.detect = mac_esp_detect,
	734	.slave_alloc = esp_slave_alloc,
	735	.slave_destroy = esp_slave_destroy,
	736	.release = mac_esp_release,
	737	.info = esp_info,
	738	.queuecommand = esp_queue,
	739	.eh_abort_handler = esp_abort,
	740	.eh_bus_reset_handler = esp_reset,
	741	.can_queue = 7,
	742	.this_id = 7,
	743	.sg_tablesize = SG_ALL,
	744	.cmd_per_lun = 1,
	745	.use_clustering = DISABLE_CLUSTERING
	746	};
	747
	748
	749	#include "scsi_module.c"
	750
	751	MODULE_LICENSE("GPL");