drivers/scsi/dec_esp.c

   1 /*
   2  * dec_esp.c: Driver for SCSI chips on IOASIC based TURBOchannel DECstations
   3  *            and TURBOchannel PMAZ-A cards
   4  *
   5  * TURBOchannel changes by Harald Koerfgen
   6  * PMAZ-A support by David Airlie
   7  *
   8  * based on jazz_esp.c:
   9  * Copyright (C) 1997 Thomas Bogendoerfer (tsbogend@alpha.franken.de)
  10  *
  11  * jazz_esp is based on David S. Miller's ESP driver and cyber_esp
  12  *
  13  * 20000819 - Small PMAZ-AA fixes by Florian Lohoff <flo@rfc822.org>
  14  *            Be warned the PMAZ-AA works currently as a single card.
  15  *            Dont try to put multiple cards in one machine - They are
  16  *            both detected but it may crash under high load garbling your
  17  *            data.
  18  * 20001005     - Initialization fixes for 2.4.0-test9
  19  *                        Florian Lohoff <flo@rfc822.org>
  20  */
  21
  22 #include <linux/kernel.h>
  23 #include <linux/delay.h>
  24 #include <linux/types.h>
  25 #include <linux/string.h>
  26 #include <linux/slab.h>
  27 #include <linux/blkdev.h>
  28 #include <linux/proc_fs.h>
  29 #include <linux/stat.h>
  30
  31 #include "scsi.h"
  32 #include "hosts.h"
  33 #include "NCR53C9x.h"
  34
  35 #include <asm/irq.h>
  36 #include <asm/jazz.h>
  37 #include <asm/jazzdma.h>
  38 #include <asm/dma.h>
  39
  40 #include <asm/pgtable.h>
  41
  42 #include <asm/dec/tc.h>
  43 #include <asm/dec/interrupts.h>
  44 #include <asm/dec/ioasic_addrs.h>
  45 #include <asm/dec/ioasic_ints.h>
  46 #include <asm/dec/machtype.h>
  47
  48 #define DEC_SCSI_SREG 0
  49 #define DEC_SCSI_DMAREG 0x40000
  50 #define DEC_SCSI_SRAM 0x80000
  51 #define DEC_SCSI_DIAG 0xC0000
  52
  53 /*
  54  * Once upon a time the pmaz code used to be working but
  55  * it hasn't been maintained for quite some time.
  56  * It isn't working anymore but I'll leave here as a
  57  * starting point. #define this an be prepared for tons
  58  * of warnings and errors :)
  59  */
  60 static int  dma_bytes_sent(struct NCR_ESP *esp, int fifo_count);
  61 static void dma_drain(struct NCR_ESP *esp);
  62 static int  dma_can_transfer(struct NCR_ESP *esp, Scsi_Cmnd * sp);
  63 static void dma_dump_state(struct NCR_ESP *esp);
  64 static void dma_init_read(struct NCR_ESP *esp, __u32 vaddress, int length);
  65 static void dma_init_write(struct NCR_ESP *esp, __u32 vaddress, int length);
  66 static void dma_ints_off(struct NCR_ESP *esp);
  67 static void dma_ints_on(struct NCR_ESP *esp);
  68 static int  dma_irq_p(struct NCR_ESP *esp);
  69 static int  dma_ports_p(struct NCR_ESP *esp);
  70 static void dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write);
  71 static void dma_mmu_get_scsi_one(struct NCR_ESP *esp, Scsi_Cmnd * sp);
  72 static void dma_mmu_get_scsi_sgl(struct NCR_ESP *esp, Scsi_Cmnd * sp);
  73 static void dma_advance_sg(Scsi_Cmnd * sp);
  74
  75 static void pmaz_dma_drain(struct NCR_ESP *esp);
  76 static void pmaz_dma_init_read(struct NCR_ESP *esp, __u32 vaddress, int length);
  77 static void pmaz_dma_init_write(struct NCR_ESP *esp, __u32 vaddress, int length);
  78 static void pmaz_dma_ints_off(struct NCR_ESP *esp);
  79 static void pmaz_dma_ints_on(struct NCR_ESP *esp);
  80 static void pmaz_dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write);
  81 static void pmaz_dma_mmu_get_scsi_one(struct NCR_ESP *esp, Scsi_Cmnd * sp);
  82
  83 #define TC_ESP_RAM_SIZE 0x20000
  84 #define ESP_TGT_DMA_SIZE ((TC_ESP_RAM_SIZE/7) & ~(sizeof(int)-1))
  85 #define ESP_NCMD 7
  86
  87 #define TC_ESP_DMAR_MASK  0x1ffff
  88 #define TC_ESP_DMAR_WRITE 0x80000000
  89 #define TC_ESP_DMA_ADDR(x) ((unsigned)(x) & TC_ESP_DMAR_MASK)
  90
  91 __u32 esp_virt_buffer;
  92 int scsi_current_length;
  93
  94 volatile unsigned char cmd_buffer[16];
  95 volatile unsigned char pmaz_cmd_buffer[16];
  96                                 /* This is where all commands are put
  97                                  * before they are trasfered to the ESP chip
  98                                  * via PIO.
  99                                  */
 100
 101 volatile unsigned long *scsi_dma_ptr;
 102 volatile unsigned long *scsi_next_ptr;
 103 volatile unsigned long *scsi_scr;
 104 volatile unsigned long *ioasic_ssr;
 105 volatile unsigned long *scsi_sdr0;
 106 volatile unsigned long *scsi_sdr1;
 107
 108 static void scsi_dma_int(int, void *, struct pt_regs *);
 109
 110 int dec_esp_detect(Scsi_Host_Template * tpnt);
 111
 112 static int dec_esp_release(struct Scsi_Host *shost)
 113 {
 114         if (shost->irq)
 115                 free_irq(shost->irq, NULL);
 116         if (shost->io_port && shost->n_io_port)
 117                 release_region(shost->io_port, shost->n_io_port);
 118         scsi_unregister(shost);
 119         return 0;
 120 }
 121
 122 static Scsi_Host_Template driver_template = {
 123         .proc_name              = "esp",
 124         .proc_info              = &esp_proc_info,
 125         .name                   = "NCR53C94",
 126         .detect                 = dec_esp_detect,
 127         .slave_alloc            = esp_slave_alloc,
 128         .slave_destroy          = esp_slave_destroy,
 129         .release                = dec_esp_release,
 130         .info                   = esp_info,
 131         .queuecommand           = esp_queue,
 132         .eh_abort_handler       = esp_abort,
 133         .eh_bus_reset_handler   = esp_reset,
 134         .can_queue              = 7,
 135         .this_id                = 7,
 136         .sg_tablesize           = SG_ALL,
 137         .cmd_per_lun            = 1,
 138         .use_clustering         = DISABLE_CLUSTERING,
 139 };
 140
 141
 142 #include "scsi_module.c"
 143
 144 /***************************************************************** Detection */
 145 int dec_esp_detect(Scsi_Host_Template * tpnt)
 146 {
 147         struct NCR_ESP *esp;
 148         struct ConfigDev *esp_dev;
 149         int slot;
 150         unsigned long mem_start;
 151
 152         if (IOASIC) {
 153                 esp_dev = 0;
 154                 esp = esp_allocate(tpnt, (void *) esp_dev);
 155
 156                 scsi_dma_ptr = (unsigned long *) (system_base + IOCTL + SCSI_DMA_P);
 157                 scsi_next_ptr = (unsigned long *) (system_base + IOCTL + SCSI_DMA_BP);
 158                 scsi_scr = (unsigned long *) (system_base + IOCTL + SCSI_SCR);
 159                 ioasic_ssr = (unsigned long *) (system_base + IOCTL + SSR);
 160                 scsi_sdr0 = (unsigned long *) (system_base + IOCTL + SCSI_SDR0);
 161                 scsi_sdr1 = (unsigned long *) (system_base + IOCTL + SCSI_SDR1);
 162
 163                 /* Do command transfer with programmed I/O */
 164                 esp->do_pio_cmds = 1;
 165
 166                 /* Required functions */
 167                 esp->dma_bytes_sent = &dma_bytes_sent;
 168                 esp->dma_can_transfer = &dma_can_transfer;
 169                 esp->dma_dump_state = &dma_dump_state;
 170                 esp->dma_init_read = &dma_init_read;
 171                 esp->dma_init_write = &dma_init_write;
 172                 esp->dma_ints_off = &dma_ints_off;
 173                 esp->dma_ints_on = &dma_ints_on;
 174                 esp->dma_irq_p = &dma_irq_p;
 175                 esp->dma_ports_p = &dma_ports_p;
 176                 esp->dma_setup = &dma_setup;
 177
 178                 /* Optional functions */
 179                 esp->dma_barrier = 0;
 180                 esp->dma_drain = &dma_drain;
 181                 esp->dma_invalidate = 0;
 182                 esp->dma_irq_entry = 0;
 183                 esp->dma_irq_exit = 0;
 184                 esp->dma_poll = 0;
 185                 esp->dma_reset = 0;
 186                 esp->dma_led_off = 0;
 187                 esp->dma_led_on = 0;
 188
 189                 /* virtual DMA functions */
 190                 esp->dma_mmu_get_scsi_one = &dma_mmu_get_scsi_one;
 191                 esp->dma_mmu_get_scsi_sgl = &dma_mmu_get_scsi_sgl;
 192                 esp->dma_mmu_release_scsi_one = 0;
 193                 esp->dma_mmu_release_scsi_sgl = 0;
 194                 esp->dma_advance_sg = &dma_advance_sg;
 195
 196
 197                 /* SCSI chip speed */
 198                 esp->cfreq = 25000000;
 199
 200                 /*
 201                  * we don't give the address of DMA channel, but the number
 202                  * of DMA channel, so we can use the jazz DMA functions
 203                  *
 204                  */
 205                 esp->dregs = JAZZ_SCSI_DMA;
 206
 207                 /* ESP register base */
 208                 esp->eregs = (struct ESP_regs *) (system_base + SCSI);
 209
 210                 /* Set the command buffer */
 211                 esp->esp_command = (volatile unsigned char *) cmd_buffer;
 212
 213                 /* get virtual dma address for command buffer */
 214                 esp->esp_command_dvma = (__u32) KSEG1ADDR((volatile unsigned char *) cmd_buffer);
 215
 216                 esp->irq = SCSI_INT;
 217
 218                 esp->scsi_id = 7;
 219
 220                 /* Check for differential SCSI-bus */
 221                 esp->diff = 0;
 222
 223                 esp_initialize(esp);
 224
 225                 if (request_irq(esp->irq, esp_intr, SA_INTERRUPT,
 226                                 "NCR 53C94 SCSI", esp->ehost))
 227                         goto err_dealloc;
 228                 if (request_irq(SCSI_DMA_INT, scsi_dma_int, SA_INTERRUPT,
 229                                 "JUNKIO SCSI DMA", esp->ehost))
 230                         goto err_free_irq;
 231
 232         }
 233
 234         if (TURBOCHANNEL) {
 235                 while ((slot = search_tc_card("PMAZ-AA")) >= 0) {
 236                         claim_tc_card(slot);
 237
 238                         esp_dev = 0;
 239                         esp = esp_allocate(tpnt, (void *) esp_dev);
 240
 241                         mem_start = get_tc_base_addr(slot);
 242
 243                         /* Store base addr into esp struct */
 244                         esp->slot = mem_start;
 245
 246                         esp->dregs = 0;
 247                         esp->eregs = (struct ESP_regs *) (mem_start + DEC_SCSI_SREG);
 248                         esp->do_pio_cmds = 1;
 249
 250                         /* Set the command buffer */
 251                         esp->esp_command = (volatile unsigned char *) pmaz_cmd_buffer;
 252
 253                         /* get virtual dma address for command buffer */
 254                         esp->esp_command_dvma = (__u32) KSEG0ADDR((volatile unsigned char *) pmaz_cmd_buffer);
 255
 256                         esp->cfreq = get_tc_speed();
 257
 258                         esp->irq = get_tc_irq_nr(slot);
 259
 260                         /* Required functions */
 261                         esp->dma_bytes_sent = &dma_bytes_sent;
 262                         esp->dma_can_transfer = &dma_can_transfer;
 263                         esp->dma_dump_state = &dma_dump_state;
 264                         esp->dma_init_read = &pmaz_dma_init_read;
 265                         esp->dma_init_write = &pmaz_dma_init_write;
 266                         esp->dma_ints_off = &pmaz_dma_ints_off;
 267                         esp->dma_ints_on = &pmaz_dma_ints_on;
 268                         esp->dma_irq_p = &dma_irq_p;
 269                         esp->dma_ports_p = &dma_ports_p;
 270                         esp->dma_setup = &pmaz_dma_setup;
 271
 272                         /* Optional functions */
 273                         esp->dma_barrier = 0;
 274                         esp->dma_drain = &pmaz_dma_drain;
 275                         esp->dma_invalidate = 0;
 276                         esp->dma_irq_entry = 0;
 277                         esp->dma_irq_exit = 0;
 278                         esp->dma_poll = 0;
 279                         esp->dma_reset = 0;
 280                         esp->dma_led_off = 0;
 281                         esp->dma_led_on = 0;
 282
 283                         esp->dma_mmu_get_scsi_one = pmaz_dma_mmu_get_scsi_one;
 284                         esp->dma_mmu_get_scsi_sgl = 0;
 285                         esp->dma_mmu_release_scsi_one = 0;
 286                         esp->dma_mmu_release_scsi_sgl = 0;
 287                         esp->dma_advance_sg = 0;
 288
 289                         if (request_irq(esp->irq, esp_intr, SA_INTERRUPT,
 290                                          "PMAZ_AA", esp->ehost)) {
 291                                 esp_deallocate(esp);
 292                                 release_tc_card(slot);
 293                                 continue;
 294                         }
 295                         esp->scsi_id = 7;
 296                         esp->diff = 0;
 297                         esp_initialize(esp);
 298                 }
 299         }
 300
 301         if(nesps) {
 302                 printk("ESP: Total of %d ESP hosts found, %d actually in use.\n", nesps, esps_in_use);
 303                 esps_running = esps_in_use;
 304                 return esps_in_use;
 305         }
 306         return 0;
 307
 308  err_free_irq:
 309         free_irq(esp->irq, esp_intr);
 310  err_dealloc:
 311         esp_deallocate(esp);
 312         return 0;
 313 }
 314
 315 /************************************************************* DMA Functions */
 316 static void scsi_dma_int(int irq, void *dev_id, struct pt_regs *regs)
 317 {
 318         extern volatile unsigned int *isr;
 319         unsigned int dummy;
 320
 321         if (*isr & SCSI_PTR_LOADED) {
 322                 /* next page */
 323                 *scsi_next_ptr = ((*scsi_dma_ptr + PAGE_SIZE) & PAGE_MASK) << 3;
 324                 *isr &= ~SCSI_PTR_LOADED;
 325         } else {
 326                 if (*isr & SCSI_PAGOVRRUN)
 327                         *isr &= ~SCSI_PAGOVRRUN;
 328                 if (*isr & SCSI_DMA_MEMRDERR) {
 329                         printk("Got unexpected SCSI DMA Interrupt! < ");
 330                         printk("SCSI_DMA_MEMRDERR ");
 331                 printk(">\n");
 332                         *isr &= ~SCSI_DMA_MEMRDERR;
 333                 }
 334         }
 335
 336         /*
 337          * This routine will only work on IOASIC machines
 338          * so we can avoid an indirect function call here
 339          * and flush the writeback buffer the fast way
 340          */
 341         dummy = *isr;
 342         dummy = *isr;
 343 }
 344
 345 static int dma_bytes_sent(struct NCR_ESP *esp, int fifo_count)
 346 {
 347     return fifo_count;
 348 }
 349
 350 static void dma_drain(struct NCR_ESP *esp)
 351 {
 352         unsigned long nw = *scsi_scr;
 353         unsigned short *p = (unsigned short *)KSEG1ADDR((*scsi_dma_ptr) >> 3);
 354
 355     /*
 356          * Is there something in the dma buffers left?
 357      */
 358         if (nw) {
 359                 switch (nw) {
 360                 case 1:
 361                         *p = (unsigned short) *scsi_sdr0;
 362                         break;
 363                 case 2:
 364                         *p++ = (unsigned short) (*scsi_sdr0);
 365                         *p = (unsigned short) ((*scsi_sdr0) >> 16);
 366                         break;
 367                 case 3:
 368                         *p++ = (unsigned short) (*scsi_sdr0);
 369                         *p++ = (unsigned short) ((*scsi_sdr0) >> 16);
 370                         *p = (unsigned short) (*scsi_sdr1);
 371                         break;
 372                 default:
 373                         printk("Strange: %d words in dma buffer left\n", (int) nw);
 374                         break;
 375                 }
 376         }
 377 }
 378
 379 static int dma_can_transfer(struct NCR_ESP *esp, Scsi_Cmnd * sp)
 380 {
 381         return sp->SCp.this_residual;
 382 }
 383
 384 static void dma_dump_state(struct NCR_ESP *esp)
 385 {
 386 /*
 387     ESPLOG(("esp%d: dma -- enable <%08x> residue <%08x\n",
 388             esp->esp_id, vdma_get_enable((int)esp->dregs), vdma_get_resdiue((int)esp->dregs)));
 389  */
 390 }
 391
 392 static void dma_init_read(struct NCR_ESP *esp, __u32 vaddress, int length)
 393 {
 394         extern volatile unsigned int *isr;
 395         unsigned int dummy;
 396
 397         if (vaddress & 3)
 398                 panic("dec_efs.c: unable to handle partial word transfers, yet...");
 399
 400         dma_cache_wback_inv((unsigned long) phys_to_virt(vaddress), length);
 401
 402         *ioasic_ssr &= ~SCSI_DMA_EN;
 403         *scsi_scr = 0;
 404         *scsi_dma_ptr = vaddress << 3;
 405
 406         /* prepare for next page */
 407         *scsi_next_ptr = ((vaddress + PAGE_SIZE) & PAGE_MASK) << 3;
 408         *ioasic_ssr |= (SCSI_DMA_DIR | SCSI_DMA_EN);
 409
 410         /*
 411          * see above
 412          */
 413         dummy = *isr;
 414         dummy = *isr;
 415 }
 416
 417 static void dma_init_write(struct NCR_ESP *esp, __u32 vaddress, int length)
 418 {
 419         extern volatile unsigned int *isr;
 420         unsigned int dummy;
 421
 422         if (vaddress & 3)
 423                 panic("dec_efs.c: unable to handle partial word transfers, yet...");
 424
 425         dma_cache_wback_inv((unsigned long) phys_to_virt(vaddress), length);
 426
 427         *ioasic_ssr &= ~(SCSI_DMA_DIR | SCSI_DMA_EN);
 428         *scsi_scr = 0;
 429         *scsi_dma_ptr = vaddress << 3;
 430
 431         /* prepare for next page */
 432         *scsi_next_ptr = ((vaddress + PAGE_SIZE) & PAGE_MASK) << 3;
 433         *ioasic_ssr |= SCSI_DMA_EN;
 434
 435         /*
 436          * see above
 437          */
 438         dummy = *isr;
 439         dummy = *isr;
 440 }
 441
 442 static void dma_ints_off(struct NCR_ESP *esp)
 443 {
 444         disable_irq(SCSI_DMA_INT);
 445 }
 446
 447 static void dma_ints_on(struct NCR_ESP *esp)
 448 {
 449         enable_irq(SCSI_DMA_INT);
 450 }
 451
 452 static int dma_irq_p(struct NCR_ESP *esp)
 453 {
 454     return (esp->eregs->esp_status & ESP_STAT_INTR);
 455 }
 456
 457 static int dma_ports_p(struct NCR_ESP *esp)
 458 {
 459 /*
 460  * FIXME: what's this good for?
 461  */
 462         return 1;
 463 }
 464
 465 static void dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write)
 466 {
 467     /*
 468      * On the Sparc, DMA_ST_WRITE means "move data from device to memory"
 469      * so when (write) is true, it actually means READ!
 470      */
 471         if (write) {
 472         dma_init_read(esp, addr, count);
 473     } else {
 474         dma_init_write(esp, addr, count);
 475     }
 476 }
 477
 478 /*
 479  * These aren't used yet
 480  */
 481 static void dma_mmu_get_scsi_one(struct NCR_ESP *esp, Scsi_Cmnd * sp)
 482 {
 483         sp->SCp.ptr = (char *)PHYSADDR(sp->SCp.buffer);
 484 }
 485
 486 static void dma_mmu_get_scsi_sgl(struct NCR_ESP *esp, Scsi_Cmnd * sp)
 487 {
 488     int sz = sp->SCp.buffers_residual;
 489     struct mmu_sglist *sg = (struct mmu_sglist *) sp->SCp.buffer;
 490
 491     while (sz >= 0) {
 492                 sg[sz].dvma_addr = PHYSADDR(sg[sz].addr);
 493         sz--;
 494     }
 495         sp->SCp.ptr = (char *) ((unsigned long) sp->SCp.buffer->dvma_address);
 496 }
 497
 498 static void dma_advance_sg(Scsi_Cmnd * sp)
 499 {
 500         sp->SCp.ptr = (char *) ((unsigned long) sp->SCp.buffer->dvma_address);
 501 }
 502
 503 static void pmaz_dma_drain(struct NCR_ESP *esp)
 504 {
 505         memcpy((void *) (KSEG0ADDR(esp_virt_buffer)),
 506                 (void *) ( esp->slot + DEC_SCSI_SRAM + ESP_TGT_DMA_SIZE),
 507                 scsi_current_length);
 508 }
 509
 510 static void pmaz_dma_init_read(struct NCR_ESP *esp, __u32 vaddress, int length)
 511 {
 512         volatile int *dmareg = (volatile int *) (esp->slot + DEC_SCSI_DMAREG);
 513
 514         if (length > ESP_TGT_DMA_SIZE)
 515                 length = ESP_TGT_DMA_SIZE;
 516
 517         *dmareg = TC_ESP_DMA_ADDR(esp->slot + DEC_SCSI_SRAM + ESP_TGT_DMA_SIZE);
 518
 519         esp_virt_buffer = vaddress;
 520         scsi_current_length = length;
 521 }
 522
 523 static void pmaz_dma_init_write(struct NCR_ESP *esp, __u32 vaddress, int length)
 524 {
 525         volatile int *dmareg = (volatile int *) ( esp->slot + DEC_SCSI_DMAREG );
 526
 527         memcpy((void *)(esp->slot + DEC_SCSI_SRAM + ESP_TGT_DMA_SIZE),
 528                (void *)KSEG0ADDR(vaddress), length);
 529
 530         *dmareg = TC_ESP_DMAR_WRITE |
 531                 TC_ESP_DMA_ADDR(esp->slot + DEC_SCSI_SRAM + ESP_TGT_DMA_SIZE);
 532
 533 }
 534
 535 static void pmaz_dma_ints_off(struct NCR_ESP *esp)
 536 {
 537 }
 538
 539 static void pmaz_dma_ints_on(struct NCR_ESP *esp)
 540 {
 541 }
 542
 543 static void pmaz_dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write)
 544 {
 545         /*
 546          * On the Sparc, DMA_ST_WRITE means "move data from device to memory"
 547          * so when (write) is true, it actually means READ!
 548          */
 549         if (write) {
 550                 pmaz_dma_init_read(esp, addr, count);
 551         } else {
 552                 pmaz_dma_init_write(esp, addr, count);
 553         }
 554 }
 555
 556 static void pmaz_dma_mmu_get_scsi_one(struct NCR_ESP *esp, Scsi_Cmnd * sp)
 557 {
 558         sp->SCp.ptr = (char *)KSEG0ADDR((sp->request_buffer));
 559 }