linux/drivers/scsi/sym53c8xx_2/sym_glue.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family 
   4 * of PCI-SCSI IO processors.
   5 *
   6 * Copyright (C) 1999-2001  Gerard Roudier <groudier@free.fr>
   7 * Copyright (c) 2003-2005  Matthew Wilcox <matthew@wil.cx>
   8 *
   9 * This driver is derived from the Linux sym53c8xx driver.
  10 * Copyright (C) 1998-2000  Gerard Roudier
  11 *
  12 * The sym53c8xx driver is derived from the ncr53c8xx driver that had been 
  13 * a port of the FreeBSD ncr driver to Linux-1.2.13.
  14 *
  15 * The original ncr driver has been written for 386bsd and FreeBSD by
  16 *         Wolfgang Stanglmeier        <wolf@cologne.de>
  17 *         Stefan Esser                <se@mi.Uni-Koeln.de>
  18 * Copyright (C) 1994  Wolfgang Stanglmeier
  19 *
  20 * Other major contributions:
  21 *
  22 * NVRAM detection and reading.
  23 * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk>
  24 *
  25 *-----------------------------------------------------------------------------
  26 */
  27#include <linux/ctype.h>
  28#include <linux/init.h>
  29#include <linux/module.h>
  30#include <linux/moduleparam.h>
  31#include <linux/spinlock.h>
  32#include <scsi/scsi.h>
  33#include <scsi/scsi_tcq.h>
  34#include <scsi/scsi_device.h>
  35#include <scsi/scsi_transport.h>
  36
  37#include "sym_glue.h"
  38#include "sym_nvram.h"
  39
  40#define NAME53C         "sym53c"
  41#define NAME53C8XX      "sym53c8xx"
  42
  43struct sym_driver_setup sym_driver_setup = SYM_LINUX_DRIVER_SETUP;
  44unsigned int sym_debug_flags = 0;
  45
  46static char *excl_string;
  47static char *safe_string;
  48module_param_named(cmd_per_lun, sym_driver_setup.max_tag, ushort, 0);
  49module_param_named(burst, sym_driver_setup.burst_order, byte, 0);
  50module_param_named(led, sym_driver_setup.scsi_led, byte, 0);
  51module_param_named(diff, sym_driver_setup.scsi_diff, byte, 0);
  52module_param_named(irqm, sym_driver_setup.irq_mode, byte, 0);
  53module_param_named(buschk, sym_driver_setup.scsi_bus_check, byte, 0);
  54module_param_named(hostid, sym_driver_setup.host_id, byte, 0);
  55module_param_named(verb, sym_driver_setup.verbose, byte, 0);
  56module_param_named(debug, sym_debug_flags, uint, 0);
  57module_param_named(settle, sym_driver_setup.settle_delay, byte, 0);
  58module_param_named(nvram, sym_driver_setup.use_nvram, byte, 0);
  59module_param_named(excl, excl_string, charp, 0);
  60module_param_named(safe, safe_string, charp, 0);
  61
  62MODULE_PARM_DESC(cmd_per_lun, "The maximum number of tags to use by default");
  63MODULE_PARM_DESC(burst, "Maximum burst.  0 to disable, 255 to read from registers");
  64MODULE_PARM_DESC(led, "Set to 1 to enable LED support");
  65MODULE_PARM_DESC(diff, "0 for no differential mode, 1 for BIOS, 2 for always, 3 for not GPIO3");
  66MODULE_PARM_DESC(irqm, "0 for open drain, 1 to leave alone, 2 for totem pole");
  67MODULE_PARM_DESC(buschk, "0 to not check, 1 for detach on error, 2 for warn on error");
  68MODULE_PARM_DESC(hostid, "The SCSI ID to use for the host adapters");
  69MODULE_PARM_DESC(verb, "0 for minimal verbosity, 1 for normal, 2 for excessive");
  70MODULE_PARM_DESC(debug, "Set bits to enable debugging");
  71MODULE_PARM_DESC(settle, "Settle delay in seconds.  Default 3");
  72MODULE_PARM_DESC(nvram, "Option currently not used");
  73MODULE_PARM_DESC(excl, "List ioport addresses here to prevent controllers from being attached");
  74MODULE_PARM_DESC(safe, "Set other settings to a \"safe mode\"");
  75
  76MODULE_LICENSE("GPL");
  77MODULE_VERSION(SYM_VERSION);
  78MODULE_AUTHOR("Matthew Wilcox <matthew@wil.cx>");
  79MODULE_DESCRIPTION("NCR, Symbios and LSI 8xx and 1010 PCI SCSI adapters");
  80
  81static void sym2_setup_params(void)
  82{
  83        char *p = excl_string;
  84        int xi = 0;
  85
  86        while (p && (xi < 8)) {
  87                char *next_p;
  88                int val = (int) simple_strtoul(p, &next_p, 0);
  89                sym_driver_setup.excludes[xi++] = val;
  90                p = next_p;
  91        }
  92
  93        if (safe_string) {
  94                if (*safe_string == 'y') {
  95                        sym_driver_setup.max_tag = 0;
  96                        sym_driver_setup.burst_order = 0;
  97                        sym_driver_setup.scsi_led = 0;
  98                        sym_driver_setup.scsi_diff = 1;
  99                        sym_driver_setup.irq_mode = 0;
 100                        sym_driver_setup.scsi_bus_check = 2;
 101                        sym_driver_setup.host_id = 7;
 102                        sym_driver_setup.verbose = 2;
 103                        sym_driver_setup.settle_delay = 10;
 104                        sym_driver_setup.use_nvram = 1;
 105                } else if (*safe_string != 'n') {
 106                        printk(KERN_WARNING NAME53C8XX "Ignoring parameter %s"
 107                                        " passed to safe option", safe_string);
 108                }
 109        }
 110}
 111
 112static struct scsi_transport_template *sym2_transport_template = NULL;
 113
 114/*
 115 *  Driver private area in the SCSI command structure.
 116 */
 117struct sym_ucmd {               /* Override the SCSI pointer structure */
 118        struct completion *eh_done;             /* SCSI error handling */
 119};
 120
 121#define SYM_UCMD_PTR(cmd)  ((struct sym_ucmd *)(&(cmd)->SCp))
 122#define SYM_SOFTC_PTR(cmd) sym_get_hcb(cmd->device->host)
 123
 124/*
 125 *  Complete a pending CAM CCB.
 126 */
 127void sym_xpt_done(struct sym_hcb *np, struct scsi_cmnd *cmd)
 128{
 129        struct sym_ucmd *ucmd = SYM_UCMD_PTR(cmd);
 130        BUILD_BUG_ON(sizeof(struct scsi_pointer) < sizeof(struct sym_ucmd));
 131
 132        if (ucmd->eh_done)
 133                complete(ucmd->eh_done);
 134
 135        scsi_dma_unmap(cmd);
 136        cmd->scsi_done(cmd);
 137}
 138
 139/*
 140 *  Tell the SCSI layer about a BUS RESET.
 141 */
 142void sym_xpt_async_bus_reset(struct sym_hcb *np)
 143{
 144        printf_notice("%s: SCSI BUS has been reset.\n", sym_name(np));
 145        np->s.settle_time = jiffies + sym_driver_setup.settle_delay * HZ;
 146        np->s.settle_time_valid = 1;
 147        if (sym_verbose >= 2)
 148                printf_info("%s: command processing suspended for %d seconds\n",
 149                            sym_name(np), sym_driver_setup.settle_delay);
 150}
 151
 152/*
 153 *  Choose the more appropriate CAM status if 
 154 *  the IO encountered an extended error.
 155 */
 156static int sym_xerr_cam_status(int cam_status, int x_status)
 157{
 158        if (x_status) {
 159                if (x_status & XE_PARITY_ERR)
 160                        cam_status = DID_PARITY;
 161                else
 162                        cam_status = DID_ERROR;
 163        }
 164        return cam_status;
 165}
 166
 167/*
 168 *  Build CAM result for a failed or auto-sensed IO.
 169 */
 170void sym_set_cam_result_error(struct sym_hcb *np, struct sym_ccb *cp, int resid)
 171{
 172        struct scsi_cmnd *cmd = cp->cmd;
 173        u_int cam_status, scsi_status;
 174
 175        cam_status  = DID_OK;
 176        scsi_status = cp->ssss_status;
 177
 178        if (cp->host_flags & HF_SENSE) {
 179                scsi_status = cp->sv_scsi_status;
 180                resid = cp->sv_resid;
 181                if (sym_verbose && cp->sv_xerr_status)
 182                        sym_print_xerr(cmd, cp->sv_xerr_status);
 183                if (cp->host_status == HS_COMPLETE &&
 184                    cp->ssss_status == S_GOOD &&
 185                    cp->xerr_status == 0) {
 186                        cam_status = sym_xerr_cam_status(DID_OK,
 187                                                         cp->sv_xerr_status);
 188                        /*
 189                         *  Bounce back the sense data to user.
 190                         */
 191                        memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
 192                        memcpy(cmd->sense_buffer, cp->sns_bbuf,
 193                               min(SCSI_SENSE_BUFFERSIZE, SYM_SNS_BBUF_LEN));
 194#if 0
 195                        /*
 196                         *  If the device reports a UNIT ATTENTION condition 
 197                         *  due to a RESET condition, we should consider all 
 198                         *  disconnect CCBs for this unit as aborted.
 199                         */
 200                        if (1) {
 201                                u_char *p;
 202                                p  = (u_char *) cmd->sense_data;
 203                                if (p[0]==0x70 && p[2]==0x6 && p[12]==0x29)
 204                                        sym_clear_tasks(np, DID_ABORT,
 205                                                        cp->target,cp->lun, -1);
 206                        }
 207#endif
 208                } else {
 209                        /*
 210                         * Error return from our internal request sense.  This
 211                         * is bad: we must clear the contingent allegiance
 212                         * condition otherwise the device will always return
 213                         * BUSY.  Use a big stick.
 214                         */
 215                        sym_reset_scsi_target(np, cmd->device->id);
 216                        cam_status = DID_ERROR;
 217                }
 218        } else if (cp->host_status == HS_COMPLETE)      /* Bad SCSI status */
 219                cam_status = DID_OK;
 220        else if (cp->host_status == HS_SEL_TIMEOUT)     /* Selection timeout */
 221                cam_status = DID_NO_CONNECT;
 222        else if (cp->host_status == HS_UNEXPECTED)      /* Unexpected BUS FREE*/
 223                cam_status = DID_ERROR;
 224        else {                                          /* Extended error */
 225                if (sym_verbose) {
 226                        sym_print_addr(cmd, "COMMAND FAILED (%x %x %x).\n",
 227                                cp->host_status, cp->ssss_status,
 228                                cp->xerr_status);
 229                }
 230                /*
 231                 *  Set the most appropriate value for CAM status.
 232                 */
 233                cam_status = sym_xerr_cam_status(DID_ERROR, cp->xerr_status);
 234        }
 235        scsi_set_resid(cmd, resid);
 236        cmd->result = (cam_status << 16) | scsi_status;
 237}
 238
 239static int sym_scatter(struct sym_hcb *np, struct sym_ccb *cp, struct scsi_cmnd *cmd)
 240{
 241        int segment;
 242        int use_sg;
 243
 244        cp->data_len = 0;
 245
 246        use_sg = scsi_dma_map(cmd);
 247        if (use_sg > 0) {
 248                struct scatterlist *sg;
 249                struct sym_tcb *tp = &np->target[cp->target];
 250                struct sym_tblmove *data;
 251
 252                if (use_sg > SYM_CONF_MAX_SG) {
 253                        scsi_dma_unmap(cmd);
 254                        return -1;
 255                }
 256
 257                data = &cp->phys.data[SYM_CONF_MAX_SG - use_sg];
 258
 259                scsi_for_each_sg(cmd, sg, use_sg, segment) {
 260                        dma_addr_t baddr = sg_dma_address(sg);
 261                        unsigned int len = sg_dma_len(sg);
 262
 263                        if ((len & 1) && (tp->head.wval & EWS)) {
 264                                len++;
 265                                cp->odd_byte_adjustment++;
 266                        }
 267
 268                        sym_build_sge(np, &data[segment], baddr, len);
 269                        cp->data_len += len;
 270                }
 271        } else {
 272                segment = -2;
 273        }
 274
 275        return segment;
 276}
 277
 278/*
 279 *  Queue a SCSI command.
 280 */
 281static int sym_queue_command(struct sym_hcb *np, struct scsi_cmnd *cmd)
 282{
 283        struct scsi_device *sdev = cmd->device;
 284        struct sym_tcb *tp;
 285        struct sym_lcb *lp;
 286        struct sym_ccb *cp;
 287        int     order;
 288
 289        /*
 290         *  Retrieve the target descriptor.
 291         */
 292        tp = &np->target[sdev->id];
 293
 294        /*
 295         *  Select tagged/untagged.
 296         */
 297        lp = sym_lp(tp, sdev->lun);
 298        order = (lp && lp->s.reqtags) ? M_SIMPLE_TAG : 0;
 299
 300        /*
 301         *  Queue the SCSI IO.
 302         */
 303        cp = sym_get_ccb(np, cmd, order);
 304        if (!cp)
 305                return 1;       /* Means resource shortage */
 306        sym_queue_scsiio(np, cmd, cp);
 307        return 0;
 308}
 309
 310/*
 311 *  Setup buffers and pointers that address the CDB.
 312 */
 313static inline int sym_setup_cdb(struct sym_hcb *np, struct scsi_cmnd *cmd, struct sym_ccb *cp)
 314{
 315        memcpy(cp->cdb_buf, cmd->cmnd, cmd->cmd_len);
 316
 317        cp->phys.cmd.addr = CCB_BA(cp, cdb_buf[0]);
 318        cp->phys.cmd.size = cpu_to_scr(cmd->cmd_len);
 319
 320        return 0;
 321}
 322
 323/*
 324 *  Setup pointers that address the data and start the I/O.
 325 */
 326int sym_setup_data_and_start(struct sym_hcb *np, struct scsi_cmnd *cmd, struct sym_ccb *cp)
 327{
 328        u32 lastp, goalp;
 329        int dir;
 330
 331        /*
 332         *  Build the CDB.
 333         */
 334        if (sym_setup_cdb(np, cmd, cp))
 335                goto out_abort;
 336
 337        /*
 338         *  No direction means no data.
 339         */
 340        dir = cmd->sc_data_direction;
 341        if (dir != DMA_NONE) {
 342                cp->segments = sym_scatter(np, cp, cmd);
 343                if (cp->segments < 0) {
 344                        sym_set_cam_status(cmd, DID_ERROR);
 345                        goto out_abort;
 346                }
 347
 348                /*
 349                 *  No segments means no data.
 350                 */
 351                if (!cp->segments)
 352                        dir = DMA_NONE;
 353        } else {
 354                cp->data_len = 0;
 355                cp->segments = 0;
 356        }
 357
 358        /*
 359         *  Set the data pointer.
 360         */
 361        switch (dir) {
 362        case DMA_BIDIRECTIONAL:
 363                scmd_printk(KERN_INFO, cmd, "got DMA_BIDIRECTIONAL command");
 364                sym_set_cam_status(cmd, DID_ERROR);
 365                goto out_abort;
 366        case DMA_TO_DEVICE:
 367                goalp = SCRIPTA_BA(np, data_out2) + 8;
 368                lastp = goalp - 8 - (cp->segments * (2*4));
 369                break;
 370        case DMA_FROM_DEVICE:
 371                cp->host_flags |= HF_DATA_IN;
 372                goalp = SCRIPTA_BA(np, data_in2) + 8;
 373                lastp = goalp - 8 - (cp->segments * (2*4));
 374                break;
 375        case DMA_NONE:
 376        default:
 377                lastp = goalp = SCRIPTB_BA(np, no_data);
 378                break;
 379        }
 380
 381        /*
 382         *  Set all pointers values needed by SCRIPTS.
 383         */
 384        cp->phys.head.lastp = cpu_to_scr(lastp);
 385        cp->phys.head.savep = cpu_to_scr(lastp);
 386        cp->startp          = cp->phys.head.savep;
 387        cp->goalp           = cpu_to_scr(goalp);
 388
 389        /*
 390         *  When `#ifed 1', the code below makes the driver 
 391         *  panic on the first attempt to write to a SCSI device.
 392         *  It is the first test we want to do after a driver 
 393         *  change that does not seem obviously safe. :)
 394         */
 395#if 0
 396        switch (cp->cdb_buf[0]) {
 397        case 0x0A: case 0x2A: case 0xAA:
 398                panic("XXXXXXXXXXXXX WRITE NOT YET ALLOWED XXXXXXXXXXXXXX\n");
 399                break;
 400        default:
 401                break;
 402        }
 403#endif
 404
 405        /*
 406         *      activate this job.
 407         */
 408        sym_put_start_queue(np, cp);
 409        return 0;
 410
 411out_abort:
 412        sym_free_ccb(np, cp);
 413        sym_xpt_done(np, cmd);
 414        return 0;
 415}
 416
 417
 418/*
 419 *  timer daemon.
 420 *
 421 *  Misused to keep the driver running when
 422 *  interrupts are not configured correctly.
 423 */
 424static void sym_timer(struct sym_hcb *np)
 425{
 426        unsigned long thistime = jiffies;
 427
 428        /*
 429         *  Restart the timer.
 430         */
 431        np->s.timer.expires = thistime + SYM_CONF_TIMER_INTERVAL;
 432        add_timer(&np->s.timer);
 433
 434        /*
 435         *  If we are resetting the ncr, wait for settle_time before 
 436         *  clearing it. Then command processing will be resumed.
 437         */
 438        if (np->s.settle_time_valid) {
 439                if (time_before_eq(np->s.settle_time, thistime)) {
 440                        if (sym_verbose >= 2 )
 441                                printk("%s: command processing resumed\n",
 442                                       sym_name(np));
 443                        np->s.settle_time_valid = 0;
 444                }
 445                return;
 446        }
 447
 448        /*
 449         *      Nothing to do for now, but that may come.
 450         */
 451        if (np->s.lasttime + 4*HZ < thistime) {
 452                np->s.lasttime = thistime;
 453        }
 454
 455#ifdef SYM_CONF_PCIQ_MAY_MISS_COMPLETIONS
 456        /*
 457         *  Some way-broken PCI bridges may lead to 
 458         *  completions being lost when the clearing 
 459         *  of the INTFLY flag by the CPU occurs 
 460         *  concurrently with the chip raising this flag.
 461         *  If this ever happen, lost completions will 
 462         * be reaped here.
 463         */
 464        sym_wakeup_done(np);
 465#endif
 466}
 467
 468
 469/*
 470 *  PCI BUS error handler.
 471 */
 472void sym_log_bus_error(struct Scsi_Host *shost)
 473{
 474        struct sym_data *sym_data = shost_priv(shost);
 475        struct pci_dev *pdev = sym_data->pdev;
 476        unsigned short pci_sts;
 477        pci_read_config_word(pdev, PCI_STATUS, &pci_sts);
 478        if (pci_sts & 0xf900) {
 479                pci_write_config_word(pdev, PCI_STATUS, pci_sts);
 480                shost_printk(KERN_WARNING, shost,
 481                        "PCI bus error: status = 0x%04x\n", pci_sts & 0xf900);
 482        }
 483}
 484
 485/*
 486 * queuecommand method.  Entered with the host adapter lock held and
 487 * interrupts disabled.
 488 */
 489static int sym53c8xx_queue_command_lck(struct scsi_cmnd *cmd,
 490                                        void (*done)(struct scsi_cmnd *))
 491{
 492        struct sym_hcb *np = SYM_SOFTC_PTR(cmd);
 493        struct sym_ucmd *ucp = SYM_UCMD_PTR(cmd);
 494        int sts = 0;
 495
 496        cmd->scsi_done = done;
 497        memset(ucp, 0, sizeof(*ucp));
 498
 499        /*
 500         *  Shorten our settle_time if needed for 
 501         *  this command not to time out.
 502         */
 503        if (np->s.settle_time_valid && cmd->request->timeout) {
 504                unsigned long tlimit = jiffies + cmd->request->timeout;
 505                tlimit -= SYM_CONF_TIMER_INTERVAL*2;
 506                if (time_after(np->s.settle_time, tlimit)) {
 507                        np->s.settle_time = tlimit;
 508                }
 509        }
 510
 511        if (np->s.settle_time_valid)
 512                return SCSI_MLQUEUE_HOST_BUSY;
 513
 514        sts = sym_queue_command(np, cmd);
 515        if (sts)
 516                return SCSI_MLQUEUE_HOST_BUSY;
 517        return 0;
 518}
 519
 520static DEF_SCSI_QCMD(sym53c8xx_queue_command)
 521
 522/*
 523 *  Linux entry point of the interrupt handler.
 524 */
 525static irqreturn_t sym53c8xx_intr(int irq, void *dev_id)
 526{
 527        struct Scsi_Host *shost = dev_id;
 528        struct sym_data *sym_data = shost_priv(shost);
 529        irqreturn_t result;
 530
 531        /* Avoid spinloop trying to handle interrupts on frozen device */
 532        if (pci_channel_offline(sym_data->pdev))
 533                return IRQ_NONE;
 534
 535        if (DEBUG_FLAGS & DEBUG_TINY) printf_debug ("[");
 536
 537        spin_lock(shost->host_lock);
 538        result = sym_interrupt(shost);
 539        spin_unlock(shost->host_lock);
 540
 541        if (DEBUG_FLAGS & DEBUG_TINY) printf_debug ("]\n");
 542
 543        return result;
 544}
 545
 546/*
 547 *  Linux entry point of the timer handler
 548 */
 549static void sym53c8xx_timer(struct timer_list *t)
 550{
 551        struct sym_hcb *np = from_timer(np, t, s.timer);
 552        unsigned long flags;
 553
 554        spin_lock_irqsave(np->s.host->host_lock, flags);
 555        sym_timer(np);
 556        spin_unlock_irqrestore(np->s.host->host_lock, flags);
 557}
 558
 559
 560/*
 561 *  What the eh thread wants us to perform.
 562 */
 563#define SYM_EH_ABORT            0
 564#define SYM_EH_DEVICE_RESET     1
 565#define SYM_EH_BUS_RESET        2
 566#define SYM_EH_HOST_RESET       3
 567
 568/*
 569 *  Generic method for our eh processing.
 570 *  The 'op' argument tells what we have to do.
 571 */
 572static int sym_eh_handler(int op, char *opname, struct scsi_cmnd *cmd)
 573{
 574        struct sym_ucmd *ucmd = SYM_UCMD_PTR(cmd);
 575        struct Scsi_Host *shost = cmd->device->host;
 576        struct sym_data *sym_data = shost_priv(shost);
 577        struct pci_dev *pdev = sym_data->pdev;
 578        struct sym_hcb *np = sym_data->ncb;
 579        SYM_QUEHEAD *qp;
 580        int cmd_queued = 0;
 581        int sts = -1;
 582        struct completion eh_done;
 583
 584        scmd_printk(KERN_WARNING, cmd, "%s operation started\n", opname);
 585
 586        /* We may be in an error condition because the PCI bus
 587         * went down. In this case, we need to wait until the
 588         * PCI bus is reset, the card is reset, and only then
 589         * proceed with the scsi error recovery.  There's no
 590         * point in hurrying; take a leisurely wait.
 591         */
 592#define WAIT_FOR_PCI_RECOVERY   35
 593        if (pci_channel_offline(pdev)) {
 594                int finished_reset = 0;
 595                init_completion(&eh_done);
 596                spin_lock_irq(shost->host_lock);
 597                /* Make sure we didn't race */
 598                if (pci_channel_offline(pdev)) {
 599                        BUG_ON(sym_data->io_reset);
 600                        sym_data->io_reset = &eh_done;
 601                } else {
 602                        finished_reset = 1;
 603                }
 604                spin_unlock_irq(shost->host_lock);
 605                if (!finished_reset)
 606                        finished_reset = wait_for_completion_timeout
 607                                                (sym_data->io_reset,
 608                                                WAIT_FOR_PCI_RECOVERY*HZ);
 609                spin_lock_irq(shost->host_lock);
 610                sym_data->io_reset = NULL;
 611                spin_unlock_irq(shost->host_lock);
 612                if (!finished_reset)
 613                        return SCSI_FAILED;
 614        }
 615
 616        spin_lock_irq(shost->host_lock);
 617        /* This one is queued in some place -> to wait for completion */
 618        FOR_EACH_QUEUED_ELEMENT(&np->busy_ccbq, qp) {
 619                struct sym_ccb *cp = sym_que_entry(qp, struct sym_ccb, link_ccbq);
 620                if (cp->cmd == cmd) {
 621                        cmd_queued = 1;
 622                        break;
 623                }
 624        }
 625
 626        /* Try to proceed the operation we have been asked for */
 627        sts = -1;
 628        switch(op) {
 629        case SYM_EH_ABORT:
 630                sts = sym_abort_scsiio(np, cmd, 1);
 631                break;
 632        case SYM_EH_DEVICE_RESET:
 633                sts = sym_reset_scsi_target(np, cmd->device->id);
 634                break;
 635        case SYM_EH_BUS_RESET:
 636                sym_reset_scsi_bus(np, 1);
 637                sts = 0;
 638                break;
 639        case SYM_EH_HOST_RESET:
 640                sym_reset_scsi_bus(np, 0);
 641                sym_start_up(shost, 1);
 642                sts = 0;
 643                break;
 644        default:
 645                break;
 646        }
 647
 648        /* On error, restore everything and cross fingers :) */
 649        if (sts)
 650                cmd_queued = 0;
 651
 652        if (cmd_queued) {
 653                init_completion(&eh_done);
 654                ucmd->eh_done = &eh_done;
 655                spin_unlock_irq(shost->host_lock);
 656                if (!wait_for_completion_timeout(&eh_done, 5*HZ)) {
 657                        ucmd->eh_done = NULL;
 658                        sts = -2;
 659                }
 660        } else {
 661                spin_unlock_irq(shost->host_lock);
 662        }
 663
 664        dev_warn(&cmd->device->sdev_gendev, "%s operation %s.\n", opname,
 665                        sts==0 ? "complete" :sts==-2 ? "timed-out" : "failed");
 666        return sts ? SCSI_FAILED : SCSI_SUCCESS;
 667}
 668
 669
 670/*
 671 * Error handlers called from the eh thread (one thread per HBA).
 672 */
 673static int sym53c8xx_eh_abort_handler(struct scsi_cmnd *cmd)
 674{
 675        return sym_eh_handler(SYM_EH_ABORT, "ABORT", cmd);
 676}
 677
 678static int sym53c8xx_eh_device_reset_handler(struct scsi_cmnd *cmd)
 679{
 680        return sym_eh_handler(SYM_EH_DEVICE_RESET, "DEVICE RESET", cmd);
 681}
 682
 683static int sym53c8xx_eh_bus_reset_handler(struct scsi_cmnd *cmd)
 684{
 685        return sym_eh_handler(SYM_EH_BUS_RESET, "BUS RESET", cmd);
 686}
 687
 688static int sym53c8xx_eh_host_reset_handler(struct scsi_cmnd *cmd)
 689{
 690        return sym_eh_handler(SYM_EH_HOST_RESET, "HOST RESET", cmd);
 691}
 692
 693/*
 694 *  Tune device queuing depth, according to various limits.
 695 */
 696static void sym_tune_dev_queuing(struct sym_tcb *tp, int lun, u_short reqtags)
 697{
 698        struct sym_lcb *lp = sym_lp(tp, lun);
 699        u_short oldtags;
 700
 701        if (!lp)
 702                return;
 703
 704        oldtags = lp->s.reqtags;
 705
 706        if (reqtags > lp->s.scdev_depth)
 707                reqtags = lp->s.scdev_depth;
 708
 709        lp->s.reqtags     = reqtags;
 710
 711        if (reqtags != oldtags) {
 712                dev_info(&tp->starget->dev,
 713                         "tagged command queuing %s, command queue depth %d.\n",
 714                          lp->s.reqtags ? "enabled" : "disabled", reqtags);
 715        }
 716}
 717
 718static int sym53c8xx_slave_alloc(struct scsi_device *sdev)
 719{
 720        struct sym_hcb *np = sym_get_hcb(sdev->host);
 721        struct sym_tcb *tp = &np->target[sdev->id];
 722        struct sym_lcb *lp;
 723        unsigned long flags;
 724        int error;
 725
 726        if (sdev->id >= SYM_CONF_MAX_TARGET || sdev->lun >= SYM_CONF_MAX_LUN)
 727                return -ENXIO;
 728
 729        spin_lock_irqsave(np->s.host->host_lock, flags);
 730
 731        /*
 732         * Fail the device init if the device is flagged NOSCAN at BOOT in
 733         * the NVRAM.  This may speed up boot and maintain coherency with
 734         * BIOS device numbering.  Clearing the flag allows the user to
 735         * rescan skipped devices later.  We also return an error for
 736         * devices not flagged for SCAN LUNS in the NVRAM since some single
 737         * lun devices behave badly when asked for a non zero LUN.
 738         */
 739
 740        if (tp->usrflags & SYM_SCAN_BOOT_DISABLED) {
 741                tp->usrflags &= ~SYM_SCAN_BOOT_DISABLED;
 742                starget_printk(KERN_INFO, sdev->sdev_target,
 743                                "Scan at boot disabled in NVRAM\n");
 744                error = -ENXIO;
 745                goto out;
 746        }
 747
 748        if (tp->usrflags & SYM_SCAN_LUNS_DISABLED) {
 749                if (sdev->lun != 0) {
 750                        error = -ENXIO;
 751                        goto out;
 752                }
 753                starget_printk(KERN_INFO, sdev->sdev_target,
 754                                "Multiple LUNs disabled in NVRAM\n");
 755        }
 756
 757        lp = sym_alloc_lcb(np, sdev->id, sdev->lun);
 758        if (!lp) {
 759                error = -ENOMEM;
 760                goto out;
 761        }
 762        if (tp->nlcb == 1)
 763                tp->starget = sdev->sdev_target;
 764
 765        spi_min_period(tp->starget) = tp->usr_period;
 766        spi_max_width(tp->starget) = tp->usr_width;
 767
 768        error = 0;
 769out:
 770        spin_unlock_irqrestore(np->s.host->host_lock, flags);
 771
 772        return error;
 773}
 774
 775/*
 776 * Linux entry point for device queue sizing.
 777 */
 778static int sym53c8xx_slave_configure(struct scsi_device *sdev)
 779{
 780        struct sym_hcb *np = sym_get_hcb(sdev->host);
 781        struct sym_tcb *tp = &np->target[sdev->id];
 782        struct sym_lcb *lp = sym_lp(tp, sdev->lun);
 783        int reqtags, depth_to_use;
 784
 785        /*
 786         *  Get user flags.
 787         */
 788        lp->curr_flags = lp->user_flags;
 789
 790        /*
 791         *  Select queue depth from driver setup.
 792         *  Do not use more than configured by user.
 793         *  Use at least 1.
 794         *  Do not use more than our maximum.
 795         */
 796        reqtags = sym_driver_setup.max_tag;
 797        if (reqtags > tp->usrtags)
 798                reqtags = tp->usrtags;
 799        if (!sdev->tagged_supported)
 800                reqtags = 0;
 801        if (reqtags > SYM_CONF_MAX_TAG)
 802                reqtags = SYM_CONF_MAX_TAG;
 803        depth_to_use = reqtags ? reqtags : 1;
 804        scsi_change_queue_depth(sdev, depth_to_use);
 805        lp->s.scdev_depth = depth_to_use;
 806        sym_tune_dev_queuing(tp, sdev->lun, reqtags);
 807
 808        if (!spi_initial_dv(sdev->sdev_target))
 809                spi_dv_device(sdev);
 810
 811        return 0;
 812}
 813
 814static void sym53c8xx_slave_destroy(struct scsi_device *sdev)
 815{
 816        struct sym_hcb *np = sym_get_hcb(sdev->host);
 817        struct sym_tcb *tp = &np->target[sdev->id];
 818        struct sym_lcb *lp = sym_lp(tp, sdev->lun);
 819        unsigned long flags;
 820
 821        /* if slave_alloc returned before allocating a sym_lcb, return */
 822        if (!lp)
 823                return;
 824
 825        spin_lock_irqsave(np->s.host->host_lock, flags);
 826
 827        if (lp->busy_itlq || lp->busy_itl) {
 828                /*
 829                 * This really shouldn't happen, but we can't return an error
 830                 * so let's try to stop all on-going I/O.
 831                 */
 832                starget_printk(KERN_WARNING, tp->starget,
 833                               "Removing busy LCB (%d)\n", (u8)sdev->lun);
 834                sym_reset_scsi_bus(np, 1);
 835        }
 836
 837        if (sym_free_lcb(np, sdev->id, sdev->lun) == 0) {
 838                /*
 839                 * It was the last unit for this target.
 840                 */
 841                tp->head.sval        = 0;
 842                tp->head.wval        = np->rv_scntl3;
 843                tp->head.uval        = 0;
 844                tp->tgoal.check_nego = 1;
 845                tp->starget          = NULL;
 846        }
 847
 848        spin_unlock_irqrestore(np->s.host->host_lock, flags);
 849}
 850
 851/*
 852 *  Linux entry point for info() function
 853 */
 854static const char *sym53c8xx_info (struct Scsi_Host *host)
 855{
 856        return SYM_DRIVER_NAME;
 857}
 858
 859
 860#ifdef SYM_LINUX_PROC_INFO_SUPPORT
 861/*
 862 *  Proc file system stuff
 863 *
 864 *  A read operation returns adapter information.
 865 *  A write operation is a control command.
 866 *  The string is parsed in the driver code and the command is passed 
 867 *  to the sym_usercmd() function.
 868 */
 869
 870#ifdef SYM_LINUX_USER_COMMAND_SUPPORT
 871
 872struct  sym_usrcmd {
 873        u_long  target;
 874        u_long  lun;
 875        u_long  data;
 876        u_long  cmd;
 877};
 878
 879#define UC_SETSYNC      10
 880#define UC_SETTAGS      11
 881#define UC_SETDEBUG     12
 882#define UC_SETWIDE      14
 883#define UC_SETFLAG      15
 884#define UC_SETVERBOSE   17
 885#define UC_RESETDEV     18
 886#define UC_CLEARDEV     19
 887
 888static void sym_exec_user_command (struct sym_hcb *np, struct sym_usrcmd *uc)
 889{
 890        struct sym_tcb *tp;
 891        int t, l;
 892
 893        switch (uc->cmd) {
 894        case 0: return;
 895
 896#ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT
 897        case UC_SETDEBUG:
 898                sym_debug_flags = uc->data;
 899                break;
 900#endif
 901        case UC_SETVERBOSE:
 902                np->verbose = uc->data;
 903                break;
 904        default:
 905                /*
 906                 * We assume that other commands apply to targets.
 907                 * This should always be the case and avoid the below 
 908                 * 4 lines to be repeated 6 times.
 909                 */
 910                for (t = 0; t < SYM_CONF_MAX_TARGET; t++) {
 911                        if (!((uc->target >> t) & 1))
 912                                continue;
 913                        tp = &np->target[t];
 914                        if (!tp->nlcb)
 915                                continue;
 916
 917                        switch (uc->cmd) {
 918
 919                        case UC_SETSYNC:
 920                                if (!uc->data || uc->data >= 255) {
 921                                        tp->tgoal.iu = tp->tgoal.dt =
 922                                                tp->tgoal.qas = 0;
 923                                        tp->tgoal.offset = 0;
 924                                } else if (uc->data <= 9 && np->minsync_dt) {
 925                                        if (uc->data < np->minsync_dt)
 926                                                uc->data = np->minsync_dt;
 927                                        tp->tgoal.iu = tp->tgoal.dt =
 928                                                tp->tgoal.qas = 1;
 929                                        tp->tgoal.width = 1;
 930                                        tp->tgoal.period = uc->data;
 931                                        tp->tgoal.offset = np->maxoffs_dt;
 932                                } else {
 933                                        if (uc->data < np->minsync)
 934                                                uc->data = np->minsync;
 935                                        tp->tgoal.iu = tp->tgoal.dt =
 936                                                tp->tgoal.qas = 0;
 937                                        tp->tgoal.period = uc->data;
 938                                        tp->tgoal.offset = np->maxoffs;
 939                                }
 940                                tp->tgoal.check_nego = 1;
 941                                break;
 942                        case UC_SETWIDE:
 943                                tp->tgoal.width = uc->data ? 1 : 0;
 944                                tp->tgoal.check_nego = 1;
 945                                break;
 946                        case UC_SETTAGS:
 947                                for (l = 0; l < SYM_CONF_MAX_LUN; l++)
 948                                        sym_tune_dev_queuing(tp, l, uc->data);
 949                                break;
 950                        case UC_RESETDEV:
 951                                tp->to_reset = 1;
 952                                np->istat_sem = SEM;
 953                                OUTB(np, nc_istat, SIGP|SEM);
 954                                break;
 955                        case UC_CLEARDEV:
 956                                for (l = 0; l < SYM_CONF_MAX_LUN; l++) {
 957                                        struct sym_lcb *lp = sym_lp(tp, l);
 958                                        if (lp) lp->to_clear = 1;
 959                                }
 960                                np->istat_sem = SEM;
 961                                OUTB(np, nc_istat, SIGP|SEM);
 962                                break;
 963                        case UC_SETFLAG:
 964                                tp->usrflags = uc->data;
 965                                break;
 966                        }
 967                }
 968                break;
 969        }
 970}
 971
 972static int sym_skip_spaces(char *ptr, int len)
 973{
 974        int cnt, c;
 975
 976        for (cnt = len; cnt > 0 && (c = *ptr++) && isspace(c); cnt--);
 977
 978        return (len - cnt);
 979}
 980
 981static int get_int_arg(char *ptr, int len, u_long *pv)
 982{
 983        char *end;
 984
 985        *pv = simple_strtoul(ptr, &end, 10);
 986        return (end - ptr);
 987}
 988
 989static int is_keyword(char *ptr, int len, char *verb)
 990{
 991        int verb_len = strlen(verb);
 992
 993        if (len >= verb_len && !memcmp(verb, ptr, verb_len))
 994                return verb_len;
 995        else
 996                return 0;
 997}
 998
 999#define SKIP_SPACES(ptr, len)                                           \
