drivers/scsi/a2091.c

   1 #include <linux/types.h>
   2 #include <linux/mm.h>
   3 #include <linux/blk.h>
   4 #include <linux/sched.h>
   5 #include <linux/version.h>
   6 #include <linux/init.h>
   7
   8 #include <asm/setup.h>
   9 #include <asm/page.h>
  10 #include <asm/pgtable.h>
  11 #include <asm/amigaints.h>
  12 #include <asm/amigahw.h>
  13 #include <linux/zorro.h>
  14 #include <asm/irq.h>
  15 #include <linux/spinlock.h>
  16
  17 #include "scsi.h"
  18 #include "hosts.h"
  19 #include "wd33c93.h"
  20 #include "a2091.h"
  21
  22 #include<linux/stat.h>
  23
  24 struct proc_dir_entry proc_scsi_a2091 = {
  25     PROC_SCSI_A2091, 5, "A2091",
  26     S_IFDIR | S_IRUGO | S_IXUGO, 2
  27 };
  28
  29 #define DMA(ptr) ((a2091_scsiregs *)((ptr)->base))
  30 #define HDATA(ptr) ((struct WD33C93_hostdata *)((ptr)->hostdata))
  31
  32 static struct Scsi_Host *first_instance = NULL;
  33 static Scsi_Host_Template *a2091_template;
  34
  35 static void a2091_intr (int irq, void *dummy, struct pt_regs *fp)
  36 {
  37     unsigned long flags;
  38     unsigned int status;
  39     struct Scsi_Host *instance;
  40     for (instance = first_instance; instance &&
  41          instance->hostt == a2091_template; instance = instance->next)
  42     {
  43         status = DMA(instance)->ISTR;
  44         if (!(status & (ISTR_INT_F|ISTR_INT_P)))
  45                 continue;
  46
  47         if (status & ISTR_INTS) {
  48                 spin_lock_irqsave(&io_request_lock, flags);
  49                 wd33c93_intr (instance);
  50                 spin_unlock_irqrestore(&io_request_lock, flags);
  51         }
  52     }
  53 }
  54
  55 static int dma_setup (Scsi_Cmnd *cmd, int dir_in)
  56 {
  57     unsigned short cntr = CNTR_PDMD | CNTR_INTEN;
  58     unsigned long addr = virt_to_bus(cmd->SCp.ptr);
  59     struct Scsi_Host *instance = cmd->host;
  60
  61     /* don't allow DMA if the physical address is bad */
  62     if (addr & A2091_XFER_MASK ||
  63         (!dir_in && mm_end_of_chunk (addr, cmd->SCp.this_residual)))
  64     {
  65         HDATA(instance)->dma_bounce_len = (cmd->SCp.this_residual + 511)
  66             & ~0x1ff;
  67         HDATA(instance)->dma_bounce_buffer =
  68             scsi_malloc (HDATA(instance)->dma_bounce_len);
  69
  70         /* can't allocate memory; use PIO */
  71         if (!HDATA(instance)->dma_bounce_buffer) {
  72             HDATA(instance)->dma_bounce_len = 0;
  73             return 1;
  74         }
  75
  76         /* get the physical address of the bounce buffer */
  77         addr = virt_to_bus(HDATA(instance)->dma_bounce_buffer);
  78
  79         /* the bounce buffer may not be in the first 16M of physmem */
  80         if (addr & A2091_XFER_MASK) {
  81             /* we could use chipmem... maybe later */
  82             scsi_free (HDATA(instance)->dma_bounce_buffer,
  83                        HDATA(instance)->dma_bounce_len);
  84             HDATA(instance)->dma_bounce_buffer = NULL;
  85             HDATA(instance)->dma_bounce_len = 0;
  86             return 1;
  87         }
  88
  89         if (!dir_in) {
  90             /* copy to bounce buffer for a write */
  91             if (cmd->use_sg)
  92 #if 0
  93                 panic ("scsi%ddma: incomplete s/g support",
  94                        instance->host_no);
  95 #else
  96                 memcpy (HDATA(instance)->dma_bounce_buffer,
  97                         cmd->SCp.ptr, cmd->SCp.this_residual);
  98 #endif
  99             else
 100                 memcpy (HDATA(instance)->dma_bounce_buffer,
 101                         cmd->request_buffer, cmd->request_bufflen);
 102         }
 103     }
 104
 105     /* setup dma direction */
 106     if (!dir_in)
 107         cntr |= CNTR_DDIR;
 108
 109     /* remember direction */
 110     HDATA(cmd->host)->dma_dir = dir_in;
 111
 112     DMA(cmd->host)->CNTR = cntr;
 113
 114     /* setup DMA *physical* address */
 115     DMA(cmd->host)->ACR = addr;
 116
 117     if (dir_in){
 118         /* invalidate any cache */
 119         cache_clear (addr, cmd->SCp.this_residual);
 120     }else{
 121         /* push any dirty cache */
 122         cache_push (addr, cmd->SCp.this_residual);
 123       }
 124     /* start DMA */
 125     DMA(cmd->host)->ST_DMA = 1;
 126
 127     /* return success */
 128     return 0;
 129 }
 130
 131 static void dma_stop (struct Scsi_Host *instance, Scsi_Cmnd *SCpnt,
 132                       int status)
 133 {
 134     /* disable SCSI interrupts */
 135     unsigned short cntr = CNTR_PDMD;
 136
 137     if (!HDATA(instance)->dma_dir)
 138             cntr |= CNTR_DDIR;
 139
 140     /* disable SCSI interrupts */
 141     DMA(instance)->CNTR = cntr;
 142
 143     /* flush if we were reading */
 144     if (HDATA(instance)->dma_dir) {
 145         DMA(instance)->FLUSH = 1;
 146         while (!(DMA(instance)->ISTR & ISTR_FE_FLG))
 147             ;
 148     }
 149
 150     /* clear a possible interrupt */
 151     DMA(instance)->CINT = 1;
 152
 153     /* stop DMA */
 154     DMA(instance)->SP_DMA = 1;
 155
 156     /* restore the CONTROL bits (minus the direction flag) */
 157     DMA(instance)->CNTR = CNTR_PDMD | CNTR_INTEN;
 158
 159     /* copy from a bounce buffer, if necessary */
 160     if (status && HDATA(instance)->dma_bounce_buffer) {
 161         if (SCpnt && SCpnt->use_sg) {
 162 #if 0
 163             panic ("scsi%d: incomplete s/g support",
 164                    instance->host_no);
 165 #else
 166             if( HDATA(instance)->dma_dir )
 167                 memcpy (SCpnt->SCp.ptr,
 168                         HDATA(instance)->dma_bounce_buffer,
 169                         SCpnt->SCp.this_residual);
 170             scsi_free (HDATA(instance)->dma_bounce_buffer,
 171                        HDATA(instance)->dma_bounce_len);
 172             HDATA(instance)->dma_bounce_buffer = NULL;
 173             HDATA(instance)->dma_bounce_len = 0;
 174
 175 #endif
 176         } else {
 177             if (HDATA(instance)->dma_dir && SCpnt)
 178                 memcpy (SCpnt->request_buffer,
 179                         HDATA(instance)->dma_bounce_buffer,
 180                         SCpnt->request_bufflen);
 181
 182             scsi_free (HDATA(instance)->dma_bounce_buffer,
 183                        HDATA(instance)->dma_bounce_len);
 184             HDATA(instance)->dma_bounce_buffer = NULL;
 185             HDATA(instance)->dma_bounce_len = 0;
 186         }
 187     }
 188 }
 189
 190 static int num_a2091 = 0;
 191
 192 int __init a2091_detect(Scsi_Host_Template *tpnt)
 193 {
 194     static unsigned char called = 0;
 195     struct Scsi_Host *instance;
 196     caddr_t address;
 197     unsigned int key;
 198     const struct ConfigDev *cd;
 199
 200     if (!MACH_IS_AMIGA || called)
 201         return 0;
 202     called = 1;
 203
 204     tpnt->proc_dir = &proc_scsi_a2091;
 205     tpnt->proc_info = &wd33c93_proc_info;
 206
 207     while ((key = zorro_find(ZORRO_PROD_CBM_A590_A2091_1, 0, 0)) ||
 208            (key = zorro_find(ZORRO_PROD_CBM_A590_A2091_2, 0, 0))) {
 209         cd = zorro_get_board(key);
 210         address = cd->cd_BoardAddr;
 211         instance = scsi_register (tpnt, sizeof (struct WD33C93_hostdata));
 212         instance->base = (unsigned char *)ZTWO_VADDR(address);
 213         instance->irq = IRQ_AMIGA_PORTS;
 214         instance->unique_id = key;
 215         DMA(instance)->DAWR = DAWR_A2091;
 216         wd33c93_init(instance, (wd33c93_regs *)&(DMA(instance)->SASR),
 217                      dma_setup, dma_stop, WD33C93_FS_8_10);
 218         if (num_a2091++ == 0) {
 219             first_instance = instance;
 220             a2091_template = instance->hostt;
 221             request_irq(IRQ_AMIGA_PORTS, a2091_intr, SA_SHORQ, "A2091 SCSI",
 222                         a2091_intr);
 223         }
 224         DMA(instance)->CNTR = CNTR_PDMD | CNTR_INTEN;
 225         zorro_config_board(key, 0);
 226     }
 227
 228     return num_a2091;
 229 }
 230
 231 #ifdef MODULE
 232
 233 #define HOSTS_C
 234
 235 #include "a2091.h"
 236
 237 Scsi_Host_Template driver_template = A2091_SCSI;
 238
 239 #include "scsi_module.c"
 240
 241 #endif
 242
 243 int a2091_release(struct Scsi_Host *instance)
 244 {
 245 #ifdef MODULE
 246         DMA(instance)->CNTR = 0;
 247         zorro_unconfig_board(instance->unique_id, 0);
 248         if (--num_a2091 == 0)
 249                 free_irq(IRQ_AMIGA_PORTS, a2091_intr);
 250         wd33c93_release();
 251 #endif
 252         return 1;
 253 }