drivers/scsi/aha1740.c

   1 /*  $Id$
   2  *  1993/03/31
   3  *  linux/kernel/aha1740.c
   4  *
   5  *  Based loosely on aha1542.c which is
   6  *  Copyright (C) 1992  Tommy Thorn and
   7  *  Modified by Eric Youngdale
   8  *
   9  *  This file is aha1740.c, written and
  10  *  Copyright (C) 1992,1993  Brad McLean
  11  *  brad@saturn.gaylord.com or brad@bradpc.gaylord.com.
  12  *
  13  *  Modifications to makecode and queuecommand
  14  *  for proper handling of multiple devices courteously
  15  *  provided by Michael Weller, March, 1993
  16  *
  17  *  Multiple adapter support, extended translation detection,
  18  *  update to current scsi subsystem changes, proc fs support,
  19  *  working (!) module support based on patches from Andreas Arens,
  20  *  by Andreas Degert <ad@papyrus.hamburg.com>, 2/1997
  21  *
  22  * aha1740_makecode may still need even more work
  23  * if it doesn't work for your devices, take a look.
  24  *
  25  * Reworked for new_eh and new locking by Alan Cox <alan@redhat.com>
  26  *
  27  * Converted to EISA and generic DMA APIs by Marc Zyngier
  28  * <maz@wild-wind.fr.eu.org>, 4/2003.
  29  *
  30  * Shared interrupt support added by Rask Ingemann Lambertsen
  31  * <rask@sygehus.dk>, 10/2003
  32  *
  33  * For the avoidance of doubt the "preferred form" of this code is one which
  34  * is in an open non patent encumbered format. Where cryptographic key signing
  35  * forms part of the process of creating an executable the information
  36  * including keys needed to generate an equivalently functional executable
  37  * are deemed to be part of the source code.
  38  */
  39
  40 #include <linux/blkdev.h>
  41 #include <linux/interrupt.h>
  42 #include <linux/module.h>
  43 #include <linux/kernel.h>
  44 #include <linux/types.h>
  45 #include <linux/string.h>
  46 #include <linux/ioport.h>
  47 #include <linux/proc_fs.h>
  48 #include <linux/stat.h>
  49 #include <linux/init.h>
  50 #include <linux/device.h>
  51 #include <linux/eisa.h>
  52 #include <linux/dma-mapping.h>
  53
  54 #include <asm/dma.h>
  55 #include <asm/system.h>
  56 #include <asm/io.h>
  57
  58 #include "scsi.h"
  59 #include <scsi/scsi_host.h>
  60 #include "aha1740.h"
  61
  62 /* IF YOU ARE HAVING PROBLEMS WITH THIS DRIVER, AND WANT TO WATCH
  63    IT WORK, THEN:
  64 #define DEBUG
  65 */
  66 #ifdef DEBUG
  67 #define DEB(x) x
  68 #else
  69 #define DEB(x)
  70 #endif
  71
  72 struct aha1740_hostdata {
  73         struct eisa_device *edev;
  74         unsigned int translation;
  75         unsigned int last_ecb_used;
  76         dma_addr_t ecb_dma_addr;
  77         struct ecb ecb[AHA1740_ECBS];
  78 };
  79
  80 struct aha1740_sg {
  81         struct aha1740_chain sg_chain[AHA1740_SCATTER];
  82         dma_addr_t sg_dma_addr;
  83         dma_addr_t buf_dma_addr;
  84 };
  85
  86 #define HOSTDATA(host) ((struct aha1740_hostdata *) &host->hostdata)
  87
  88 static inline struct ecb *ecb_dma_to_cpu (struct Scsi_Host *host,
  89                                           dma_addr_t dma)
  90 {
  91         struct aha1740_hostdata *hdata = HOSTDATA (host);
  92         dma_addr_t offset;
  93
  94         offset = dma - hdata->ecb_dma_addr;
  95
  96         return (struct ecb *)(((char *) hdata->ecb) + (unsigned int) offset);
  97 }
  98
  99 static inline dma_addr_t ecb_cpu_to_dma (struct Scsi_Host *host, void *cpu)
 100 {
 101         struct aha1740_hostdata *hdata = HOSTDATA (host);
 102         dma_addr_t offset;
 103
 104         offset = (char *) cpu - (char *) hdata->ecb;
 105
 106         return hdata->ecb_dma_addr + offset;
 107 }
 108
 109 static int aha1740_proc_info(struct Scsi_Host *shpnt, char *buffer,
 110                              char **start, off_t offset,
 111                              int length, int inout)
 112 {
 113         int len;
 114         struct aha1740_hostdata *host;
 115
 116         if (inout)
 117                 return-ENOSYS;
 118
 119         host = HOSTDATA(shpnt);
 120
 121         len = sprintf(buffer, "aha174x at IO:%lx, IRQ %d, SLOT %d.\n"
 122                       "Extended translation %sabled.\n",
 123                       shpnt->io_port, shpnt->irq, host->edev->slot,
 124                       host->translation ? "en" : "dis");
 125
 126         if (offset > len) {
 127                 *start = buffer;
 128                 return 0;
 129         }
 130
 131         *start = buffer + offset;
 132         len -= offset;
 133         if (len > length)
 134                 len = length;
 135         return len;
 136 }
 137
 138 static int aha1740_makecode(unchar *sense, unchar *status)
 139 {
 140         struct statusword
 141         {
 142                 ushort  don:1,  /* Command Done - No Error */
 143                         du:1,   /* Data underrun */
 144                     :1, qf:1,   /* Queue full */
 145                         sc:1,   /* Specification Check */
 146                         dor:1,  /* Data overrun */
 147                         ch:1,   /* Chaining Halted */
 148                         intr:1, /* Interrupt issued */
 149                         asa:1,  /* Additional Status Available */
 150                         sns:1,  /* Sense information Stored */
 151                     :1, ini:1,  /* Initialization Required */
 152                         me:1,   /* Major error or exception */
 153                     :1, eca:1,  /* Extended Contingent alliance */
 154                     :1;
 155         } status_word;
 156         int retval = DID_OK;
 157
 158         status_word = * (struct statusword *) status;
 159 #ifdef DEBUG
 160         printk("makecode from %x,%x,%x,%x %x,%x,%x,%x",
 161                status[0], status[1], status[2], status[3],
 162                sense[0], sense[1], sense[2], sense[3]);
 163 #endif
 164         if (!status_word.don) { /* Anything abnormal was detected */
 165                 if ( (status[1]&0x18) || status_word.sc ) {
 166                         /*Additional info available*/
 167                         /* Use the supplied info for further diagnostics */
 168                         switch ( status[2] ) {
 169                         case 0x12:
 170                                 if ( status_word.dor )
 171                                         retval=DID_ERROR; /* It's an Overrun */
 172                                 /* If not overrun, assume underrun and
 173                                  * ignore it! */
 174                         case 0x00: /* No info, assume no error, should
 175                                     * not occur */
 176                                 break;
 177                         case 0x11:
 178                         case 0x21:
 179                                 retval=DID_TIME_OUT;
 180                                 break;
 181                         case 0x0a:
 182                                 retval=DID_BAD_TARGET;
 183                                 break;
 184                         case 0x04:
 185                         case 0x05:
 186                                 retval=DID_ABORT;
 187                                 /* Either by this driver or the
 188                                  * AHA1740 itself */
 189                                 break;
 190                         default:
 191                                 retval=DID_ERROR; /* No further
 192                                                    * diagnostics
 193                                                    * possible */
 194                         }
 195                 } else {
 196                         /* Michael suggests, and Brad concurs: */
 197                         if ( status_word.qf ) {
 198                                 retval = DID_TIME_OUT; /* forces a redo */
 199                                 /* I think this specific one should
 200                                  * not happen -Brad */
 201                                 printk("aha1740.c: WARNING: AHA1740 queue overflow!\n");
 202                         } else
 203                                 if ( status[0]&0x60 ) {
 204                                          /* Didn't find a better error */
 205                                         retval = DID_ERROR;
 206                                 }
 207                         /* In any other case return DID_OK so for example
 208                            CONDITION_CHECKS make it through to the appropriate
 209                            device driver */
 210                 }
 211         }
 212         /* Under all circumstances supply the target status -Michael */
 213         return status[3] | retval << 16;
 214 }
 215
 216 static int aha1740_test_port(unsigned int base)
 217 {
 218         if ( inb(PORTADR(base)) & PORTADDR_ENH )
 219                 return 1;   /* Okay, we're all set */
 220
 221         printk("aha174x: Board detected, but not in enhanced mode, so disabled it.\n");
 222         return 0;
 223 }
 224
 225 /* A "high" level interrupt handler */
 226 static irqreturn_t aha1740_intr_handle(int irq, void *dev_id,
 227                                        struct pt_regs *regs)
 228 {
 229         struct Scsi_Host *host = (struct Scsi_Host *) dev_id;
 230         void (*my_done)(Scsi_Cmnd *);
 231         int errstatus, adapstat;
 232         int number_serviced;
 233         struct ecb *ecbptr;
 234         Scsi_Cmnd *SCtmp;
 235         unsigned int base;
 236         unsigned long flags;
 237         int handled = 0;
 238         struct aha1740_sg *sgptr;
 239         struct eisa_device *edev;
 240
 241         if (!host)
 242                 panic("aha1740.c: Irq from unknown host!\n");
 243         spin_lock_irqsave(host->host_lock, flags);
 244         base = host->io_port;
 245         number_serviced = 0;
 246         edev = HOSTDATA(host)->edev;
 247
 248         while(inb(G2STAT(base)) & G2STAT_INTPEND) {
 249                 handled = 1;
 250                 DEB(printk("aha1740_intr top of loop.\n"));
 251                 adapstat = inb(G2INTST(base));
 252                 ecbptr = ecb_dma_to_cpu (host, inl(MBOXIN0(base)));
 253                 outb(G2CNTRL_IRST,G2CNTRL(base)); /* interrupt reset */
 254
 255                 switch ( adapstat & G2INTST_MASK ) {
 256                 case    G2INTST_CCBRETRY:
 257                 case    G2INTST_CCBERROR:
 258                 case    G2INTST_CCBGOOD:
 259                         /* Host Ready -> Mailbox in complete */
 260                         outb(G2CNTRL_HRDY,G2CNTRL(base));
 261                         if (!ecbptr) {
 262                                 printk("Aha1740 null ecbptr in interrupt (%x,%x,%x,%d)\n",
 263                                        inb(G2STAT(base)),adapstat,
 264                                        inb(G2INTST(base)), number_serviced++);
 265                                 continue;
 266                         }
 267                         SCtmp = ecbptr->SCpnt;
 268                         if (!SCtmp) {
 269                                 printk("Aha1740 null SCtmp in interrupt (%x,%x,%x,%d)\n",
 270                                        inb(G2STAT(base)),adapstat,
 271                                        inb(G2INTST(base)), number_serviced++);
 272                                 continue;
 273                         }
 274                         sgptr = (struct aha1740_sg *) SCtmp->host_scribble;
 275                         if (SCtmp->use_sg) {
 276                                 /* We used scatter-gather.
 277                                    Do the unmapping dance. */
 278                                 dma_unmap_sg (&edev->dev,
 279                                               (struct scatterlist *) SCtmp->request_buffer,
 280                                               SCtmp->use_sg,
 281                                               SCtmp->sc_data_direction);
 282                         } else {
 283                                 dma_unmap_single (&edev->dev,
 284                                                   sgptr->buf_dma_addr,
 285                                                   SCtmp->request_bufflen,
 286                                                   DMA_BIDIRECTIONAL);
 287                         }
 288
 289                         /* Free the sg block */
 290                         dma_free_coherent (&edev->dev,
 291                                            sizeof (struct aha1740_sg),
 292                                            SCtmp->host_scribble,
 293                                            sgptr->sg_dma_addr);
 294
 295                         /* Fetch the sense data, and tuck it away, in
 296                            the required slot.  The Adaptec
 297                            automatically fetches it, and there is no
 298                            guarantee that we will still have it in the
 299                            cdb when we come back */
 300                         if ( (adapstat & G2INTST_MASK) == G2INTST_CCBERROR ) {
 301                                 memcpy(SCtmp->sense_buffer, ecbptr->sense,
 302                                        sizeof(SCtmp->sense_buffer));
 303                                 errstatus = aha1740_makecode(ecbptr->sense,ecbptr->status);
 304                         } else
 305                                 errstatus = 0;
 306                         DEB(if (errstatus)
 307                             printk("aha1740_intr_handle: returning %6x\n",
 308                                    errstatus));
 309                         SCtmp->result = errstatus;
 310                         my_done = ecbptr->done;
 311                         memset(ecbptr,0,sizeof(struct ecb));
 312                         if ( my_done )
 313                                 my_done(SCtmp);
 314                         break;
 315
 316                 case    G2INTST_HARDFAIL:
 317                         printk(KERN_ALERT "aha1740 hardware failure!\n");
 318                         panic("aha1740.c");     /* Goodbye */
 319
 320                 case    G2INTST_ASNEVENT:
 321                         printk("aha1740 asynchronous event: %02x %02x %02x %02x %02x\n",
 322                                adapstat,
 323                                inb(MBOXIN0(base)),
 324                                inb(MBOXIN1(base)),
 325                                inb(MBOXIN2(base)),
 326                                inb(MBOXIN3(base))); /* Say What? */
 327                         /* Host Ready -> Mailbox in complete */
 328                         outb(G2CNTRL_HRDY,G2CNTRL(base));
 329                         break;
 330
 331                 case    G2INTST_CMDGOOD:
 332                         /* set immediate command success flag here: */
 333                         break;
 334
 335                 case    G2INTST_CMDERROR:
 336                         /* Set immediate command failure flag here: */
 337                         break;
 338                 }
 339                 number_serviced++;
 340         }
 341
 342         spin_unlock_irqrestore(host->host_lock, flags);
 343         return IRQ_RETVAL(handled);
 344 }
 345
 346 static int aha1740_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
 347 {
 348         unchar direction;
 349         unchar *cmd = (unchar *) SCpnt->cmnd;
 350         unchar target = SCpnt->device->id;
 351         struct aha1740_hostdata *host = HOSTDATA(SCpnt->device->host);
 352         unsigned long flags;
 353         void *buff = SCpnt->request_buffer;
 354         int bufflen = SCpnt->request_bufflen;
 355         dma_addr_t sg_dma;
 356         struct aha1740_sg *sgptr;
 357         int ecbno;
 358         DEB(int i);
 359
 360         if(*cmd == REQUEST_SENSE) {
 361                 SCpnt->result = 0;
 362                 done(SCpnt);
 363                 return 0;
 364         }
 365
 366 #ifdef DEBUG
 367         if (*cmd == READ_10 || *cmd == WRITE_10)
 368                 i = xscsi2int(cmd+2);
 369         else if (*cmd == READ_6 || *cmd == WRITE_6)
 370                 i = scsi2int(cmd+2);
 371         else
 372                 i = -1;
 373         printk("aha1740_queuecommand: dev %d cmd %02x pos %d len %d ",
 374                target, *cmd, i, bufflen);
 375         printk("scsi cmd:");
 376         for (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
 377         printk("\n");
 378 #endif
 379
 380         /* locate an available ecb */
 381         spin_lock_irqsave(SCpnt->device->host->host_lock, flags);
 382         ecbno = host->last_ecb_used + 1; /* An optimization */
 383         if (ecbno >= AHA1740_ECBS)
 384                 ecbno = 0;
 385         do {
 386                 if (!host->ecb[ecbno].cmdw)
 387                         break;
 388                 ecbno++;
 389                 if (ecbno >= AHA1740_ECBS)
 390                         ecbno = 0;
 391         } while (ecbno != host->last_ecb_used);
 392
 393         if (host->ecb[ecbno].cmdw)
 394                 panic("Unable to find empty ecb for aha1740.\n");
 395
 396         host->ecb[ecbno].cmdw = AHA1740CMD_INIT; /* SCSI Initiator Command
 397                                                     doubles as reserved flag */
 398
 399         host->last_ecb_used = ecbno;
 400         spin_unlock_irqrestore(SCpnt->device->host->host_lock, flags);
 401
 402 #ifdef DEBUG
 403         printk("Sending command (%d %x)...", ecbno, done);
 404 #endif
 405
 406         host->ecb[ecbno].cdblen = SCpnt->cmd_len; /* SCSI Command
 407                                                    * Descriptor Block
 408                                                    * Length */
 409
 410         direction = 0;
 411         if (*cmd == READ_10 || *cmd == READ_6)
 412                 direction = 1;
 413         else if (*cmd == WRITE_10 || *cmd == WRITE_6)
 414                 direction = 0;
 415
 416         memcpy(host->ecb[ecbno].cdb, cmd, SCpnt->cmd_len);
 417
 418         SCpnt->host_scribble = dma_alloc_coherent (&host->edev->dev,
 419                                                    sizeof (struct aha1740_sg),
 420                                                    &sg_dma, GFP_ATOMIC);
 421         if(SCpnt->host_scribble == NULL) {
 422                 printk(KERN_WARNING "aha1740: out of memory in queuecommand!\n");
 423                 return 1;
 424         }
 425         sgptr = (struct aha1740_sg *) SCpnt->host_scribble;
 426         sgptr->sg_dma_addr = sg_dma;
 427
 428         if (SCpnt->use_sg) {
 429                 struct scatterlist * sgpnt;
 430                 struct aha1740_chain * cptr;
 431                 int i, count;
 432                 DEB(unsigned char * ptr);
 433
 434                 host->ecb[ecbno].sg = 1;  /* SCSI Initiator Command
 435                                            * w/scatter-gather*/
 436                 sgpnt = (struct scatterlist *) SCpnt->request_buffer;
 437                 cptr = sgptr->sg_chain;
 438                 count = dma_map_sg (&host->edev->dev, sgpnt, SCpnt->use_sg,
 439                                     SCpnt->sc_data_direction);
 440                 for(i=0; i < count; i++) {
 441                         cptr[i].datalen = sg_dma_len (sgpnt + i);
 442                         cptr[i].dataptr = sg_dma_address (sgpnt + i);
 443                 }
 444                 host->ecb[ecbno].datalen = count*sizeof(struct aha1740_chain);
 445                 host->ecb[ecbno].dataptr = sg_dma;
 446 #ifdef DEBUG
 447                 printk("cptr %x: ",cptr);
 448                 ptr = (unsigned char *) cptr;
 449                 for(i=0;i<24;i++) printk("%02x ", ptr[i]);
 450 #endif
 451         } else {
 452                 host->ecb[ecbno].datalen = bufflen;
 453                 sgptr->buf_dma_addr =  dma_map_single (&host->edev->dev,
 454                                                        buff, bufflen,
 455                                                        DMA_BIDIRECTIONAL);
 456                 host->ecb[ecbno].dataptr = sgptr->buf_dma_addr;
 457         }
 458         host->ecb[ecbno].lun = SCpnt->device->lun;
 459         host->ecb[ecbno].ses = 1; /* Suppress underrun errors */
 460         host->ecb[ecbno].dir = direction;
 461         host->ecb[ecbno].ars = 1; /* Yes, get the sense on an error */
 462         host->ecb[ecbno].senselen = 12;
 463         host->ecb[ecbno].senseptr = ecb_cpu_to_dma (SCpnt->device->host,
 464                                                     host->ecb[ecbno].sense);
 465         host->ecb[ecbno].statusptr = ecb_cpu_to_dma (SCpnt->device->host,
 466                                                      host->ecb[ecbno].status);
 467         host->ecb[ecbno].done = done;
 468         host->ecb[ecbno].SCpnt = SCpnt;
 469 #ifdef DEBUG
 470         {
 471                 int i;
 472                 printk("aha1740_command: sending.. ");
 473                 for (i = 0; i < sizeof(host->ecb[ecbno]) - 10; i++)
 474                         printk("%02x ", ((unchar *)&host->ecb[ecbno])[i]);
 475         }
 476         printk("\n");
 477 #endif
 478         if (done) {
 479         /* The Adaptec Spec says the card is so fast that the loops
 480            will only be executed once in the code below. Even if this
 481            was true with the fastest processors when the spec was
 482            written, it doesn't seem to be true with todays fast
 483            processors. We print a warning if the code is executed more
 484            often than LOOPCNT_WARN. If this happens, it should be
 485            investigated. If the count reaches LOOPCNT_MAX, we assume
 486            something is broken; since there is no way to return an
 487            error (the return value is ignored by the mid-level scsi
 488            layer) we have to panic (and maybe that's the best thing we
 489            can do then anyhow). */
 490
 491 #define LOOPCNT_WARN 10         /* excessive mbxout wait -> syslog-msg */
 492 #define LOOPCNT_MAX 1000000     /* mbxout deadlock -> panic() after ~ 2 sec. */
 493                 int loopcnt;
 494                 unsigned int base = SCpnt->device->host->io_port;
 495                 DEB(printk("aha1740[%d] critical section\n",ecbno));
 496
 497                 spin_lock_irqsave(SCpnt->device->host->host_lock, flags);
 498                 for (loopcnt = 0; ; loopcnt++) {
 499                         if (inb(G2STAT(base)) & G2STAT_MBXOUT) break;
 500                         if (loopcnt == LOOPCNT_WARN) {
 501                                 printk("aha1740[%d]_mbxout wait!\n",ecbno);
 502                         }
 503                         if (loopcnt == LOOPCNT_MAX)
 504                                 panic("aha1740.c: mbxout busy!\n");
 505                 }
 506                 outl (ecb_cpu_to_dma (SCpnt->device->host, host->ecb + ecbno),
 507                       MBOXOUT0(base));
 508                 for (loopcnt = 0; ; loopcnt++) {
 509                         if (! (inb(G2STAT(base)) & G2STAT_BUSY)) break;
 510                         if (loopcnt == LOOPCNT_WARN) {
 511                                 printk("aha1740[%d]_attn wait!\n",ecbno);
 512                         }
 513                         if (loopcnt == LOOPCNT_MAX)
 514                                 panic("aha1740.c: attn wait failed!\n");
 515                 }
 516                 outb(ATTN_START | (target & 7), ATTN(base)); /* Start it up */
 517                 spin_unlock_irqrestore(SCpnt->device->host->host_lock, flags);
 518                 DEB(printk("aha1740[%d] request queued.\n",ecbno));
 519         } else
 520                 printk(KERN_ALERT "aha1740_queuecommand: done can't be NULL\n");
 521         return 0;
 522 }
 523
 524 /* Query the board for its irq_level and irq_type.  Nothing else matters
 525    in enhanced mode on an EISA bus. */
 526
 527 static void aha1740_getconfig(unsigned int base, unsigned int *irq_level,
 528                               unsigned int *irq_type,
 529                               unsigned int *translation)
 530 {
 531         static int intab[] = { 9, 10, 11, 12, 0, 14, 15, 0 };
 532
 533         *irq_level = intab[inb(INTDEF(base)) & 0x7];
 534         *irq_type  = (inb(INTDEF(base)) & 0x8) >> 3;
 535         *translation = inb(RESV1(base)) & 0x1;
 536         outb(inb(INTDEF(base)) | 0x10, INTDEF(base));
 537 }
 538
 539 static int aha1740_biosparam(struct scsi_device *sdev,
 540                              struct block_device *dev,
 541                              sector_t capacity, int* ip)
 542 {
 543         int size = capacity;
 544         int extended = HOSTDATA(sdev->host)->translation;
 545
 546         DEB(printk("aha1740_biosparam\n"));
 547         if (extended && (ip[2] > 1024)) {
 548                 ip[0] = 255;
 549                 ip[1] = 63;
 550                 ip[2] = size / (255 * 63);
 551         } else {
 552                 ip[0] = 64;
 553                 ip[1] = 32;
 554                 ip[2] = size >> 11;
 555         }
 556         return 0;
 557 }
 558
 559 static int aha1740_eh_abort_handler (Scsi_Cmnd *dummy)
 560 {
 561 /*
 562  * From Alan Cox :
 563  * The AHA1740 has firmware handled abort/reset handling. The "head in
 564  * sand" kernel code is correct for once 8)
 565  *
 566  * So we define a dummy handler just to keep the kernel SCSI code as
 567  * quiet as possible...
 568  */
 569
 570         return 0;
 571 }
 572
 573 static Scsi_Host_Template aha1740_template = {
 574         .module           = THIS_MODULE,
 575         .proc_name        = "aha1740",
 576         .proc_info        = aha1740_proc_info,
 577         .name             = "Adaptec 174x (EISA)",
 578         .queuecommand     = aha1740_queuecommand,
 579         .bios_param       = aha1740_biosparam,
 580         .can_queue        = AHA1740_ECBS,
 581         .this_id          = 7,
 582         .sg_tablesize     = AHA1740_SCATTER,
 583         .cmd_per_lun      = AHA1740_CMDLUN,
 584         .use_clustering   = ENABLE_CLUSTERING,
 585         .eh_abort_handler = aha1740_eh_abort_handler,
 586 };
 587
 588 static int aha1740_probe (struct device *dev)
 589 {
 590         int slotbase;
 591         unsigned int irq_level, irq_type, translation;
 592         struct Scsi_Host *shpnt;
 593         struct aha1740_hostdata *host;
 594         struct eisa_device *edev = to_eisa_device (dev);
 595
 596         DEB(printk("aha1740_probe: \n"));
 597
 598         slotbase = edev->base_addr + EISA_VENDOR_ID_OFFSET;
 599         if (!request_region(slotbase, SLOTSIZE, "aha1740")) /* See if in use */
 600                 return -EBUSY;
 601         if (!aha1740_test_port(slotbase))
 602                 goto err_release_region;
 603         aha1740_getconfig(slotbase,&irq_level,&irq_type,&translation);
 604         if ((inb(G2STAT(slotbase)) &
 605              (G2STAT_MBXOUT|G2STAT_BUSY)) != G2STAT_MBXOUT) {
 606                 /* If the card isn't ready, hard reset it */
 607                 outb(G2CNTRL_HRST, G2CNTRL(slotbase));
 608                 outb(0, G2CNTRL(slotbase));
 609         }
 610         printk(KERN_INFO "Configuring slot %d at IO:%x, IRQ %u (%s)\n",
 611                edev->slot, slotbase, irq_level, irq_type ? "edge" : "level");
 612         printk(KERN_INFO "aha174x: Extended translation %sabled.\n",
 613                translation ? "en" : "dis");
 614         shpnt = scsi_host_alloc(&aha1740_template,
 615                               sizeof(struct aha1740_hostdata));
 616         if(shpnt == NULL)
 617                 goto err_release_region;
 618
 619         shpnt->base = 0;
 620         shpnt->io_port = slotbase;
 621         shpnt->n_io_port = SLOTSIZE;
 622         shpnt->irq = irq_level;
 623         shpnt->dma_channel = 0xff;
 624         host = HOSTDATA(shpnt);
 625         host->edev = edev;
 626         host->translation = translation;
 627         host->ecb_dma_addr = dma_map_single (&edev->dev, host->ecb,
 628                                              sizeof (host->ecb),
 629                                              DMA_BIDIRECTIONAL);
 630         if (!host->ecb_dma_addr) {
 631                 printk (KERN_ERR "aha1740_probe: Couldn't map ECB, giving up\n");
 632                 scsi_unregister (shpnt);
 633                 goto err_host_put;
 634         }
 635
 636         DEB(printk("aha1740_probe: enable interrupt channel %d\n",irq_level));
 637         if (request_irq(irq_level,aha1740_intr_handle,irq_type ? 0 : SA_SHIRQ,
 638                         "aha1740",shpnt)) {
 639                 printk(KERN_ERR "aha1740_probe: Unable to allocate IRQ %d.\n",
 640                        irq_level);
 641                 goto err_unmap;
 642         }
 643
 644         eisa_set_drvdata (edev, shpnt);
 645         scsi_add_host (shpnt, dev); /* XXX handle failure */
 646         scsi_scan_host (shpnt);
 647         return 0;
 648
 649  err_unmap:
 650         dma_unmap_single (&edev->dev, host->ecb_dma_addr,
 651                           sizeof (host->ecb), DMA_BIDIRECTIONAL);
 652  err_host_put:
 653         scsi_host_put (shpnt);
 654  err_release_region:
 655         release_region(slotbase, SLOTSIZE);
 656
 657         return -ENODEV;
 658 }
 659
 660 static __devexit int aha1740_remove (struct device *dev)
 661 {
 662         struct Scsi_Host *shpnt = dev->driver_data;
 663         struct aha1740_hostdata *host = HOSTDATA (shpnt);
 664
 665         scsi_remove_host(shpnt);
 666
 667         free_irq (shpnt->irq, shpnt);
 668         dma_unmap_single (dev, host->ecb_dma_addr,
 669                           sizeof (host->ecb), DMA_BIDIRECTIONAL);
 670         release_region (shpnt->io_port, SLOTSIZE);
 671
 672         scsi_host_put (shpnt);
 673
 674         return 0;
 675 }
 676
 677 static struct eisa_device_id aha1740_ids[] = {
 678         { "ADP0000" },          /* 1740  */
 679         { "ADP0001" },          /* 1740A */
 680         { "ADP0002" },          /* 1742A */
 681         { "ADP0400" },          /* 1744  */
 682         { "" }
 683 };
 684
 685 static struct eisa_driver aha1740_driver = {
 686         .id_table = aha1740_ids,
 687         .driver   = {
 688                 .name    = "aha1740",
 689                 .probe   = aha1740_probe,
 690                 .remove  = __devexit_p (aha1740_remove),
 691         },
 692 };
 693
 694 static __init int aha1740_init (void)
 695 {
 696         return eisa_driver_register (&aha1740_driver);
 697 }
 698
 699 static __exit void aha1740_exit (void)
 700 {
 701         eisa_driver_unregister (&aha1740_driver);
 702 }
 703
 704 module_init (aha1740_init);
 705 module_exit (aha1740_exit);
 706
 707 MODULE_LICENSE("GPL");