git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/mca_53c9x.c

   1 /* mca_53c9x.c: Driver for the SCSI adapter found on NCR 35xx
   2  *  (and maybe some other) Microchannel machines
   3  *
   4  * Code taken mostly from Cyberstorm SCSI drivers
   5  *   Copyright (C) 1996 Jesper Skov (jskov@cygnus.co.uk)
   6  *
   7  * Hacked to work with the NCR MCA stuff by Tymm Twillman (tymm@computer.org)
   8  *
   9  * The CyberStorm SCSI driver (and this driver) is based on David S. Miller's
  10  *   ESP driver  * for the Sparc computers.
  11  *
  12  * Special thanks to Ken Stewart at Symbios (LSI) for helping with info on
  13  *  the 86C01.  I was on the brink of going ga-ga...
  14  *
  15  * Also thanks to Jesper Skov for helping me with info on how the Amiga
  16  *  does things...
  17  */
  18
  19 /*
  20  * This is currently only set up to use one 53c9x card at a time; it could be
  21  *  changed fairly easily to detect/use more than one, but I'm not too sure how
  22  *  many cards that use the 53c9x on MCA systems there are (if, in fact, there
  23  *  are cards that use them, other than the one built into some NCR systems)...
  24  *  If anyone requests this, I'll throw it in, otherwise it's not worth the
  25  *  effort.
  26  */
  27
  28 /*
  29  * Info on the 86C01 MCA interface chip at the bottom, if you care enough to
  30  *  look.
  31  */
  32
  33 #include <linux/delay.h>
  34 #include <linux/interrupt.h>
  35 #include <linux/kernel.h>
  36 #include <linux/mca.h>
  37 #include <linux/types.h>
  38 #include <linux/string.h>
  39 #include <linux/slab.h>
  40 #include <linux/blkdev.h>
  41 #include <linux/proc_fs.h>
  42 #include <linux/stat.h>
  43 #include <linux/mca-legacy.h>
  44
  45 #include "scsi.h"
  46 #include <scsi/scsi_host.h>
  47 #include "NCR53C9x.h"
  48
  49 #include <asm/dma.h>
  50 #include <asm/irq.h>
  51 #include <asm/mca_dma.h>
  52 #include <asm/pgtable.h>
  53
  54 /*
  55  * From ibmmca.c (IBM scsi controller card driver) -- used for turning PS2 disk
  56  *  activity LED on and off
  57  */
  58
  59 #define PS2_SYS_CTR     0x92
  60
  61 /* Ports the ncr's 53c94 can be put at; indexed by pos register value */
  62
  63 #define MCA_53C9X_IO_PORTS {                             \
  64                          0x0000, 0x0240, 0x0340, 0x0400, \
  65                          0x0420, 0x3240, 0x8240, 0xA240, \
  66                         }
  67
  68 /*
  69  * Supposedly there were some cards put together with the 'c9x and 86c01.  If
  70  *   they have different ID's from the ones on the 3500 series machines,
  71  *   you can add them here and hopefully things will work out.
  72  */
  73
  74 #define MCA_53C9X_IDS {          \
  75                          0x7F4C, \
  76                          0x0000, \
  77                         }
  78
  79 static int  dma_bytes_sent(struct NCR_ESP *, int);
  80 static int  dma_can_transfer(struct NCR_ESP *, Scsi_Cmnd *);
  81 static void dma_dump_state(struct NCR_ESP *);
  82 static void dma_init_read(struct NCR_ESP *, __u32, int);
  83 static void dma_init_write(struct NCR_ESP *, __u32, int);
  84 static void dma_ints_off(struct NCR_ESP *);
  85 static void dma_ints_on(struct NCR_ESP *);
  86 static int  dma_irq_p(struct NCR_ESP *);
  87 static int  dma_ports_p(struct NCR_ESP *);
  88 static void dma_setup(struct NCR_ESP *, __u32, int, int);
  89 static void dma_led_on(struct NCR_ESP *);
  90 static void dma_led_off(struct NCR_ESP *);
  91
  92 /* This is where all commands are put before they are trasfered to the
  93  *  53c9x via PIO.
  94  */
  95
  96 static volatile unsigned char cmd_buffer[16];
  97
  98 /*
  99  * We keep the structure that is used to access the registers on the 53c9x
 100  *  here.
 101  */
 102
 103 static struct ESP_regs eregs;
 104
 105 /***************************************************************** Detection */
 106 static int mca_esp_detect(struct scsi_host_template *tpnt)
 107 {
 108         struct NCR_ESP *esp;
 109         static int io_port_by_pos[] = MCA_53C9X_IO_PORTS;
 110         int mca_53c9x_ids[] = MCA_53C9X_IDS;
 111         int *id_to_check = mca_53c9x_ids;
 112         int slot;
 113         int pos[3];
 114         unsigned int tmp_io_addr;
 115         unsigned char tmp_byte;
 116
 117
 118         if (!MCA_bus)
 119                 return 0;
 120
 121         while (*id_to_check) {
 122                 if ((slot = mca_find_adapter(*id_to_check, 0)) !=
 123                   MCA_NOTFOUND)
 124                 {
 125                         esp = esp_allocate(tpnt, (void *) NULL);
 126
 127                         pos[0] = mca_read_stored_pos(slot, 2);
 128                         pos[1] = mca_read_stored_pos(slot, 3);
 129                         pos[2] = mca_read_stored_pos(slot, 4);
 130
 131                         esp->eregs = &eregs;
 132
 133                         /*
 134                          * IO port base is given in the first (non-ID) pos
 135                          *  register, like so:
 136                          *
 137                          *  Bits 3  2  1       IO base
 138                          * ----------------------------
 139                          *       0  0  0       <disabled>
 140                          *       0  0  1       0x0240
 141                          *       0  1  0       0x0340
 142                          *       0  1  1       0x0400
 143                          *       1  0  0       0x0420
 144                          *       1  0  1       0x3240
 145                          *       1  1  0       0x8240
 146                          *       1  1  1       0xA240
 147                          */
 148
 149                         tmp_io_addr =
 150                           io_port_by_pos[(pos[0] & 0x0E) >> 1];
 151
 152                         esp->eregs->io_addr = tmp_io_addr + 0x10;
 153
 154                         if (esp->eregs->io_addr == 0x0000) {
 155                                 printk("Adapter is disabled.\n");
 156                                 break;
 157                         }
 158
 159                         /*
 160                          * IRQ is specified in bits 4 and 5:
 161                          *
 162                          *  Bits  4  5        IRQ
 163                          * -----------------------
 164                          *        0  0         3
 165                          *        0  1         5
 166                          *        1  0         7
 167                          *        1  1         9
 168                          */
 169
 170                         esp->irq = ((pos[0] & 0x30) >> 3) + 3;
 171
 172                         /*
 173                          * DMA channel is in the low 3 bits of the second
 174                          *  POS register
 175                          */
 176
 177                         esp->dma = pos[1] & 7;
 178                         esp->slot = slot;
 179
 180                         if (request_irq(esp->irq, esp_intr, 0,
 181                          "NCR 53c9x SCSI", esp->ehost))
 182                         {
 183                                 printk("Unable to request IRQ %d.\n", esp->irq);
 184                                 esp_deallocate(esp);
 185                                 scsi_unregister(esp->ehost);
 186                                 return 0;
 187                         }
 188
 189                         if (request_dma(esp->dma, "NCR 53c9x SCSI")) {
 190                                 printk("Unable to request DMA channel %d.\n",
 191                                  esp->dma);
 192                                 free_irq(esp->irq, esp_intr);
 193                                 esp_deallocate(esp);
 194                                 scsi_unregister(esp->ehost);
 195                                 return 0;
 196                         }
 197
 198                         request_region(tmp_io_addr, 32, "NCR 53c9x SCSI");
 199
 200                         /*
 201                          * 86C01 handles DMA, IO mode, from address
 202                          *  (base + 0x0a)
 203                          */
 204
 205                         mca_disable_dma(esp->dma);
 206                         mca_set_dma_io(esp->dma, tmp_io_addr + 0x0a);
 207                         mca_enable_dma(esp->dma);
 208
 209                         /* Tell the 86C01 to give us interrupts */
 210
 211                         tmp_byte = inb(tmp_io_addr + 0x02) | 0x40;
 212                         outb(tmp_byte, tmp_io_addr + 0x02);
 213
 214                         /*
 215                          * Scsi ID -- general purpose register, hi
 216                          *  2 bits; add 4 to this number to get the
 217                          *  ID
 218                          */
 219
 220                         esp->scsi_id = ((pos[2] & 0xC0) >> 6) + 4;
 221
 222                         /* Do command transfer with programmed I/O */
 223
 224                         esp->do_pio_cmds = 1;
 225
 226                         /* Required functions */
 227
 228                         esp->dma_bytes_sent = &dma_bytes_sent;
 229                         esp->dma_can_transfer = &dma_can_transfer;
 230                         esp->dma_dump_state = &dma_dump_state;
 231                         esp->dma_init_read = &dma_init_read;
 232                         esp->dma_init_write = &dma_init_write;
 233                         esp->dma_ints_off = &dma_ints_off;
 234                         esp->dma_ints_on = &dma_ints_on;
 235                         esp->dma_irq_p = &dma_irq_p;
 236                         esp->dma_ports_p = &dma_ports_p;
 237                         esp->dma_setup = &dma_setup;
 238
 239                         /* Optional functions */
 240
 241                         esp->dma_barrier = NULL;
 242                         esp->dma_drain = NULL;
 243                         esp->dma_invalidate = NULL;
 244                         esp->dma_irq_entry = NULL;
 245                         esp->dma_irq_exit = NULL;
 246                         esp->dma_led_on = dma_led_on;
 247                         esp->dma_led_off = dma_led_off;
 248                         esp->dma_poll = NULL;
 249                         esp->dma_reset = NULL;
 250
 251                         /* Set the command buffer */
 252
 253                         esp->esp_command = (volatile unsigned char*)
 254                           cmd_buffer;
 255                         esp->esp_command_dvma = isa_virt_to_bus(cmd_buffer);
 256
 257                         /* SCSI chip speed */
 258
 259                         esp->cfreq = 25000000;
 260
 261                         /* Differential SCSI? I think not. */
 262
 263                         esp->diff = 0;
 264
 265                         esp_initialize(esp);
 266
 267                         printk(" Adapter found in slot %2d: io port 0x%x "
 268                           "irq %d dma channel %d\n", slot + 1, tmp_io_addr,
 269                            esp->irq, esp->dma);
 270
 271                         mca_set_adapter_name(slot, "NCR 53C9X SCSI Adapter");
 272                         mca_mark_as_used(slot);
 273
 274                         break;
 275                 }
 276
 277                 id_to_check++;
 278         }
 279
 280         return esps_in_use;
 281 }
 282
 283
 284 /******************************************************************* Release */
 285
 286 static int mca_esp_release(struct Scsi_Host *host)
 287 {
 288         struct NCR_ESP *esp = (struct NCR_ESP *)host->hostdata;
 289         unsigned char tmp_byte;
 290
 291         esp_deallocate(esp);
 292         /*
 293          * Tell the 86C01 to stop sending interrupts
 294          */
 295
 296         tmp_byte = inb(esp->eregs->io_addr - 0x0E);
 297         tmp_byte &= ~0x40;
 298         outb(tmp_byte, esp->eregs->io_addr - 0x0E);
 299
 300         free_irq(esp->irq, esp_intr);
 301         free_dma(esp->dma);
 302
 303         mca_mark_as_unused(esp->slot);
 304
 305         return 0;
 306 }
 307
 308 /************************************************************* DMA Functions */
 309 static int dma_bytes_sent(struct NCR_ESP *esp, int fifo_count)
 310 {
 311         /* Ask the 53c9x.  It knows. */
 312
 313         return fifo_count;
 314 }
 315
 316 static int dma_can_transfer(struct NCR_ESP *esp, Scsi_Cmnd *sp)
 317 {
 318         /*
 319          * The MCA dma channels can only do up to 128K bytes at a time.
 320          *  (16 bit mode)
 321          */
 322
 323         unsigned long sz = sp->SCp.this_residual;
 324         if(sz > 0x20000)
 325                 sz = 0x20000;
 326         return sz;
 327 }
 328
 329 static void dma_dump_state(struct NCR_ESP *esp)
 330 {
 331         /*
 332          * Doesn't quite match up to the other drivers, but we do what we
 333          *  can.
 334          */
 335
 336         ESPLOG(("esp%d: dma channel <%d>\n", esp->esp_id, esp->dma));
 337         ESPLOG(("bytes left to dma: %d\n", mca_get_dma_residue(esp->dma)));
 338 }
 339
 340 static void dma_init_read(struct NCR_ESP *esp, __u32 addr, int length)
 341 {
 342         unsigned long flags;
 343
 344
 345         save_flags(flags);
 346         cli();
 347
 348         mca_disable_dma(esp->dma);
 349         mca_set_dma_mode(esp->dma, MCA_DMA_MODE_XFER | MCA_DMA_MODE_16 |
 350           MCA_DMA_MODE_IO);
 351         mca_set_dma_addr(esp->dma, addr);
 352         mca_set_dma_count(esp->dma, length / 2); /* !!! */
 353         mca_enable_dma(esp->dma);
 354
 355         restore_flags(flags);
 356 }
 357
 358 static void dma_init_write(struct NCR_ESP *esp, __u32 addr, int length)
 359 {
 360         unsigned long flags;
 361
 362
 363         save_flags(flags);
 364         cli();
 365
 366         mca_disable_dma(esp->dma);
 367         mca_set_dma_mode(esp->dma, MCA_DMA_MODE_XFER | MCA_DMA_MODE_WRITE |
 368           MCA_DMA_MODE_16 | MCA_DMA_MODE_IO);
 369         mca_set_dma_addr(esp->dma, addr);
 370         mca_set_dma_count(esp->dma, length / 2); /* !!! */
 371         mca_enable_dma(esp->dma);
 372
 373         restore_flags(flags);
 374 }
 375
 376 static void dma_ints_off(struct NCR_ESP *esp)
 377 {
 378         /*
 379          * Tell the 'C01 to shut up.  All interrupts are routed through it.
 380          */
 381
 382         outb(inb(esp->eregs->io_addr - 0x0E) & ~0x40,
 383          esp->eregs->io_addr - 0x0E);
 384 }
 385
 386 static void dma_ints_on(struct NCR_ESP *esp)
 387 {
 388         /*
 389          * Ok.  You can speak again.
 390          */
 391
 392         outb(inb(esp->eregs->io_addr - 0x0E) | 0x40,
 393          esp->eregs->io_addr - 0x0E);
 394 }
 395
 396 static int dma_irq_p(struct NCR_ESP *esp)
 397 {
 398         /*
 399          * DaveM says that this should return a "yes" if there is an interrupt
 400          *  or a DMA error occurred.  I copied the Amiga driver's semantics,
 401          *  though, because it seems to work and we can't really tell if
 402          *  a DMA error happened.  This gives the "yes" if the scsi chip
 403          *  is sending an interrupt and no DMA activity is taking place
 404          */
 405
 406         return (!(inb(esp->eregs->io_addr - 0x04) & 1) &&
 407          !(inb(esp->eregs->io_addr - 0x04) & 2) );
 408 }
 409
 410 static int dma_ports_p(struct NCR_ESP *esp)
 411 {
 412         /*
 413          * Check to see if interrupts are enabled on the 'C01 (in case abort
 414          *  is entered multiple times, so we only do the abort once)
 415          */
 416
 417         return (inb(esp->eregs->io_addr - 0x0E) & 0x40) ? 1:0;
 418 }
 419
 420 static void dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write)
 421 {
 422         if(write){
 423                 dma_init_write(esp, addr, count);
 424         } else {
 425                 dma_init_read(esp, addr, count);
 426         }
 427 }
 428
 429 /*
 430  * These will not play nicely with other disk controllers that try to use the
 431  *  disk active LED... but what can you do?  Don't answer that.
 432  *
 433  * Stolen shamelessly from ibmmca.c -- IBM Microchannel SCSI adapter driver
 434  *
 435  */
 436
 437 static void dma_led_on(struct NCR_ESP *esp)
 438 {
 439         outb(inb(PS2_SYS_CTR) | 0xc0, PS2_SYS_CTR);
 440 }
 441
 442 static void dma_led_off(struct NCR_ESP *esp)
 443 {
 444         outb(inb(PS2_SYS_CTR) & 0x3f, PS2_SYS_CTR);
 445 }
 446
 447 static struct scsi_host_template driver_template = {
 448         .proc_name              = "mca_53c9x",
 449         .name                   = "NCR 53c9x SCSI",
 450         .detect                 = mca_esp_detect,
 451         .slave_alloc            = esp_slave_alloc,
 452         .slave_destroy          = esp_slave_destroy,
 453         .release                = mca_esp_release,
 454         .queuecommand           = esp_queue,
 455         .eh_abort_handler       = esp_abort,
 456         .eh_bus_reset_handler   = esp_reset,
 457         .can_queue              = 7,
 458         .sg_tablesize           = SG_ALL,
 459         .cmd_per_lun            = 1,
 460         .unchecked_isa_dma      = 1,
 461         .use_clustering         = DISABLE_CLUSTERING
 462 };
 463
 464
 465 #include "scsi_module.c"
 466
 467 /*
 468  * OK, here's the goods I promised.  The NCR 86C01 is an MCA interface chip
 469  *  that handles enabling/diabling IRQ, dma interfacing, IO port selection
 470  *  and other fun stuff.  It takes up 16 addresses, and the chip it is
 471  *  connnected to gets the following 16.  Registers are as follows:
 472  *
 473  * Offsets 0-1 : Card ID
 474  *
 475  * Offset    2 : Mode enable register --
 476  *                Bit    7 : Data Word width (1 = 16, 0 = 8)
 477  *                Bit    6 : IRQ enable (1 = enabled)
 478  *                Bits 5,4 : IRQ select
 479  *                              0  0 : IRQ 3
 480  *                              0  1 : IRQ 5
 481  *                              1  0 : IRQ 7
 482  *                              1  1 : IRQ 9
 483  *                Bits 3-1 : Base Address
 484  *                           0  0  0 : <disabled>
 485  *                           0  0  1 : 0x0240
 486  *                           0  1  0 : 0x0340
 487  *                           0  1  1 : 0x0400
 488  *                           1  0  0 : 0x0420
 489  *                           1  0  1 : 0x3240
 490  *                           1  1  0 : 0x8240
 491  *                           1  1  1 : 0xA240
 492  *                Bit    0 : Card enable (1 = enabled)
 493  *
 494  * Offset    3 : DMA control register --
 495  *                Bit    7 : DMA enable (1 = enabled)
 496  *                Bits 6,5 : Preemt Count Select (transfers to complete after
 497  *                            'C01 has been preempted on MCA bus)
 498  *                              0  0 : 0
 499  *                              0  1 : 1
 500  *                              1  0 : 3
 501  *                              1  1 : 7
 502  *  (all these wacky numbers; I'm sure there's a reason somewhere)
 503  *                Bit    4 : Fairness enable (1 = fair bus priority)
 504  *                Bits 3-0 : Arbitration level (0-15 consecutive)
 505  *
 506  * Offset    4 : General purpose register
 507  *                Bits 7-3 : User definable (here, 7,6 are SCSI ID)
 508  *                Bits 2-0 : reserved
 509  *
 510  * Offset   10 : DMA decode register (used for IO based DMA; also can do
 511  *                PIO through this port)
 512  *
 513  * Offset   12 : Status
 514  *                Bits 7-2 : reserved
 515  *                Bit    1 : DMA pending (1 = pending)
 516  *                Bit    0 : IRQ pending (0 = pending)
 517  *
 518  * Exciting, huh?
 519  *
 520  */