1000        if ((arg_len = sym_skip_spaces(ptr, len)) < 1)                  \
1001                return -EINVAL;                                         \
1002        ptr += arg_len; len -= arg_len;
1003
1004#define GET_INT_ARG(ptr, len, v)                                        \
1005        if (!(arg_len = get_int_arg(ptr, len, &(v))))                   \
1006                return -EINVAL;                                         \
1007        ptr += arg_len; len -= arg_len;
1008
1009
1010/*
1011 * Parse a control command
1012 */
1013
1014static int sym_user_command(struct Scsi_Host *shost, char *buffer, int length)
1015{
1016        struct sym_hcb *np = sym_get_hcb(shost);
1017        char *ptr       = buffer;
1018        int len         = length;
1019        struct sym_usrcmd cmd, *uc = &cmd;
1020        int             arg_len;
1021        u_long          target;
1022
1023        memset(uc, 0, sizeof(*uc));
1024
1025        if (len > 0 && ptr[len-1] == '\n')
1026                --len;
1027
1028        if      ((arg_len = is_keyword(ptr, len, "setsync")) != 0)
1029                uc->cmd = UC_SETSYNC;
1030        else if ((arg_len = is_keyword(ptr, len, "settags")) != 0)
1031                uc->cmd = UC_SETTAGS;
1032        else if ((arg_len = is_keyword(ptr, len, "setverbose")) != 0)
1033                uc->cmd = UC_SETVERBOSE;
1034        else if ((arg_len = is_keyword(ptr, len, "setwide")) != 0)
1035                uc->cmd = UC_SETWIDE;
1036#ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT
1037        else if ((arg_len = is_keyword(ptr, len, "setdebug")) != 0)
1038                uc->cmd = UC_SETDEBUG;
1039#endif
1040        else if ((arg_len = is_keyword(ptr, len, "setflag")) != 0)
1041                uc->cmd = UC_SETFLAG;
1042        else if ((arg_len = is_keyword(ptr, len, "resetdev")) != 0)
1043                uc->cmd = UC_RESETDEV;
1044        else if ((arg_len = is_keyword(ptr, len, "cleardev")) != 0)
1045                uc->cmd = UC_CLEARDEV;
1046        else
1047                arg_len = 0;
1048
1049#ifdef DEBUG_PROC_INFO
1050printk("sym_user_command: arg_len=%d, cmd=%ld\n", arg_len, uc->cmd);
1051#endif
1052
1053        if (!arg_len)
1054                return -EINVAL;
1055        ptr += arg_len; len -= arg_len;
1056
1057        switch(uc->cmd) {
1058        case UC_SETSYNC:
1059        case UC_SETTAGS:
1060        case UC_SETWIDE:
1061        case UC_SETFLAG:
1062        case UC_RESETDEV:
1063        case UC_CLEARDEV:
1064                SKIP_SPACES(ptr, len);
1065                if ((arg_len = is_keyword(ptr, len, "all")) != 0) {
1066                        ptr += arg_len; len -= arg_len;
1067                        uc->target = ~0;
1068                } else {
1069                        GET_INT_ARG(ptr, len, target);
1070                        uc->target = (1<<target);
1071#ifdef DEBUG_PROC_INFO
1072printk("sym_user_command: target=%ld\n", target);
1073#endif
1074                }
1075                break;
1076        }
1077
1078        switch(uc->cmd) {
1079        case UC_SETVERBOSE:
1080        case UC_SETSYNC:
1081        case UC_SETTAGS:
1082        case UC_SETWIDE:
1083                SKIP_SPACES(ptr, len);
1084                GET_INT_ARG(ptr, len, uc->data);
1085#ifdef DEBUG_PROC_INFO
1086printk("sym_user_command: data=%ld\n", uc->data);
1087#endif
1088                break;
1089#ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT
1090        case UC_SETDEBUG:
1091                while (len > 0) {
1092                        SKIP_SPACES(ptr, len);
1093                        if      ((arg_len = is_keyword(ptr, len, "alloc")))
1094                                uc->data |= DEBUG_ALLOC;
1095                        else if ((arg_len = is_keyword(ptr, len, "phase")))
1096                                uc->data |= DEBUG_PHASE;
1097                        else if ((arg_len = is_keyword(ptr, len, "queue")))
1098                                uc->data |= DEBUG_QUEUE;
1099                        else if ((arg_len = is_keyword(ptr, len, "result")))
1100                                uc->data |= DEBUG_RESULT;
1101                        else if ((arg_len = is_keyword(ptr, len, "scatter")))
1102                                uc->data |= DEBUG_SCATTER;
1103                        else if ((arg_len = is_keyword(ptr, len, "script")))
1104                                uc->data |= DEBUG_SCRIPT;
1105                        else if ((arg_len = is_keyword(ptr, len, "tiny")))
1106                                uc->data |= DEBUG_TINY;
1107                        else if ((arg_len = is_keyword(ptr, len, "timing")))
1108                                uc->data |= DEBUG_TIMING;
1109                        else if ((arg_len = is_keyword(ptr, len, "nego")))
1110                                uc->data |= DEBUG_NEGO;
1111                        else if ((arg_len = is_keyword(ptr, len, "tags")))
1112                                uc->data |= DEBUG_TAGS;
1113                        else if ((arg_len = is_keyword(ptr, len, "pointer")))
1114                                uc->data |= DEBUG_POINTER;
1115                        else
1116                                return -EINVAL;
1117                        ptr += arg_len; len -= arg_len;
1118                }
1119#ifdef DEBUG_PROC_INFO
1120printk("sym_user_command: data=%ld\n", uc->data);
1121#endif
1122                break;
1123#endif /* SYM_LINUX_DEBUG_CONTROL_SUPPORT */
1124        case UC_SETFLAG:
1125                while (len > 0) {
1126                        SKIP_SPACES(ptr, len);
1127                        if      ((arg_len = is_keyword(ptr, len, "no_disc")))
1128                                uc->data &= ~SYM_DISC_ENABLED;
1129                        else
1130                                return -EINVAL;
1131                        ptr += arg_len; len -= arg_len;
1132                }
1133                break;
1134        default:
1135                break;
1136        }
1137
1138        if (len)
1139                return -EINVAL;
1140        else {
1141                unsigned long flags;
1142
1143                spin_lock_irqsave(shost->host_lock, flags);
1144                sym_exec_user_command(np, uc);
1145                spin_unlock_irqrestore(shost->host_lock, flags);
1146        }
1147        return length;
1148}
1149
1150#endif  /* SYM_LINUX_USER_COMMAND_SUPPORT */
1151
1152
1153/*
1154 *  Copy formatted information into the input buffer.
1155 */
1156static int sym_show_info(struct seq_file *m, struct Scsi_Host *shost)
1157{
1158#ifdef SYM_LINUX_USER_INFO_SUPPORT
1159        struct sym_data *sym_data = shost_priv(shost);
1160        struct pci_dev *pdev = sym_data->pdev;
1161        struct sym_hcb *np = sym_data->ncb;
1162
1163        seq_printf(m, "Chip " NAME53C "%s, device id 0x%x, "
1164                 "revision id 0x%x\n", np->s.chip_name,
1165                 pdev->device, pdev->revision);
1166        seq_printf(m, "At PCI address %s, IRQ %u\n",
1167                         pci_name(pdev), pdev->irq);
1168        seq_printf(m, "Min. period factor %d, %s SCSI BUS%s\n",
1169                 (int) (np->minsync_dt ? np->minsync_dt : np->minsync),
1170                 np->maxwide ? "Wide" : "Narrow",
1171                 np->minsync_dt ? ", DT capable" : "");
1172
1173        seq_printf(m, "Max. started commands %d, "
1174                 "max. commands per LUN %d\n",
1175                 SYM_CONF_MAX_START, SYM_CONF_MAX_TAG);
1176
1177        return 0;
1178#else
1179        return -EINVAL;
1180#endif /* SYM_LINUX_USER_INFO_SUPPORT */
1181}
1182
1183#endif /* SYM_LINUX_PROC_INFO_SUPPORT */
1184
1185/*
1186 * Free resources claimed by sym_iomap_device().  Note that
1187 * sym_free_resources() should be used instead of this function after calling
1188 * sym_attach().
1189 */
1190static void sym_iounmap_device(struct sym_device *device)
1191{
1192        if (device->s.ioaddr)
1193                pci_iounmap(device->pdev, device->s.ioaddr);
1194        if (device->s.ramaddr)
1195                pci_iounmap(device->pdev, device->s.ramaddr);
1196}
1197
1198/*
1199 *      Free controller resources.
1200 */
1201static void sym_free_resources(struct sym_hcb *np, struct pci_dev *pdev,
1202                int do_free_irq)
1203{
1204        /*
1205         *  Free O/S specific resources.
1206         */
1207        if (do_free_irq)
1208                free_irq(pdev->irq, np->s.host);
1209        if (np->s.ioaddr)
1210                pci_iounmap(pdev, np->s.ioaddr);
1211        if (np->s.ramaddr)
1212                pci_iounmap(pdev, np->s.ramaddr);
1213        /*
1214         *  Free O/S independent resources.
1215         */
1216        sym_hcb_free(np);
1217
1218        sym_mfree_dma(np, sizeof(*np), "HCB");
1219}
1220
1221/*
1222 *  Host attach and initialisations.
1223 *
1224 *  Allocate host data and ncb structure.
1225 *  Remap MMIO region.
1226 *  Do chip initialization.
1227 *  If all is OK, install interrupt handling and
1228 *  start the timer daemon.
1229 */
1230static struct Scsi_Host *sym_attach(struct scsi_host_template *tpnt, int unit,
1231                                    struct sym_device *dev)
1232{
1233        struct sym_data *sym_data;
1234        struct sym_hcb *np = NULL;
1235        struct Scsi_Host *shost = NULL;
1236        struct pci_dev *pdev = dev->pdev;
1237        unsigned long flags;
1238        struct sym_fw *fw;
1239        int do_free_irq = 0;
1240
1241        printk(KERN_INFO "sym%d: <%s> rev 0x%x at pci %s irq %u\n",
1242                unit, dev->chip.name, pdev->revision, pci_name(pdev),
1243                pdev->irq);
1244
1245        /*
1246         *  Get the firmware for this chip.
1247         */
1248        fw = sym_find_firmware(&dev->chip);
1249        if (!fw)
1250                goto attach_failed;
1251
1252        shost = scsi_host_alloc(tpnt, sizeof(*sym_data));
1253        if (!shost)
1254                goto attach_failed;
1255        sym_data = shost_priv(shost);
1256
1257        /*
1258         *  Allocate immediately the host control block, 
1259         *  since we are only expecting to succeed. :)
1260         *  We keep track in the HCB of all the resources that 
1261         *  are to be released on error.
1262         */
1263        np = __sym_calloc_dma(&pdev->dev, sizeof(*np), "HCB");
1264        if (!np)
1265                goto attach_failed;
1266        np->bus_dmat = &pdev->dev; /* Result in 1 DMA pool per HBA */
1267        sym_data->ncb = np;
1268        sym_data->pdev = pdev;
1269        np->s.host = shost;
1270
1271        pci_set_drvdata(pdev, shost);
1272
1273        /*
1274         *  Copy some useful infos to the HCB.
1275         */
1276        np->hcb_ba      = vtobus(np);
1277        np->verbose     = sym_driver_setup.verbose;
1278        np->s.unit      = unit;
1279        np->features    = dev->chip.features;
1280        np->clock_divn  = dev->chip.nr_divisor;
1281        np->maxoffs     = dev->chip.offset_max;
1282        np->maxburst    = dev->chip.burst_max;
1283        np->myaddr      = dev->host_id;
1284        np->mmio_ba     = (u32)dev->mmio_base;
1285        np->ram_ba      = (u32)dev->ram_base;
1286        np->s.ioaddr    = dev->s.ioaddr;
1287        np->s.ramaddr   = dev->s.ramaddr;
1288
1289        /*
1290         *  Edit its name.
1291         */
1292        strlcpy(np->s.chip_name, dev->chip.name, sizeof(np->s.chip_name));
1293        sprintf(np->s.inst_name, "sym%d", np->s.unit);
1294
1295        if ((SYM_CONF_DMA_ADDRESSING_MODE > 0) && (np->features & FE_DAC) &&
1296                        !dma_set_mask(&pdev->dev, DMA_DAC_MASK)) {
1297                set_dac(np);
1298        } else if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
1299                printf_warning("%s: No suitable DMA available\n", sym_name(np));
1300                goto attach_failed;
1301        }
1302
1303        if (sym_hcb_attach(shost, fw, dev->nvram))
1304                goto attach_failed;
1305
1306        /*
1307         *  Install the interrupt handler.
1308         *  If we synchonize the C code with SCRIPTS on interrupt, 
1309         *  we do not want to share the INTR line at all.
1310         */
1311        if (request_irq(pdev->irq, sym53c8xx_intr, IRQF_SHARED, NAME53C8XX,
1312                        shost)) {
1313                printf_err("%s: request irq %u failure\n",
1314                        sym_name(np), pdev->irq);
1315                goto attach_failed;
1316        }
1317        do_free_irq = 1;
1318
1319        /*
1320         *  After SCSI devices have been opened, we cannot
1321         *  reset the bus safely, so we do it here.
1322         */
1323        spin_lock_irqsave(shost->host_lock, flags);
1324        if (sym_reset_scsi_bus(np, 0))
1325                goto reset_failed;
1326
1327        /*
1328         *  Start the SCRIPTS.
1329         */
1330        sym_start_up(shost, 1);
1331
1332        /*
1333         *  Start the timer daemon
1334         */
1335        timer_setup(&np->s.timer, sym53c8xx_timer, 0);
1336        np->s.lasttime=0;
1337        sym_timer (np);
1338
1339        /*
1340         *  Fill Linux host instance structure
1341         *  and return success.
1342         */
1343        shost->max_channel      = 0;
1344        shost->this_id          = np->myaddr;
1345        shost->max_id           = np->maxwide ? 16 : 8;
1346        shost->max_lun          = SYM_CONF_MAX_LUN;
1347        shost->unique_id        = pci_resource_start(pdev, 0);
1348        shost->cmd_per_lun      = SYM_CONF_MAX_TAG;
1349        shost->can_queue        = (SYM_CONF_MAX_START-2);
1350        shost->sg_tablesize     = SYM_CONF_MAX_SG;
1351        shost->max_cmd_len      = 16;
1352        BUG_ON(sym2_transport_template == NULL);
1353        shost->transportt       = sym2_transport_template;
1354
1355        /* 53c896 rev 1 errata: DMA may not cross 16MB boundary */
1356        if (pdev->device == PCI_DEVICE_ID_NCR_53C896 && pdev->revision < 2)
1357                shost->dma_boundary = 0xFFFFFF;
1358
1359        spin_unlock_irqrestore(shost->host_lock, flags);
1360
1361        return shost;
1362
1363 reset_failed:
1364        printf_err("%s: FATAL ERROR: CHECK SCSI BUS - CABLES, "
1365                   "TERMINATION, DEVICE POWER etc.!\n", sym_name(np));
1366        spin_unlock_irqrestore(shost->host_lock, flags);
1367 attach_failed:
1368        printf_info("sym%d: giving up ...\n", unit);
1369        if (np)
1370                sym_free_resources(np, pdev, do_free_irq);
1371        else
1372                sym_iounmap_device(dev);
1373        if (shost)
1374                scsi_host_put(shost);
1375
1376        return NULL;
1377}
1378
1379
1380/*
1381 *    Detect and try to read SYMBIOS and TEKRAM NVRAM.
1382 */
1383#if SYM_CONF_NVRAM_SUPPORT
1384static void sym_get_nvram(struct sym_device *devp, struct sym_nvram *nvp)
1385{
1386        devp->nvram = nvp;
1387        nvp->type = 0;
1388
1389        sym_read_nvram(devp, nvp);
1390}
1391#else
1392static inline void sym_get_nvram(struct sym_device *devp, struct sym_nvram *nvp)
1393{
1394}
1395#endif  /* SYM_CONF_NVRAM_SUPPORT */
1396
1397static int sym_check_supported(struct sym_device *device)
1398{
1399        struct sym_chip *chip;
1400        struct pci_dev *pdev = device->pdev;
1401        unsigned long io_port = pci_resource_start(pdev, 0);
1402        int i;
1403
1404        /*
1405         *  If user excluded this chip, do not initialize it.
1406         *  I hate this code so much.  Must kill it.
1407         */
1408        if (io_port) {
1409                for (i = 0 ; i < 8 ; i++) {
1410                        if (sym_driver_setup.excludes[i] == io_port)
1411                                return -ENODEV;
1412                }
1413        }
1414
1415        /*
1416         * Check if the chip is supported.  Then copy the chip description
1417         * to our device structure so we can make it match the actual device
1418         * and options.
1419         */
1420        chip = sym_lookup_chip_table(pdev->device, pdev->revision);
1421        if (!chip) {
1422                dev_info(&pdev->dev, "device not supported\n");
1423                return -ENODEV;
1424        }
1425        memcpy(&device->chip, chip, sizeof(device->chip));
1426
1427        return 0;
1428}
1429
1430/*
1431 * Ignore Symbios chips controlled by various RAID controllers.
1432 * These controllers set value 0x52414944 at RAM end - 16.
1433 */
1434static int sym_check_raid(struct sym_device *device)
1435{
1436        unsigned int ram_size, ram_val;
1437
1438        if (!device->s.ramaddr)
1439                return 0;
1440
1441        if (device->chip.features & FE_RAM8K)
1442                ram_size = 8192;
1443        else
1444                ram_size = 4096;
1445
1446        ram_val = readl(device->s.ramaddr + ram_size - 16);
1447        if (ram_val != 0x52414944)
1448                return 0;
1449
1450        dev_info(&device->pdev->dev,
1451                        "not initializing, driven by RAID controller.\n");
1452        return -ENODEV;
1453}
1454
1455static int sym_set_workarounds(struct sym_device *device)
1456{
1457        struct sym_chip *chip = &device->chip;
1458        struct pci_dev *pdev = device->pdev;
1459        u_short status_reg;
1460
1461        /*
1462         *  (ITEM 12 of a DEL about the 896 I haven't yet).
1463         *  We must ensure the chip will use WRITE AND INVALIDATE.
1464         *  The revision number limit is for now arbitrary.
1465         */
1466        if (pdev->device == PCI_DEVICE_ID_NCR_53C896 && pdev->revision < 0x4) {
1467                chip->features  |= (FE_WRIE | FE_CLSE);
1468        }
1469
1470        /* If the chip can do Memory Write Invalidate, enable it */
1471        if (chip->features & FE_WRIE) {
1472                if (pci_set_mwi(pdev))
1473                        return -ENODEV;
1474        }
1475
1476        /*
1477         *  Work around for errant bit in 895A. The 66Mhz
1478         *  capable bit is set erroneously. Clear this bit.
1479         *  (Item 1 DEL 533)
1480         *
1481         *  Make sure Config space and Features agree.
1482         *
1483         *  Recall: writes are not normal to status register -
1484         *  write a 1 to clear and a 0 to leave unchanged.
1485         *  Can only reset bits.
1486         */
1487        pci_read_config_word(pdev, PCI_STATUS, &status_reg);
1488        if (chip->features & FE_66MHZ) {
1489                if (!(status_reg & PCI_STATUS_66MHZ))
1490                        chip->features &= ~FE_66MHZ;
1491        } else {
1492                if (status_reg & PCI_STATUS_66MHZ) {
1493                        status_reg = PCI_STATUS_66MHZ;
1494                        pci_write_config_word(pdev, PCI_STATUS, status_reg);
1495                        pci_read_config_word(pdev, PCI_STATUS, &status_reg);
1496                }
1497        }
1498
1499        return 0;
1500}
1501
1502/*
1503 * Map HBA registers and on-chip SRAM (if present).
1504 */
1505static int sym_iomap_device(struct sym_device *device)
1506{
1507        struct pci_dev *pdev = device->pdev;
1508        struct pci_bus_region bus_addr;
1509        int i = 2;
1510
1511        pcibios_resource_to_bus(pdev->bus, &bus_addr, &pdev->resource[1]);
1512        device->mmio_base = bus_addr.start;
1513
1514        if (device->chip.features & FE_RAM) {
1515                /*
1516                 * If the BAR is 64-bit, resource 2 will be occupied by the
1517                 * upper 32 bits
1518                 */
1519                if (!pdev->resource[i].flags)
1520                        i++;
1521                pcibios_resource_to_bus(pdev->bus, &bus_addr,
1522                                        &pdev->resource[i]);
1523                device->ram_base = bus_addr.start;
1524        }
1525
1526#ifdef CONFIG_SCSI_SYM53C8XX_MMIO
1527        if (device->mmio_base)
1528                device->s.ioaddr = pci_iomap(pdev, 1,
1529                                                pci_resource_len(pdev, 1));
1530#endif
1531        if (!device->s.ioaddr)
1532                device->s.ioaddr = pci_iomap(pdev, 0,
1533                                                pci_resource_len(pdev, 0));
1534        if (!device->s.ioaddr) {
1535                dev_err(&pdev->dev, "could not map registers; giving up.\n");
1536                return -EIO;
1537        }
1538        if (device->ram_base) {
1539                device->s.ramaddr = pci_iomap(pdev, i,
1540                                                pci_resource_len(pdev, i));
1541                if (!device->s.ramaddr) {
1542                        dev_warn(&pdev->dev,
1543                                "could not map SRAM; continuing anyway.\n");
1544                        device->ram_base = 0;
1545                }
1546        }
1547
1548        return 0;
1549}
1550
1551/*
1552 * The NCR PQS and PDS cards are constructed as a DEC bridge
1553 * behind which sits a proprietary NCR memory controller and
1554 * either four or two 53c875s as separate devices.  We can tell
1555 * if an 875 is part of a PQS/PDS or not since if it is, it will
1556 * be on the same bus as the memory controller.  In its usual
1557 * mode of operation, the 875s are slaved to the memory
1558 * controller for all transfers.  To operate with the Linux
1559 * driver, the memory controller is disabled and the 875s
1560 * freed to function independently.  The only wrinkle is that
1561 * the preset SCSI ID (which may be zero) must be read in from
1562 * a special configuration space register of the 875.
1563 */
1564static void sym_config_pqs(struct pci_dev *pdev, struct sym_device *sym_dev)
1565{
1566        int slot;
1567        u8 tmp;
1568
1569        for (slot = 0; slot < 256; slot++) {
1570                struct pci_dev *memc = pci_get_slot(pdev->bus, slot);
1571
1572                if (!memc || memc->vendor != 0x101a || memc->device == 0x0009) {
1573                        pci_dev_put(memc);
1574                        continue;
1575                }
1576
1577                /* bit 1: allow individual 875 configuration */
1578                pci_read_config_byte(memc, 0x44, &tmp);
1579                if ((tmp & 0x2) == 0) {
1580                        tmp |= 0x2;
1581                        pci_write_config_byte(memc, 0x44, tmp);
1582                }
1583
1584                /* bit 2: drive individual 875 interrupts to the bus */
1585                pci_read_config_byte(memc, 0x45, &tmp);
1586                if ((tmp & 0x4) == 0) {
1587                        tmp |= 0x4;
1588                        pci_write_config_byte(memc, 0x45, tmp);
1589                }
1590
1591                pci_dev_put(memc);
1592                break;
1593        }
1594
1595        pci_read_config_byte(pdev, 0x84, &tmp);
1596        sym_dev->host_id = tmp;
1597}
1598
1599/*
1600 *  Called before unloading the module.
1601 *  Detach the host.
1602 *  We have to free resources and halt the NCR chip.
1603 */
1604static int sym_detach(struct Scsi_Host *shost, struct pci_dev *pdev)
1605{
1606        struct sym_hcb *np = sym_get_hcb(shost);
1607        printk("%s: detaching ...\n", sym_name(np));
1608
1609        del_timer_sync(&np->s.timer);
1610
1611        /*
1612         * Reset NCR chip.
1613         * We should use sym_soft_reset(), but we don't want to do 
1614         * so, since we may not be safe if interrupts occur.
1615         */
1616        printk("%s: resetting chip\n", sym_name(np));
1617        OUTB(np, nc_istat, SRST);
1618        INB(np, nc_mbox1);
1619        udelay(10);
1620        OUTB(np, nc_istat, 0);
1621
1622        sym_free_resources(np, pdev, 1);
1623        scsi_host_put(shost);
1624
1625        return 1;
1626}
1627
1628/*
1629 * Driver host template.
1630 */
1631static struct scsi_host_template sym2_template = {
1632        .module                 = THIS_MODULE,
1633        .name                   = "sym53c8xx",
1634        .info                   = sym53c8xx_info, 
1635        .queuecommand           = sym53c8xx_queue_command,
1636        .slave_alloc            = sym53c8xx_slave_alloc,
1637        .slave_configure        = sym53c8xx_slave_configure,
1638        .slave_destroy          = sym53c8xx_slave_destroy,
1639        .eh_abort_handler       = sym53c8xx_eh_abort_handler,
1640        .eh_device_reset_handler = sym53c8xx_eh_device_reset_handler,
1641        .eh_bus_reset_handler   = sym53c8xx_eh_bus_reset_handler,
1642        .eh_host_reset_handler  = sym53c8xx_eh_host_reset_handler,
1643        .this_id                = 7,
1644        .max_sectors            = 0xFFFF,
1645#ifdef SYM_LINUX_PROC_INFO_SUPPORT
1646        .show_info              = sym_show_info,
1647#ifdef  SYM_LINUX_USER_COMMAND_SUPPORT
1648        .write_info             = sym_user_command,
1649#endif
1650        .proc_name              = NAME53C8XX,
1651#endif
1652};
1653
1654static int attach_count;
1655
1656static int sym2_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1657{
1658        struct sym_device sym_dev;
1659        struct sym_nvram nvram;
1660        struct Scsi_Host *shost;
1661        int do_iounmap = 0;
1662        int do_disable_device = 1;
1663
1664        memset(&sym_dev, 0, sizeof(sym_dev));
1665        memset(&nvram, 0, sizeof(nvram));
1666        sym_dev.pdev = pdev;
1667        sym_dev.host_id = SYM_SETUP_HOST_ID;
1668
1669        if (pci_enable_device(pdev))
1670                goto leave;
1671
1672        pci_set_master(pdev);
1673
1674        if (pci_request_regions(pdev, NAME53C8XX))
1675                goto disable;
1676
1677        if (sym_check_supported(&sym_dev))
1678                goto free;
1679
1680        if (sym_iomap_device(&sym_dev))
1681                goto free;
1682        do_iounmap = 1;
1683
1684        if (sym_check_raid(&sym_dev)) {
1685                do_disable_device = 0;  /* Don't disable the device */
1686                goto free;
1687        }
1688
1689        if (sym_set_workarounds(&sym_dev))
1690                goto free;
1691
1692        sym_config_pqs(pdev, &sym_dev);
1693
1694        sym_get_nvram(&sym_dev, &nvram);
1695
1696        do_iounmap = 0; /* Don't sym_iounmap_device() after sym_attach(). */
1697        shost = sym_attach(&sym2_template, attach_count, &sym_dev);
1698        if (!shost)
1699                goto free;
1700
1701        if (scsi_add_host(shost, &pdev->dev))
1702                goto detach;
1703        scsi_scan_host(shost);
1704
1705        attach_count++;
1706
1707        return 0;
1708
1709 detach:
1710        sym_detach(pci_get_drvdata(pdev), pdev);
1711 free:
1712        if (do_iounmap)
1713                sym_iounmap_device(&sym_dev);
1714        pci_release_regions(pdev);
1715 disable:
1716        if (do_disable_device)
1717                pci_disable_device(pdev);
1718 leave:
1719        return -ENODEV;
1720}
1721
1722static void sym2_remove(struct pci_dev *pdev)
1723{
1724        struct Scsi_Host *shost = pci_get_drvdata(pdev);
1725
1726        scsi_remove_host(shost);
1727        sym_detach(shost, pdev);
1728        pci_release_regions(pdev);
1729        pci_disable_device(pdev);
1730
1731        attach_count--;
1732}
1733
1734/**
1735 * sym2_io_error_detected() - called when PCI error is detected
1736 * @pdev: pointer to PCI device
1737 * @state: current state of the PCI slot
1738 */
1739static pci_ers_result_t sym2_io_error_detected(struct pci_dev *pdev,
1740                                         pci_channel_state_t state)
1741{
1742        /* If slot is permanently frozen, turn everything off */
1743        if (state == pci_channel_io_perm_failure) {
1744                sym2_remove(pdev);
1745                return PCI_ERS_RESULT_DISCONNECT;
1746        }
1747
1748        disable_irq(pdev->irq);
1749        pci_disable_device(pdev);
1750
1751        /* Request that MMIO be enabled, so register dump can be taken. */
1752        return PCI_ERS_RESULT_CAN_RECOVER;
1753}
1754
1755/**
1756 * sym2_io_slot_dump - Enable MMIO and dump debug registers
1757 * @pdev: pointer to PCI device
1758 */
1759static pci_ers_result_t sym2_io_slot_dump(struct pci_dev *pdev)
1760{
1761        struct Scsi_Host *shost = pci_get_drvdata(pdev);
1762
1763        sym_dump_registers(shost);
1764
1765        /* Request a slot reset. */
1766        return PCI_ERS_RESULT_NEED_RESET;
1767}
1768
1769/**
1770 * sym2_reset_workarounds - hardware-specific work-arounds
1771 * @pdev: pointer to PCI device
1772 *
1773 * This routine is similar to sym_set_workarounds(), except
1774 * that, at this point, we already know that the device was
1775 * successfully initialized at least once before, and so most
1776 * of the steps taken there are un-needed here.
1777 */
1778static void sym2_reset_workarounds(struct pci_dev *pdev)
1779{
1780        u_short status_reg;
1781        struct sym_chip *chip;
1782
1783        chip = sym_lookup_chip_table(pdev->device, pdev->revision);
1784
1785        /* Work around for errant bit in 895A, in a fashion
1786         * similar to what is done in sym_set_workarounds().
1787         */
1788        pci_read_config_word(pdev, PCI_STATUS, &status_reg);
1789        if (!(chip->features & FE_66MHZ) && (status_reg & PCI_STATUS_66MHZ)) {
1790                status_reg = PCI_STATUS_66MHZ;
1791                pci_write_config_word(pdev, PCI_STATUS, status_reg);
1792                pci_read_config_word(pdev, PCI_STATUS, &status_reg);
1793        }
1794}
1795
1796/**
1797 * sym2_io_slot_reset() - called when the pci bus has been reset.
1798 * @pdev: pointer to PCI device
1799 *
1800 * Restart the card from scratch.
1801 */
1802static pci_ers_result_t sym2_io_slot_reset(struct pci_dev *pdev)
1803{
1804        struct Scsi_Host *shost = pci_get_drvdata(pdev);
1805        struct sym_hcb *np = sym_get_hcb(shost);
1806
1807        printk(KERN_INFO "%s: recovering from a PCI slot reset\n",
1808                  sym_name(np));
1809
1810        if (pci_enable_device(pdev)) {
1811                printk(KERN_ERR "%s: Unable to enable after PCI reset\n",
1812                        sym_name(np));
1813                return PCI_ERS_RESULT_DISCONNECT;
1814        }
1815
1816        pci_set_master(pdev);
1817        enable_irq(pdev->irq);
1818
1819        /* If the chip can do Memory Write Invalidate, enable it */
1820        if (np->features & FE_WRIE) {
1821                if (pci_set_mwi(pdev))
1822                        return PCI_ERS_RESULT_DISCONNECT;
1823        }
1824
1825        /* Perform work-arounds, analogous to sym_set_workarounds() */
1826        sym2_reset_workarounds(pdev);
1827
1828        /* Perform host reset only on one instance of the card */
1829        if (PCI_FUNC(pdev->devfn) == 0) {
1830                if (sym_reset_scsi_bus(np, 0)) {
1831                        printk(KERN_ERR "%s: Unable to reset scsi host\n",
1832                                sym_name(np));
1833                        return PCI_ERS_RESULT_DISCONNECT;
1834                }
1835                sym_start_up(shost, 1);
1836        }
1837
1838        return PCI_ERS_RESULT_RECOVERED;
1839}
1840
1841/**
1842 * sym2_io_resume() - resume normal ops after PCI reset
1843 * @pdev: pointer to PCI device
1844 *
1845 * Called when the error recovery driver tells us that its
1846 * OK to resume normal operation. Use completion to allow
1847 * halted scsi ops to resume.
1848 */
1849static void sym2_io_resume(struct pci_dev *pdev)
1850{
1851        struct Scsi_Host *shost = pci_get_drvdata(pdev);
1852        struct sym_data *sym_data = shost_priv(shost);
1853
1854        spin_lock_irq(shost->host_lock);
1855        if (sym_data->io_reset)
1856                complete(sym_data->io_reset);
1857        spin_unlock_irq(shost->host_lock);
1858}
1859
1860static void sym2_get_signalling(struct Scsi_Host *shost)
1861{
1862        struct sym_hcb *np = sym_get_hcb(shost);
1863        enum spi_signal_type type;
1864
1865        switch (np->scsi_mode) {
1866        case SMODE_SE:
1867                type = SPI_SIGNAL_SE;
1868                break;
1869        case SMODE_LVD:
1870                type = SPI_SIGNAL_LVD;
1871                break;
1872        case SMODE_HVD:
1873                type = SPI_SIGNAL_HVD;
1874                break;
1875        default:
1876                type = SPI_SIGNAL_UNKNOWN;
1877                break;
1878        }
1879        spi_signalling(shost) = type;
1880}
1881
1882static void sym2_set_offset(struct scsi_target *starget, int offset)
1883{
1884        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1885        struct sym_hcb *np = sym_get_hcb(shost);
1886        struct sym_tcb *tp = &np->target[starget->id];
1887
1888        tp->tgoal.offset = offset;
1889        tp->tgoal.check_nego = 1;
1890}
1891
1892static void sym2_set_period(struct scsi_target *starget, int period)
1893{
1894        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1895        struct sym_hcb *np = sym_get_hcb(shost);
1896        struct sym_tcb *tp = &np->target[starget->id];
1897
1898        /* have to have DT for these transfers, but DT will also
1899         * set width, so check that this is allowed */
1900        if (period <= np->minsync && spi_width(starget))
1901                tp->tgoal.dt = 1;
1902
1903        tp->tgoal.period = period;
1904        tp->tgoal.check_nego = 1;
1905}
1906
1907static void sym2_set_width(struct scsi_target *starget, int width)
1908{
1909        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1910        struct sym_hcb *np = sym_get_hcb(shost);
1911        struct sym_tcb *tp = &np->target[starget->id];
1912
1913        /* It is illegal to have DT set on narrow transfers.  If DT is
1914         * clear, we must also clear IU and QAS.  */
1915        if (width == 0)
1916                tp->tgoal.iu = tp->tgoal.dt = tp->tgoal.qas = 0;
1917
1918        tp->tgoal.width = width;
1919        tp->tgoal.check_nego = 1;
1920}
1921
1922static void sym2_set_dt(struct scsi_target *starget, int dt)
1923{
1924        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1925        struct sym_hcb *np = sym_get_hcb(shost);
1926        struct sym_tcb *tp = &np->target[starget->id];
1927
1928        /* We must clear QAS and IU if DT is clear */
1929        if (dt)
1930                tp->tgoal.dt = 1;
1931        else
1932                tp->tgoal.iu = tp->tgoal.dt = tp->tgoal.qas = 0;
1933        tp->tgoal.check_nego = 1;
1934}
1935
1936#if 0
1937static void sym2_set_iu(struct scsi_target *starget, int iu)
1938{
1939        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1940        struct sym_hcb *np = sym_get_hcb(shost);
1941        struct sym_tcb *tp = &np->target[starget->id];
1942
1943        if (iu)
1944                tp->tgoal.iu = tp->tgoal.dt = 1;
1945        else
1946                tp->tgoal.iu = 0;
1947        tp->tgoal.check_nego = 1;
1948}
1949
1950static void sym2_set_qas(struct scsi_target *starget, int qas)
1951{
1952        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1953        struct sym_hcb *np = sym_get_hcb(shost);
1954        struct sym_tcb *tp = &np->target[starget->id];
1955
1956        if (qas)
1957                tp->tgoal.dt = tp->tgoal.qas = 1;
1958        else
1959                tp->tgoal.qas = 0;
1960        tp->tgoal.check_nego = 1;
1961}
1962#endif
1963
1964static struct spi_function_template sym2_transport_functions = {
1965        .set_offset     = sym2_set_offset,
1966        .show_offset    = 1,
1967        .set_period     = sym2_set_period,
1968        .show_period    = 1,
1969        .set_width      = sym2_set_width,
1970        .show_width     = 1,
1971        .set_dt         = sym2_set_dt,
1972        .show_dt        = 1,
1973#if 0
1974        .set_iu         = sym2_set_iu,
1975        .show_iu        = 1,
1976        .set_qas        = sym2_set_qas,
1977        .show_qas       = 1,
1978#endif
1979        .get_signalling = sym2_get_signalling,
1980};
1981
1982static struct pci_device_id sym2_id_table[] = {
1983        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C810,
1984          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
1985        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C820,
1986          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, /* new */
1987        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C825,
1988          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
1989        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C815,
1990          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
1991        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C810AP,
1992          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, /* new */
1993        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C860,
1994          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
1995        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C1510,
1996          PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_SCSI<<8,  0xffff00, 0UL },
1997        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C896,
1998          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
1999        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C895,
2000          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2001        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C885,
2002          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2003        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C875,
2004          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2005        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C1510,
2006          PCI_ANY_ID, PCI_ANY_ID,  PCI_CLASS_STORAGE_SCSI<<8,  0xffff00, 0UL }, /* new */
2007        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C895A,
2008          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2009        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C875A,
2010          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2011        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C1010_33,
2012          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2013        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C1010_66,
2014          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2015        { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C875J,
2016          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2017        { 0, }
2018};
2019
2020MODULE_DEVICE_TABLE(pci, sym2_id_table);
2021
2022static const struct pci_error_handlers sym2_err_handler = {
2023        .error_detected = sym2_io_error_detected,
2024        .mmio_enabled   = sym2_io_slot_dump,
2025        .slot_reset     = sym2_io_slot_reset,
2026        .resume         = sym2_io_resume,
2027};
2028
2029static struct pci_driver sym2_driver = {
2030        .name           = NAME53C8XX,
2031        .id_table       = sym2_id_table,
2032        .probe          = sym2_probe,
2033        .remove         = sym2_remove,
2034        .err_handler    = &sym2_err_handler,
2035};
2036
2037static int __init sym2_init(void)
2038{
2039        int error;
2040
2041        sym2_setup_params();
2042        sym2_transport_template = spi_attach_transport(&sym2_transport_functions);
2043        if (!sym2_transport_template)
2044                return -ENODEV;
2045
2046        error = pci_register_driver(&sym2_driver);
2047        if (error)
2048                spi_release_transport(sym2_transport_template);
2049        return error;
2050}
2051
2052static void __exit sym2_exit(void)
2053{
2054        pci_unregister_driver(&sym2_driver);
2055        spi_release_transport(sym2_transport_template);
2056}
2057
2058module_init(sym2_init);
2059module_exit(sym2_exit);
2060