URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [scsi/] [mac_esp.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 * 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/blk.h>
#include <linux/proc_fs.h>
#include <linux/stat.h>
#include <linux/init.h>
 
#include "scsi.h"
#include "hosts.h"
#include "NCR53C9x.h"
#include "mac_esp.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 mac_turnon_irq(x)       mac_enable_irq(x)
#define mac_turnoff_irq(x)      mac_disable_irq(x)
 
extern void esp_handle(struct NCR_ESP *esp);
extern void mac_esp_intr(int irq, void *dev_id, struct pt_regs *pregs);
 
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 pt_regs *pregs)
{
        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, struct pt_regs *pregs)
{
        if (esp_initialized == 0)
                return;
 
        mac_esp_intr(irq, dev_id, pregs);
}
 
void fake_intr(int irq, void *dev_id, struct pt_regs *pregs)
{
#ifdef DEBUG_MAC_ESP
        printk("mac_esp: got irq\n");
#endif
 
        mac_esp_intr(irq, dev_id, pregs);
}
 
void fake_drq(int irq, void *dev_id, struct pt_regs *pregs)
{
        printk("mac_esp: got drq\n");
}
 
#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(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);
#if 0   /* conflicts with IOP ADB */
                        request_irq(IRQ_MAC_SCSIDRQ, fake_drq, 0, "Mac ESP DRQ", esp);
#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);
#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;
}
 
