drivers/scsi/qlogicfas408.c

   1 /*----------------------------------------------------------------*/
   2 /*
   3    Qlogic linux driver - work in progress. No Warranty express or implied.
   4    Use at your own risk.  Support Tort Reform so you won't have to read all
   5    these silly disclaimers.
   6
   7    Copyright 1994, Tom Zerucha.
   8    tz@execpc.com
   9
  10    Additional Code, and much appreciated help by
  11    Michael A. Griffith
  12    grif@cs.ucr.edu
  13
  14    Thanks to Eric Youngdale and Dave Hinds for loadable module and PCMCIA
  15    help respectively, and for suffering through my foolishness during the
  16    debugging process.
  17
  18    Reference Qlogic FAS408 Technical Manual, 53408-510-00A, May 10, 1994
  19    (you can reference it, but it is incomplete and inaccurate in places)
  20
  21    Version 0.46 1/30/97 - kernel 1.2.0+
  22
  23    Functions as standalone, loadable, and PCMCIA driver, the latter from
  24    Dave Hinds' PCMCIA package.
  25
  26    Cleaned up 26/10/2002 by Alan Cox <alan@lxorguk.ukuu.org.uk> as part of the 2.5
  27    SCSI driver cleanup and audit. This driver still needs work on the
  28    following
  29         -       Non terminating hardware waits
  30         -       Some layering violations with its pcmcia stub
  31
  32    Redistributable under terms of the GNU General Public License
  33
  34    For the avoidance of doubt the "preferred form" of this code is one which
  35    is in an open non patent encumbered format. Where cryptographic key signing
  36    forms part of the process of creating an executable the information
  37    including keys needed to generate an equivalently functional executable
  38    are deemed to be part of the source code.
  39
  40 */
  41
  42 #include <linux/module.h>
  43 #include <linux/blkdev.h>               /* to get disk capacity */
  44 #include <linux/kernel.h>
  45 #include <linux/string.h>
  46 #include <linux/init.h>
  47 #include <linux/interrupt.h>
  48 #include <linux/ioport.h>
  49 #include <linux/proc_fs.h>
  50 #include <linux/unistd.h>
  51 #include <linux/spinlock.h>
  52 #include <linux/stat.h>
  53
  54 #include <asm/io.h>
  55 #include <asm/irq.h>
  56 #include <asm/dma.h>
  57
  58 #include "scsi.h"
  59 #include <scsi/scsi_host.h>
  60 #include "qlogicfas408.h"
  61
  62 /*----------------------------------------------------------------*/
  63 static int qlcfg5 = (XTALFREQ << 5);    /* 15625/512 */
  64 static int qlcfg6 = SYNCXFRPD;
  65 static int qlcfg7 = SYNCOFFST;
  66 static int qlcfg8 = (SLOWCABLE << 7) | (QL_ENABLE_PARITY << 4);
  67 static int qlcfg9 = ((XTALFREQ + 4) / 5);
  68 static int qlcfgc = (FASTCLK << 3) | (FASTSCSI << 4);
  69
  70 /*----------------------------------------------------------------*/
  71
  72 /*----------------------------------------------------------------*/
  73 /* local functions */
  74 /*----------------------------------------------------------------*/
  75
  76 /* error recovery - reset everything */
  77
  78 static void ql_zap(struct qlogicfas408_priv *priv)
  79 {
  80         int x;
  81         int qbase = priv->qbase;
  82         int int_type = priv->int_type;
  83
  84         x = inb(qbase + 0xd);
  85         REG0;
  86         outb(3, qbase + 3);     /* reset SCSI */
  87         outb(2, qbase + 3);     /* reset chip */
  88         if (x & 0x80)
  89                 REG1;
  90 }
  91
  92 /*
  93  *      Do a pseudo-dma tranfer
  94  */
  95
  96 static int ql_pdma(struct qlogicfas408_priv *priv, int phase, char *request,
  97                    int reqlen)
  98 {
  99         int j;
 100         int qbase = priv->qbase;
 101         j = 0;
 102         if (phase & 1) {        /* in */
 103 #if QL_TURBO_PDMA
 104                 rtrc(4)
 105                 /* empty fifo in large chunks */
 106                 if (reqlen >= 128 && (inb(qbase + 8) & 2)) {    /* full */
 107                         insl(qbase + 4, request, 32);
 108                         reqlen -= 128;
 109                         request += 128;
 110                 }
 111                 while (reqlen >= 84 && !(j & 0xc0))     /* 2/3 */
 112                         if ((j = inb(qbase + 8)) & 4)
 113                         {
 114                                 insl(qbase + 4, request, 21);
 115                                 reqlen -= 84;
 116                                 request += 84;
 117                         }
 118                 if (reqlen >= 44 && (inb(qbase + 8) & 8)) {     /* 1/3 */
 119                         insl(qbase + 4, request, 11);
 120                         reqlen -= 44;
 121                         request += 44;
 122                 }
 123 #endif
 124                 /* until both empty and int (or until reclen is 0) */
 125                 rtrc(7)
 126                 j = 0;
 127                 while (reqlen && !((j & 0x10) && (j & 0xc0)))
 128                 {
 129                         /* while bytes to receive and not empty */
 130                         j &= 0xc0;
 131                         while (reqlen && !((j = inb(qbase + 8)) & 0x10))
 132                         {
 133                                 *request++ = inb(qbase + 4);
 134                                 reqlen--;
 135                         }
 136                         if (j & 0x10)
 137                                 j = inb(qbase + 8);
 138
 139                 }
 140         } else {                /* out */
 141 #if QL_TURBO_PDMA
 142                 rtrc(4)
 143                 if (reqlen >= 128 && inb(qbase + 8) & 0x10) {   /* empty */
 144                         outsl(qbase + 4, request, 32);
 145                         reqlen -= 128;
 146                         request += 128;
 147                 }
 148                 while (reqlen >= 84 && !(j & 0xc0))     /* 1/3 */
 149                         if (!((j = inb(qbase + 8)) & 8)) {
 150                                 outsl(qbase + 4, request, 21);
 151                                 reqlen -= 84;
 152                                 request += 84;
 153                         }
 154                 if (reqlen >= 40 && !(inb(qbase + 8) & 4)) {    /* 2/3 */
 155                         outsl(qbase + 4, request, 10);
 156                         reqlen -= 40;
 157                         request += 40;
 158                 }
 159 #endif
 160                 /* until full and int (or until reclen is 0) */
 161                 rtrc(7)
 162                     j = 0;
 163                 while (reqlen && !((j & 2) && (j & 0xc0))) {
 164                         /* while bytes to send and not full */
 165                         while (reqlen && !((j = inb(qbase + 8)) & 2))
 166                         {
 167                                 outb(*request++, qbase + 4);
 168                                 reqlen--;
 169                         }
 170                         if (j & 2)
 171                                 j = inb(qbase + 8);
 172                 }
 173         }
 174         /* maybe return reqlen */
 175         return inb(qbase + 8) & 0xc0;
 176 }
 177
 178 /*
 179  *      Wait for interrupt flag (polled - not real hardware interrupt)
 180  */
 181
 182 static int ql_wai(struct qlogicfas408_priv *priv)
 183 {
 184         int k;
 185         int qbase = priv->qbase;
 186         unsigned long i;
 187
 188         k = 0;
 189         i = jiffies + WATCHDOG;
 190         while (time_before(jiffies, i) && !priv->qabort &&
 191                                         !((k = inb(qbase + 4)) & 0xe0)) {
 192                 barrier();
 193                 cpu_relax();
 194         }
 195         if (time_after_eq(jiffies, i))
 196                 return (DID_TIME_OUT);
 197         if (priv->qabort)
 198                 return (priv->qabort == 1 ? DID_ABORT : DID_RESET);
 199         if (k & 0x60)
 200                 ql_zap(priv);
 201         if (k & 0x20)
 202                 return (DID_PARITY);
 203         if (k & 0x40)
 204                 return (DID_ERROR);
 205         return 0;
 206 }
 207
 208 /*
 209  *      Initiate scsi command - queueing handler
 210  *      caller must hold host lock
 211  */
 212
 213 static void ql_icmd(struct scsi_cmnd *cmd)
 214 {
 215         struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
 216         int     qbase = priv->qbase;
 217         int     int_type = priv->int_type;
 218         unsigned int i;
 219
 220         priv->qabort = 0;
 221
 222         REG0;
 223         /* clearing of interrupts and the fifo is needed */
 224
 225         inb(qbase + 5);         /* clear interrupts */
 226         if (inb(qbase + 5))     /* if still interrupting */
 227                 outb(2, qbase + 3);     /* reset chip */
 228         else if (inb(qbase + 7) & 0x1f)
 229                 outb(1, qbase + 3);     /* clear fifo */
 230         while (inb(qbase + 5)); /* clear ints */
 231         REG1;
 232         outb(1, qbase + 8);     /* set for PIO pseudo DMA */
 233         outb(0, qbase + 0xb);   /* disable ints */
 234         inb(qbase + 8);         /* clear int bits */
 235         REG0;
 236         outb(0x40, qbase + 0xb);        /* enable features */
 237
 238         /* configurables */
 239         outb(qlcfgc, qbase + 0xc);
 240         /* config: no reset interrupt, (initiator) bus id */
 241         outb(0x40 | qlcfg8 | priv->qinitid, qbase + 8);
 242         outb(qlcfg7, qbase + 7);
 243         outb(qlcfg6, qbase + 6);
 244         outb(qlcfg5, qbase + 5);        /* select timer */
 245         outb(qlcfg9 & 7, qbase + 9);    /* prescaler */
 246 /*      outb(0x99, qbase + 5);  */
 247         outb(scmd_id(cmd), qbase + 4);
 248
 249         for (i = 0; i < cmd->cmd_len; i++)
 250                 outb(cmd->cmnd[i], qbase + 2);
 251
 252         priv->qlcmd = cmd;
 253         outb(0x41, qbase + 3);  /* select and send command */
 254 }
 255
 256 /*
 257  *      Process scsi command - usually after interrupt
 258  */
 259
 260 static void ql_pcmd(struct scsi_cmnd *cmd)
 261 {
 262         unsigned int i, j;
 263         unsigned long k;
 264         unsigned int status;    /* scsi returned status */
 265         unsigned int message;   /* scsi returned message */
 266         unsigned int phase;     /* recorded scsi phase */
 267         unsigned int reqlen;    /* total length of transfer */
 268         char *buf;
 269         struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
 270         int qbase = priv->qbase;
 271         int int_type = priv->int_type;
 272
 273         rtrc(1)
 274         j = inb(qbase + 6);
 275         i = inb(qbase + 5);
 276         if (i == 0x20) {
 277                 set_host_byte(cmd, DID_NO_CONNECT);
 278                 return;
 279         }
 280         i |= inb(qbase + 5);    /* the 0x10 bit can be set after the 0x08 */
 281         if (i != 0x18) {
 282                 printk(KERN_ERR "Ql:Bad Interrupt status:%02x\n", i);
 283                 ql_zap(priv);
 284                 set_host_byte(cmd, DID_BAD_INTR);
 285                 return;
 286         }
 287         j &= 7;                 /* j = inb( qbase + 7 ) >> 5; */
 288
 289         /* correct status is supposed to be step 4 */
 290         /* it sometimes returns step 3 but with 0 bytes left to send */
 291         /* We can try stuffing the FIFO with the max each time, but we will get a
 292            sequence of 3 if any bytes are left (but we do flush the FIFO anyway */
 293
 294         if (j != 3 && j != 4) {
 295                 printk(KERN_ERR "Ql:Bad sequence for command %d, int %02X, cmdleft = %d\n",
 296                      j, i, inb(qbase + 7) & 0x1f);
 297                 ql_zap(priv);
 298                 set_host_byte(cmd, DID_ERROR);
 299                 return;
 300         }
 301
 302         if (inb(qbase + 7) & 0x1f)      /* if some bytes in fifo */
 303                 outb(1, qbase + 3);     /* clear fifo */
 304         /* note that request_bufflen is the total xfer size when sg is used */
 305         reqlen = scsi_bufflen(cmd);
 306         /* note that it won't work if transfers > 16M are requested */
 307         if (reqlen && !((phase = inb(qbase + 4)) & 6)) {        /* data phase */
 308                 struct scatterlist *sg;
 309                 rtrc(2)
 310                 outb(reqlen, qbase);    /* low-mid xfer cnt */
 311                 outb(reqlen >> 8, qbase + 1);   /* low-mid xfer cnt */
 312                 outb(reqlen >> 16, qbase + 0xe);        /* high xfer cnt */
 313                 outb(0x90, qbase + 3);  /* command do xfer */
 314                 /* PIO pseudo DMA to buffer or sglist */
 315                 REG1;
 316
 317                 scsi_for_each_sg(cmd, sg, scsi_sg_count(cmd), i) {
 318                         if (priv->qabort) {
 319                                 REG0;
 320                                 set_host_byte(cmd,
 321                                               priv->qabort == 1 ?
 322                                               DID_ABORT : DID_RESET);
 323                         }
 324                         buf = sg_virt(sg);
 325                         if (ql_pdma(priv, phase, buf, sg->length))
 326                                 break;
 327                 }
 328                 REG0;
 329                 rtrc(2);
 330                 /*
 331                  *      Wait for irq (split into second state of irq handler
 332                  *      if this can take time)
 333                  */
 334                 if ((k = ql_wai(priv))) {
 335                         set_host_byte(cmd, k);
 336                         return;
 337                 }
 338                 k = inb(qbase + 5);     /* should be 0x10, bus service */
 339         }
 340
 341         /*
 342          *      Enter Status (and Message In) Phase
 343          */
 344
 345         k = jiffies + WATCHDOG;
 346
 347         while (time_before(jiffies, k) && !priv->qabort &&
 348                                                 !(inb(qbase + 4) & 6))
 349                 cpu_relax();    /* wait for status phase */
 350
 351         if (time_after_eq(jiffies, k)) {
 352                 ql_zap(priv);
 353                 set_host_byte(cmd, DID_TIME_OUT);
 354                 return;
 355         }
 356
 357         /* FIXME: timeout ?? */
 358         while (inb(qbase + 5))
 359                 cpu_relax();    /* clear pending ints */
 360
 361         if (priv->qabort) {
 362                 set_host_byte(cmd,
 363                               priv->qabort == 1 ? DID_ABORT : DID_RESET);
 364                 return;
 365         }
 366
 367         outb(0x11, qbase + 3);  /* get status and message */
 368         if ((k = ql_wai(priv))) {
 369                 set_host_byte(cmd, k);
 370                 return;
 371         }
 372         i = inb(qbase + 5);     /* get chip irq stat */
 373         j = inb(qbase + 7) & 0x1f;      /* and bytes rec'd */
 374         status = inb(qbase + 2);
 375         message = inb(qbase + 2);
 376
 377         /*
 378          *      Should get function complete int if Status and message, else
 379          *      bus serv if only status
 380          */
 381         if (!((i == 8 && j == 2) || (i == 0x10 && j == 1))) {
 382                 printk(KERN_ERR "Ql:Error during status phase, int=%02X, %d bytes recd\n", i, j);
 383                 set_host_byte(cmd, DID_ERROR);
 384         }
 385         outb(0x12, qbase + 3);  /* done, disconnect */
 386         rtrc(1);
 387         if ((k = ql_wai(priv))) {
 388                 set_host_byte(cmd, k);
 389                 return;
 390         }
 391
 392         /*
 393          *      Should get bus service interrupt and disconnect interrupt
 394          */
 395
 396         i = inb(qbase + 5);     /* should be bus service */
 397         while (!priv->qabort && ((i & 0x20) != 0x20)) {
 398                 barrier();
 399                 cpu_relax();
 400                 i |= inb(qbase + 5);
 401         }
 402         rtrc(0);
 403
 404         if (priv->qabort) {
 405                 set_host_byte(cmd,
 406                               priv->qabort == 1 ? DID_ABORT : DID_RESET);
 407                 return;
 408         }
 409
 410         set_host_byte(cmd, DID_OK);
 411         if (message != COMMAND_COMPLETE)
 412                 scsi_msg_to_host_byte(cmd, message);
 413         set_status_byte(cmd, status);
 414         return;
 415 }
 416
 417 /*
 418  *      Interrupt handler
 419  */
 420
 421 static void ql_ihandl(void *dev_id)
 422 {
 423         struct scsi_cmnd *icmd;
 424         struct Scsi_Host *host = dev_id;
 425         struct qlogicfas408_priv *priv = get_priv_by_host(host);
 426         int qbase = priv->qbase;
 427         REG0;
 428
 429         if (!(inb(qbase + 4) & 0x80))   /* false alarm? */
 430                 return;
 431
 432         if (priv->qlcmd == NULL) {      /* no command to process? */
 433                 int i;
 434                 i = 16;
 435                 while (i-- && inb(qbase + 5));  /* maybe also ql_zap() */
 436                 return;
 437         }
 438         icmd = priv->qlcmd;
 439         ql_pcmd(icmd);
 440         priv->qlcmd = NULL;
 441         /*
 442          *      If result is CHECK CONDITION done calls qcommand to request
 443          *      sense
 444          */
 445         (icmd->scsi_done) (icmd);
 446 }
 447
 448 irqreturn_t qlogicfas408_ihandl(int irq, void *dev_id)
 449 {
 450         unsigned long flags;
 451         struct Scsi_Host *host = dev_id;
 452
 453         spin_lock_irqsave(host->host_lock, flags);
 454         ql_ihandl(dev_id);
 455         spin_unlock_irqrestore(host->host_lock, flags);
 456         return IRQ_HANDLED;
 457 }
 458
 459 /*
 460  *      Queued command
 461  */
 462
 463 static int qlogicfas408_queuecommand_lck(struct scsi_cmnd *cmd,
 464                               void (*done) (struct scsi_cmnd *))
 465 {
 466         struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
 467
 468         set_host_byte(cmd, DID_OK);
 469         set_status_byte(cmd, SAM_STAT_GOOD);
 470         if (scmd_id(cmd) == priv->qinitid) {
 471                 set_host_byte(cmd, DID_BAD_TARGET);
 472                 done(cmd);
 473                 return 0;
 474         }
 475
 476         cmd->scsi_done = done;
 477         /* wait for the last command's interrupt to finish */
 478         while (priv->qlcmd != NULL) {
 479                 barrier();
 480                 cpu_relax();
 481         }
 482         ql_icmd(cmd);
 483         return 0;
 484 }
 485
 486 DEF_SCSI_QCMD(qlogicfas408_queuecommand)
 487
 488 /*
 489  *      Return bios parameters
 490  */
 491
 492 int qlogicfas408_biosparam(struct scsi_device *disk, struct block_device *dev,
 493                            sector_t capacity, int ip[])
 494 {
 495 /* This should mimic the DOS Qlogic driver's behavior exactly */
 496         ip[0] = 0x40;
 497         ip[1] = 0x20;
 498         ip[2] = (unsigned long) capacity / (ip[0] * ip[1]);
 499         if (ip[2] > 1024) {
 500                 ip[0] = 0xff;
 501                 ip[1] = 0x3f;
 502                 ip[2] = (unsigned long) capacity / (ip[0] * ip[1]);
 503 #if 0
 504                 if (ip[2] > 1023)
 505                         ip[2] = 1023;
 506 #endif
 507         }
 508         return 0;
 509 }
 510
 511 /*
 512  *      Abort a command in progress
 513  */
 514
 515 int qlogicfas408_abort(struct scsi_cmnd *cmd)
 516 {
 517         struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
 518         priv->qabort = 1;
 519         ql_zap(priv);
 520         return SUCCESS;
 521 }
 522
 523 /*
 524  *      Reset SCSI bus
 525  *      FIXME: This function is invoked with cmd = NULL directly by
 526  *      the PCMCIA qlogic_stub code. This wants fixing
 527  */
 528
 529 int qlogicfas408_host_reset(struct scsi_cmnd *cmd)
 530 {
 531         struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
 532         unsigned long flags;
 533
 534         priv->qabort = 2;
 535
 536         spin_lock_irqsave(cmd->device->host->host_lock, flags);
 537         ql_zap(priv);
 538         spin_unlock_irqrestore(cmd->device->host->host_lock, flags);
 539
 540         return SUCCESS;
 541 }
 542
 543 /*
 544  *      Return info string
 545  */
 546
 547 const char *qlogicfas408_info(struct Scsi_Host *host)
 548 {
 549         struct qlogicfas408_priv *priv = get_priv_by_host(host);
 550         return priv->qinfo;
 551 }
 552
 553 /*
 554  *      Get type of chip
 555  */
 556
 557 int qlogicfas408_get_chip_type(int qbase, int int_type)
 558 {
 559         REG1;
 560         return inb(qbase + 0xe) & 0xf8;
 561 }
 562
 563 /*
 564  *      Perform initialization tasks
 565  */
 566
 567 void qlogicfas408_setup(int qbase, int id, int int_type)
 568 {
 569         outb(1, qbase + 8);     /* set for PIO pseudo DMA */
 570         REG0;
 571         outb(0x40 | qlcfg8 | id, qbase + 8);    /* (ini) bus id, disable scsi rst */
 572         outb(qlcfg5, qbase + 5);        /* select timer */
 573         outb(qlcfg9, qbase + 9);        /* prescaler */
 574
 575 #if QL_RESET_AT_START
 576         outb(3, qbase + 3);
 577
 578         REG1;
 579         /* FIXME: timeout */
 580         while (inb(qbase + 0xf) & 4)
 581                 cpu_relax();
 582
 583         REG0;
 584 #endif
 585 }
 586
 587 /*
 588  *      Checks if this is a QLogic FAS 408
 589  */
 590
 591 int qlogicfas408_detect(int qbase, int int_type)
 592 {
 593         REG1;
 594         return (((inb(qbase + 0xe) ^ inb(qbase + 0xe)) == 7) &&
 595                 ((inb(qbase + 0xe) ^ inb(qbase + 0xe)) == 7));
 596 }
 597
 598 /*
 599  *      Disable interrupts
 600  */
 601
 602 void qlogicfas408_disable_ints(struct qlogicfas408_priv *priv)
 603 {
 604         int qbase = priv->qbase;
 605         int int_type = priv->int_type;
 606
 607         REG1;
 608         outb(0, qbase + 0xb);   /* disable ints */
 609 }
 610
 611 /*
 612  *      Init and exit functions
 613  */
 614
 615 static int __init qlogicfas408_init(void)
 616 {
 617         return 0;
 618 }
 619
 620 static void __exit qlogicfas408_exit(void)
 621 {
 622
 623 }
 624
 625 MODULE_AUTHOR("Tom Zerucha, Michael Griffith");
 626 MODULE_DESCRIPTION("Driver for the Qlogic FAS SCSI controllers");
 627 MODULE_LICENSE("GPL");
 628 module_init(qlogicfas408_init);
 629 module_exit(qlogicfas408_exit);
 630
 631 EXPORT_SYMBOL(qlogicfas408_info);
 632 EXPORT_SYMBOL(qlogicfas408_queuecommand);
 633 EXPORT_SYMBOL(qlogicfas408_abort);
 634 EXPORT_SYMBOL(qlogicfas408_host_reset);
 635 EXPORT_SYMBOL(qlogicfas408_biosparam);
 636 EXPORT_SYMBOL(qlogicfas408_ihandl);
 637 EXPORT_SYMBOL(qlogicfas408_get_chip_type);
 638 EXPORT_SYMBOL(qlogicfas408_setup);
 639 EXPORT_SYMBOL(qlogicfas408_detect);
 640 EXPORT_SYMBOL(qlogicfas408_disable_ints);
 641