From 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Sat, 16 Apr 2005 15:20:36 -0700 Subject: Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip! --- drivers/scsi/mac_esp.c | 754 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 754 insertions(+) create mode 100644 drivers/scsi/mac_esp.c (limited to 'drivers/scsi/mac_esp.c') diff --git a/drivers/scsi/mac_esp.c b/drivers/scsi/mac_esp.c new file mode 100644 index 00000000000..c94c8db8465 --- /dev/null +++ b/drivers/scsi/mac_esp.c @@ -0,0 +1,754 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "scsi.h" +#include +#include "NCR53C9x.h" + +#include + +#include +#include +#include +#include +#include + +#include + +#include + +/* #define DEBUG_MAC_ESP */ + +#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); +} + +irqreturn_t fake_drq(int irq, void *dev_id, struct pt_regs *pregs) +{ + 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=,,,,,,, + * 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->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) +{ + 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 = { + .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"); -- cgit v1.2.3