/*
 * 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)
{
        mac_turnoff_irq(esp->irq);
}
 
 
static void dma_ints_on(struct NCR_ESP * esp)
{
        mac_turnon_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 Scsi_Host_Template driver_template = SCSI_MAC_ESP;
 
#include "scsi_module.c"
 
MODULE_LICENSE("GPL");

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [scsi/] [mac_esp.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* 68k mac 53c9[46] scsi driver`
3			`*`
4			`* copyright (c) 1998, David Weis weisd3458@uni.edu`
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/blk.h>`
23			`#include <linux/proc_fs.h>`
24			`#include <linux/stat.h>`
25			`#include <linux/init.h>`
26
27			`#include "scsi.h"`
28			`#include "hosts.h"`
29			`#include "NCR53C9x.h"`
30			`#include "mac_esp.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 mac_turnon_irq(x) mac_enable_irq(x)`
45			`#define mac_turnoff_irq(x) mac_disable_irq(x)`
46
47			`extern void esp_handle(struct NCR_ESP *esp);`
48			`extern void mac_esp_intr(int irq, void dev_id, struct pt_regs pregs);`
49
50			`static int dma_bytes_sent(struct NCR_ESP * esp, int fifo_count);`
51			`static int dma_can_transfer(struct NCR_ESP * esp, Scsi_Cmnd *sp);`
52			`static void dma_dump_state(struct NCR_ESP * esp);`
53			`static void dma_init_read(struct NCR_ESP * esp, char * vaddress, int length);`
54			`static void dma_init_write(struct NCR_ESP * esp, char * vaddress, int length);`
55			`static void dma_ints_off(struct NCR_ESP * esp);`
56			`static void dma_ints_on(struct NCR_ESP * esp);`
57			`static int dma_irq_p(struct NCR_ESP * esp);`
58			`static int dma_irq_p_quick(struct NCR_ESP * esp);`
59			`static void dma_led_off(struct NCR_ESP * esp);`
60			`static void dma_led_on(struct NCR_ESP *esp);`
61			`static int dma_ports_p(struct NCR_ESP *esp);`
62			`static void dma_setup(struct NCR_ESP * esp, __u32 addr, int count, int write);`
63			`static void dma_setup_quick(struct NCR_ESP * esp, __u32 addr, int count, int write);`
64
65			`static int esp_dafb_dma_irq_p(struct NCR_ESP * espdev);`
66			`static int esp_iosb_dma_irq_p(struct NCR_ESP * espdev);`
67
68			`static volatile unsigned char cmd_buffer[16];`
69			`/* This is where all commands are put`
70			`* before they are transferred to the ESP chip`
71			`* via PIO.`
72			`*/`
73
74			`static int esp_initialized = 0;`
75
76			`static int setup_num_esps = -1;`
77			`static int setup_disconnect = -1;`
78			`static int setup_nosync = -1;`
79			`static int setup_can_queue = -1;`
80			`static int setup_cmd_per_lun = -1;`
81			`static int setup_sg_tablesize = -1;`
82			`#ifdef SUPPORT_TAGS`
83			`static int setup_use_tagged_queuing = -1;`
84			`#endif`
85			`static int setup_hostid = -1;`
86
87			`/*`
88			`* Experimental ESP inthandler; check macints.c to make sure dev_id is`
89			`* set up properly!`
90			`*/`
91
92			`void mac_esp_intr(int irq, void dev_id, struct pt_regs pregs)`
93			`{`
94			`struct NCR_ESP esp = (struct NCR_ESP ) dev_id;`
95			`int irq_p = 0;`
96
97			`/* Handle the one ESP interrupt showing at this IRQ level. */`
98			`if(((esp)->irq & 0xff) == irq) {`
99			`/*`
100			`* Debug ..`
101			`*/`
102			`irq_p = esp->dma_irq_p(esp);`
103			`printk("mac_esp: irq_p %x current %p disconnected %p\n",`
104			`irq_p, esp->current_SC, esp->disconnected_SC);`
105
106			`/*`
107			`* Mac: if we're here, it's an ESP interrupt for sure!`
108			`*/`
109			`if((esp->current_SC \|\| esp->disconnected_SC)) {`
110			`esp->dma_ints_off(esp);`
111
112			`ESPIRQ(("I%d(", esp->esp_id));`
113			`esp_handle(esp);`
114			`ESPIRQ((")"));`
115
116			`esp->dma_ints_on(esp);`
117			`}`
118			`}`
119			`}`
120
121			`/*`
122			`* Debug hooks; use for playing with the interrupt flag testing and interrupt`
123			`* acknowledge on the various machines`
124			`*/`
125
126			`void scsi_esp_polled(int irq, void dev_id, struct pt_regs pregs)`
127			`{`
128			`if (esp_initialized == 0)`
129			`return;`
130
131			`mac_esp_intr(irq, dev_id, pregs);`
132			`}`
133
134			`void fake_intr(int irq, void dev_id, struct pt_regs pregs)`
135			`{`
136			`#ifdef DEBUG_MAC_ESP`
137			`printk("mac_esp: got irq\n");`
138			`#endif`
139
140			`mac_esp_intr(irq, dev_id, pregs);`
141			`}`
142
143			`void fake_drq(int irq, void dev_id, struct pt_regs pregs)`
144			`{`
145			`printk("mac_esp: got drq\n");`
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
300			`int mac_esp_detect(Scsi_Host_Template * tpnt)`
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
354			`esp = esp_allocate(tpnt, (void *) NULL);`
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);`
428			`#if 0 /* conflicts with IOP ADB */`
429			`request_irq(IRQ_MAC_SCSIDRQ, fake_drq, 0, "Mac ESP DRQ", esp);`
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);`
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			`/*`
472			`* I've been wondering what this is supposed to do, for some time. Talking`
473			`* to Allen Briggs: These machines have an extra register someplace where the`
474			`* DRQ pin of the ESP can be monitored. That isn't useful for determining`
475			`* anything else (such as reselect interrupt or other magic) though.`
476			`* Maybe make the semantics should be changed like`
477			`* if (esp->current_SC)`
478			`* ... check DRQ flag ...`
479			`* else`
480			`* ... disconnected, check pending VIA interrupt ...`
481			`*`
482			`* There's a problem with using the dabf flag or mac_irq_pending() here: both`
483			`* seem to return 1 even though no interrupt is currently pending, resulting`
484			`* in esp_exec_cmd() holding off the next command, and possibly infinite loops`
485			`* in esp_intr().`
486			`* Short term fix: just use esp_status & ESP_STAT_INTR here, as long as we`
487			`* use simple PIO. The DRQ status will be important when implementing pseudo`
488			`* DMA mode (set up ESP transfer count, return, do a batch of bytes in PIO or`
489			`* 'hardware handshake' mode upon DRQ).`
490			`* If you plan on changing this (i.e. to save the esp_status register access in`
491			`* favor of a VIA register access or a shadow register for the IFR), make sure`
492			`* to try a debug version of this first to monitor what registers would be a good`
493			`* indicator of the ESP interrupt.`
494			`*/`
495
496			`static int esp_dafb_dma_irq_p(struct NCR_ESP * esp)`
497			`{`
498			`unsigned int ret;`
499			`int sreg = esp_read(esp->eregs->esp_status);`
500
501			`#ifdef DEBUG_MAC_ESP`
502			`printk("mac_esp: esp_dafb_dma_irq_p dafb %d irq %d\n",`
503			`readl(esp->dregs), mac_irq_pending(IRQ_MAC_SCSI));`
504			`#endif`
505
506			`sreg &= ESP_STAT_INTR;`
507
508			`/*`
509			`* maybe working; this is essentially what's used for iosb_dma_irq_p`
510			`*/`
511			`if (sreg)`
512			`return 1;`
513			`else`
514			`return 0;`
515
516			`/*`
517			`* didn't work ...`
518			`*/`
519			`#if 0`
520			`if (esp->current_SC)`
521			`ret = readl(esp->dregs) & 0x200;`
522			`else if (esp->disconnected_SC)`
523			`ret = 1; /* sreg ?? */`
524			`else`
525			`ret = mac_irq_pending(IRQ_MAC_SCSI);`
526
527			`return(ret);`
528			`#endif`
529
530			`}`
531
532			`/*`
533			`* See above: testing mac_irq_pending always returned 8 (SCSI IRQ) regardless`
534			`* of the actual ESP status.`
535			`*/`
536
537			`static int esp_iosb_dma_irq_p(struct NCR_ESP * esp)`
538			`{`
539			`int ret = mac_irq_pending(IRQ_MAC_SCSI) \|\| mac_irq_pending(IRQ_MAC_SCSIDRQ);`
540			`int sreg = esp_read(esp->eregs->esp_status);`
541
542			`#ifdef DEBUG_MAC_ESP`
543			`printk("mac_esp: dma_irq_p drq %d irq %d sreg %x curr %p disc %p\n",`
544			`mac_irq_pending(IRQ_MAC_SCSIDRQ), mac_irq_pending(IRQ_MAC_SCSI),`
545			`sreg, esp->current_SC, esp->disconnected_SC);`
546			`#endif`
547
548			`sreg &= ESP_STAT_INTR;`
549
550			`if (sreg)`
551			`return (sreg);`
552			`else`
553			`return 0;`
554			`}`
555
556			`/*`
557			`* This seems to be OK for PIO at least ... usually 0 after PIO.`
558			`*/`
559
560			`static int dma_bytes_sent(struct NCR_ESP * esp, int fifo_count)`
561			`{`
562
563			`#ifdef DEBUG_MAC_ESP`
564			`printk("mac_esp: dma bytes sent = %x\n", fifo_count);`
565			`#endif`
566
567			`return fifo_count;`
568			`}`
569
570			`/*`
571			`* dma_can_transfer is used to switch between DMA and PIO, if DMA (pseudo)`
572			`* is ever implemented. Returning 0 here will use PIO.`
573			`*/`
574
575			`static int dma_can_transfer(struct NCR_ESP * esp, Scsi_Cmnd * sp)`
576			`{`
577			`unsigned long sz = sp->SCp.this_residual;`
578			`#if 0 /* no DMA yet; make conditional */`
579			`if (sz > 0x10000000) {`
580			`sz = 0x10000000;`
581			`}`
582			`printk("mac_esp: dma can transfer = 0lx%x\n", sz);`
583			`#else`
584
585			`#ifdef DEBUG_MAC_ESP`
586			`printk("mac_esp: pio to transfer = %ld\n", sz);`
587			`#endif`
588
589			`sz = 0;`
590			`#endif`
591			`return sz;`
592			`}`
593
594			`/*`
595			`* Not yet ...`
596			`*/`
597
598			`static void dma_dump_state(struct NCR_ESP * esp)`
599			`{`
600			`#ifdef DEBUG_MAC_ESP`
601			`printk("mac_esp: dma_dump_state: called\n");`
602			`#endif`
603			`#if 0`
604			`ESPLOG(("esp%d: dma -- cond_reg<%02x>\n",`
605			`esp->esp_id, ((struct mac_dma_registers *)`
606			`(esp->dregs))->cond_reg));`
607			`#endif`
608			`}`
609
610			`/*`
611			`* DMA setup: should be used to set up the ESP transfer count for pseudo`
612			`* DMA transfers; need a DRQ transfer function to do the actual transfer`
613			`*/`
614
615			`static void dma_init_read(struct NCR_ESP * esp, char * vaddress, int length)`
616			`{`
617			`printk("mac_esp: dma_init_read\n");`
618			`}`
619
620
621			`static void dma_init_write(struct NCR_ESP * esp, char * vaddress, int length)`
622			`{`
623			`printk("mac_esp: dma_init_write\n");`
624			`}`
625
626
627			`static void dma_ints_off(struct NCR_ESP * esp)`
628			`{`
629			`mac_turnoff_irq(esp->irq);`
630			`}`
631
632
633			`static void dma_ints_on(struct NCR_ESP * esp)`
634			`{`
635			`mac_turnon_irq(esp->irq);`
636			`}`
637
638			`/*`
639			`* generic dma_irq_p(), unused`
640			`*/`
641
642			`static int dma_irq_p(struct NCR_ESP * esp)`
643			`{`
644			`int i = esp_read(esp->eregs->esp_status);`
645
646			`#ifdef DEBUG_MAC_ESP`
647			`printk("mac_esp: dma_irq_p status %d\n", i);`
648			`#endif`
649
650			`return (i & ESP_STAT_INTR);`
651			`}`
652
653			`static int dma_irq_p_quick(struct NCR_ESP * esp)`
654			`{`
655			`/*`
656			`* Copied from iosb_dma_irq_p()`
657			`*/`
658			`int ret = mac_irq_pending(IRQ_MAC_SCSI) \|\| mac_irq_pending(IRQ_MAC_SCSIDRQ);`
659			`int sreg = esp_read(esp->eregs->esp_status);`
660
661			`#ifdef DEBUG_MAC_ESP`
662			`printk("mac_esp: dma_irq_p drq %d irq %d sreg %x curr %p disc %p\n",`
663			`mac_irq_pending(IRQ_MAC_SCSIDRQ), mac_irq_pending(IRQ_MAC_SCSI),`
664			`sreg, esp->current_SC, esp->disconnected_SC);`
665			`#endif`
666
667			`sreg &= ESP_STAT_INTR;`
668
669			`if (sreg)`
670			`return (sreg);`
671			`else`
672			`return 0;`
673
674			`}`
675
676			`static void dma_led_off(struct NCR_ESP * esp)`
677			`{`
678			`#ifdef DEBUG_MAC_ESP`
679			`printk("mac_esp: dma_led_off: called\n");`
680			`#endif`
681			`}`
682
683
684			`static void dma_led_on(struct NCR_ESP * esp)`
685			`{`
686			`#ifdef DEBUG_MAC_ESP`
687			`printk("mac_esp: dma_led_on: called\n");`
688			`#endif`
689			`}`
690
691
692			`static int dma_ports_p(struct NCR_ESP * esp)`
693			`{`
694			`return 0;`
695			`}`
696
697
698			`static void dma_setup(struct NCR_ESP * esp, __u32 addr, int count, int write)`
699			`{`
700
701			`#ifdef DEBUG_MAC_ESP`
702			`printk("mac_esp: dma_setup\n");`
703			`#endif`
704
705			`if (write) {`
706			`dma_init_read(esp, (char *) addr, count);`
707			`} else {`
708			`dma_init_write(esp, (char *) addr, count);`
709			`}`
710			`}`
711
712
713			`static void dma_setup_quick(struct NCR_ESP * esp, __u32 addr, int count, int write)`
714			`{`
715			`#ifdef DEBUG_MAC_ESP`
716			`printk("mac_esp: dma_setup_quick\n");`
717			`#endif`
718			`}`
719
720			`static Scsi_Host_Template driver_template = SCSI_MAC_ESP;`
721
722			`#include "scsi_module.c"`
723
724			`MODULE_LICENSE("GPL");`