drivers/scsi/sun3x_esp.c

   1 /* sun3x_esp.c:  EnhancedScsiProcessor Sun3x SCSI driver code.
   2  *
   3  * (C) 1999 Thomas Bogendoerfer (tsbogend@alpha.franken.de)
   4  *
   5  * Based on David S. Miller's esp driver
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/delay.h>
  10 #include <linux/types.h>
  11 #include <linux/string.h>
  12 #include <linux/malloc.h>
  13 #include <linux/blk.h>
  14 #include <linux/proc_fs.h>
  15 #include <linux/stat.h>
  16
  17 #include "scsi.h"
  18 #include "hosts.h"
  19 #include "NCR53C9x.h"
  20
  21 #include "sun3x_esp.h"
  22 #include <asm/sun3x.h>
  23 #include <asm/dvma.h>
  24
  25 extern struct NCR_ESP *espchain;
  26
  27 static void dma_barrier(struct NCR_ESP *esp);
  28 static int  dma_bytes_sent(struct NCR_ESP *esp, int fifo_count);
  29 static int  dma_can_transfer(struct NCR_ESP *esp, Scsi_Cmnd *sp);
  30 static void dma_drain(struct NCR_ESP *esp);
  31 static void dma_dump_state(struct NCR_ESP *esp);
  32 static void dma_init_read(struct NCR_ESP *esp, __u32 vaddress, int length);
  33 static void dma_init_write(struct NCR_ESP *esp, __u32 vaddress, int length);
  34 static void dma_ints_off(struct NCR_ESP *esp);
  35 static void dma_ints_on(struct NCR_ESP *esp);
  36 static int  dma_irq_p(struct NCR_ESP *esp);
  37 static void dma_poll(struct NCR_ESP *esp, unsigned char *vaddr);
  38 static int  dma_ports_p(struct NCR_ESP *esp);
  39 static void dma_reset(struct NCR_ESP *esp);
  40 static void dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write);
  41 static void dma_mmu_get_scsi_one (struct NCR_ESP *esp, Scsi_Cmnd *sp);
  42 static void dma_mmu_get_scsi_sgl (struct NCR_ESP *esp, Scsi_Cmnd *sp);
  43 static void dma_mmu_release_scsi_one (struct NCR_ESP *esp, Scsi_Cmnd *sp);
  44 static void dma_mmu_release_scsi_sgl (struct NCR_ESP *esp, Scsi_Cmnd *sp);
  45 static void dma_advance_sg (Scsi_Cmnd *sp);
  46
  47 volatile unsigned char cmd_buffer[16];
  48                                 /* This is where all commands are put
  49                                  * before they are trasfered to the ESP chip
  50                                  * via PIO.
  51                                  */
  52
  53 /* Detecting ESP chips on the machine.  This is the simple and easy
  54  * version.
  55  */
  56 int sun3x_esp_detect(Scsi_Host_Template *tpnt)
  57 {
  58         struct NCR_ESP *esp;
  59         struct ConfigDev *esp_dev;
  60
  61         esp_dev = 0;
  62         esp = esp_allocate(tpnt, (void *) esp_dev);
  63
  64         /* Do command transfer with DMA */
  65         esp->do_pio_cmds = 0;
  66
  67         /* Required functions */
  68         esp->dma_bytes_sent = &dma_bytes_sent;
  69         esp->dma_can_transfer = &dma_can_transfer;
  70         esp->dma_dump_state = &dma_dump_state;
  71         esp->dma_init_read = &dma_init_read;
  72         esp->dma_init_write = &dma_init_write;
  73         esp->dma_ints_off = &dma_ints_off;
  74         esp->dma_ints_on = &dma_ints_on;
  75         esp->dma_irq_p = &dma_irq_p;
  76         esp->dma_ports_p = &dma_ports_p;
  77         esp->dma_setup = &dma_setup;
  78
  79         /* Optional functions */
  80         esp->dma_barrier = &dma_barrier;
  81         esp->dma_drain = &dma_drain;
  82         esp->dma_irq_entry = &dma_ints_off;
  83         esp->dma_irq_exit = &dma_ints_on;
  84         esp->dma_led_on = 0;
  85         esp->dma_led_off = 0;
  86         esp->dma_poll = &dma_poll;
  87         esp->dma_reset = &dma_reset;
  88
  89         /* virtual DMA functions */
  90         esp->dma_mmu_get_scsi_one = &dma_mmu_get_scsi_one;
  91         esp->dma_mmu_get_scsi_sgl = &dma_mmu_get_scsi_sgl;
  92         esp->dma_mmu_release_scsi_one = &dma_mmu_release_scsi_one;
  93         esp->dma_mmu_release_scsi_sgl = &dma_mmu_release_scsi_sgl;
  94         esp->dma_advance_sg = &dma_advance_sg;
  95
  96         /* SCSI chip speed */
  97         esp->cfreq = 20000000;
  98         esp->eregs = (struct ESP_regs *)(SUN3X_ESP_BASE);
  99         esp->dregs = (void *)SUN3X_ESP_DMA;
 100
 101         esp->esp_command = (volatile unsigned char *)cmd_buffer;
 102         esp->esp_command_dvma = dvma_alloc(virt_to_phys(cmd_buffer),
 103                                            sizeof (cmd_buffer));
 104
 105         esp->irq = 2;
 106         request_irq(esp->irq, esp_intr, SA_INTERRUPT, "SUN3X SCSI", NULL);
 107
 108         esp->scsi_id = 7;
 109         esp->diff = 0;
 110
 111         esp_initialize(esp);
 112
 113         printk("ESP: Total of %d ESP hosts found, %d actually in use.\n", nesps,
 114                esps_in_use);
 115         esps_running = esps_in_use;
 116         return esps_in_use;
 117 }
 118
 119 static void dma_barrier(struct NCR_ESP *esp)
 120 {
 121         struct sparc_dma_registers *dregs =
 122                 (struct sparc_dma_registers *) esp->dregs;
 123
 124         while(dregs->cond_reg & DMA_PEND_READ)
 125                 udelay(1);
 126         dregs->cond_reg &= ~(DMA_ENABLE);
 127 }
 128
 129 /* This uses various DMA csr fields and the fifo flags count value to
 130  * determine how many bytes were successfully sent/received by the ESP.
 131  */
 132 static int dma_bytes_sent(struct NCR_ESP *esp, int fifo_count)
 133 {
 134         struct sparc_dma_registers *dregs =
 135                 (struct sparc_dma_registers *) esp->dregs;
 136
 137         int rval = dregs->st_addr - esp->esp_command_dvma;
 138
 139         return rval - fifo_count;
 140 }
 141
 142 static int dma_can_transfer(struct NCR_ESP *esp, Scsi_Cmnd *sp)
 143 {
 144         __u32 base, end, sz;
 145
 146         base = ((__u32)sp->SCp.ptr);
 147         base &= (0x1000000 - 1);
 148         end = (base + sp->SCp.this_residual);
 149         if(end > 0x1000000)
 150                 end = 0x1000000;
 151         sz = (end - base);
 152         return sz;
 153 }
 154
 155 static void dma_drain(struct NCR_ESP *esp)
 156 {
 157         struct sparc_dma_registers *dregs =
 158                 (struct sparc_dma_registers *) esp->dregs;
 159
 160         if(dregs->cond_reg & DMA_FIFO_ISDRAIN) {
 161                 dregs->cond_reg |= DMA_FIFO_STDRAIN;
 162                 while(dregs->cond_reg & DMA_FIFO_ISDRAIN)
 163                         udelay(1);
 164         }
 165 }
 166
 167 static void dma_dump_state(struct NCR_ESP *esp)
 168 {
 169         struct sparc_dma_registers *dregs =
 170                 (struct sparc_dma_registers *) esp->dregs;
 171
 172         ESPLOG(("esp%d: dma -- cond_reg<%08lx> addr<%p>\n",
 173                 esp->esp_id, dregs->cond_reg, dregs->st_addr));
 174 }
 175
 176 static void dma_init_read(struct NCR_ESP *esp, __u32 vaddress, int length)
 177 {
 178         struct sparc_dma_registers *dregs =
 179                 (struct sparc_dma_registers *) esp->dregs;
 180
 181         dregs->cond_reg |= (DMA_ST_WRITE | DMA_ENABLE);
 182         dregs->st_addr = vaddress;
 183 }
 184
 185 static void dma_init_write(struct NCR_ESP *esp, __u32 vaddress, int length)
 186 {
 187         struct sparc_dma_registers *dregs =
 188                 (struct sparc_dma_registers *) esp->dregs;
 189
 190         /* Set up the DMA counters */
 191         dregs->cond_reg = ((dregs->cond_reg & ~(DMA_ST_WRITE)) | DMA_ENABLE);
 192         dregs->st_addr = vaddress;
 193 }
 194
 195 static void dma_ints_off(struct NCR_ESP *esp)
 196 {
 197         DMA_INTSOFF((struct sparc_dma_registers *) esp->dregs);
 198 }
 199
 200 static void dma_ints_on(struct NCR_ESP *esp)
 201 {
 202         DMA_INTSON((struct sparc_dma_registers *) esp->dregs);
 203 }
 204
 205 static int dma_irq_p(struct NCR_ESP *esp)
 206 {
 207         return DMA_IRQ_P((struct sparc_dma_registers *) esp->dregs);
 208 }
 209
 210 static void dma_poll(struct NCR_ESP *esp, unsigned char *vaddr)
 211 {
 212         dma_drain(esp);
 213
 214         /* Wait till the first bits settle. */
 215         while(vaddr[0] == 0xff)
 216                 udelay(1);
 217 }
 218
 219 static int dma_ports_p(struct NCR_ESP *esp)
 220 {
 221         return (((struct sparc_dma_registers *) esp->dregs)->cond_reg
 222                         & DMA_INT_ENAB);
 223 }
 224
 225 /* Resetting various pieces of the ESP scsi driver chipset/buses. */
 226 static void dma_reset(struct NCR_ESP *esp)
 227 {
 228         struct sparc_dma_registers *dregs =
 229                 (struct sparc_dma_registers *)esp->dregs;
 230
 231         /* Punt the DVMA into a known state. */
 232         dregs->cond_reg |= DMA_RST_SCSI;
 233         dregs->cond_reg &= ~(DMA_RST_SCSI);
 234         DMA_INTSON(dregs);
 235 }
 236
 237 static void dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write)
 238 {
 239         struct sparc_dma_registers *dregs =
 240                 (struct sparc_dma_registers *) esp->dregs;
 241         unsigned long nreg = dregs->cond_reg;
 242
 243         if(write)
 244                 nreg |= DMA_ST_WRITE;
 245         else
 246                 nreg &= ~(DMA_ST_WRITE);
 247         nreg |= DMA_ENABLE;
 248         dregs->cond_reg = nreg;
 249         dregs->st_addr = addr;
 250 }
 251
 252 static void dma_mmu_get_scsi_one (struct NCR_ESP *esp, Scsi_Cmnd *sp)
 253 {
 254     sp->SCp.have_data_in = dvma_alloc(virt_to_phys(sp->SCp.buffer),
 255                                        sp->SCp.this_residual);
 256     sp->SCp.ptr = (char *)((unsigned long)sp->SCp.have_data_in);
 257 }
 258
 259 static void dma_mmu_get_scsi_sgl (struct NCR_ESP *esp, Scsi_Cmnd *sp)
 260 {
 261     int sz = sp->SCp.buffers_residual;
 262     struct mmu_sglist *sg = (struct mmu_sglist *) sp->SCp.buffer;
 263
 264     while (sz >= 0) {
 265         sg[sz].dvma_addr = dvma_alloc(virt_to_phys(sg[sz].addr), sg[sz].len);
 266         sz--;
 267     }
 268     sp->SCp.ptr=(char *)((unsigned long)sp->SCp.buffer->dvma_address);
 269 }
 270
 271 static void dma_mmu_release_scsi_one (struct NCR_ESP *esp, Scsi_Cmnd *sp)
 272 {
 273     dvma_free(sp->SCp.have_data_in, sp->request_bufflen);
 274 }
 275
 276 static void dma_mmu_release_scsi_sgl (struct NCR_ESP *esp, Scsi_Cmnd *sp)
 277 {
 278     int sz = sp->use_sg - 1;
 279     struct mmu_sglist *sg = (struct mmu_sglist *)sp->buffer;
 280
 281     while(sz >= 0) {
 282         dvma_free(sg[sz].dvma_addr,sg[sz].len);
 283         sz--;
 284     }
 285 }
 286
 287 static void dma_advance_sg (Scsi_Cmnd *sp)
 288 {
 289     sp->SCp.ptr = (char *)((unsigned long)sp->SCp.buffer->dvma_address);
 290 }