drivers/scsi/aic7xxx/aic79xx_osm.c

   1 /*
   2  * Adaptec AIC79xx device driver for Linux.
   3  *
   4  * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic79xx_osm.c#171 $
   5  *
   6  * --------------------------------------------------------------------------
   7  * Copyright (c) 1994-2000 Justin T. Gibbs.
   8  * Copyright (c) 1997-1999 Doug Ledford
   9  * Copyright (c) 2000-2003 Adaptec Inc.
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions, and the following disclaimer,
  17  *    without modification.
  18  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  19  *    substantially similar to the "NO WARRANTY" disclaimer below
  20  *    ("Disclaimer") and any redistribution must be conditioned upon
  21  *    including a substantially similar Disclaimer requirement for further
  22  *    binary redistribution.
  23  * 3. Neither the names of the above-listed copyright holders nor the names
  24  *    of any contributors may be used to endorse or promote products derived
  25  *    from this software without specific prior written permission.
  26  *
  27  * Alternatively, this software may be distributed under the terms of the
  28  * GNU General Public License ("GPL") version 2 as published by the Free
  29  * Software Foundation.
  30  *
  31  * NO WARRANTY
  32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  35  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  36  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  40  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  41  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  42  * POSSIBILITY OF SUCH DAMAGES.
  43  */
  44
  45 #include "aic79xx_osm.h"
  46 #include "aic79xx_inline.h"
  47 #include <scsi/scsicam.h>
  48
  49 static struct scsi_transport_template *ahd_linux_transport_template = NULL;
  50
  51 #include <linux/init.h>         /* __setup */
  52 #include <linux/mm.h>           /* For fetching system memory size */
  53 #include <linux/blkdev.h>               /* For block_size() */
  54 #include <linux/delay.h>        /* For ssleep/msleep */
  55 #include <linux/device.h>
  56
  57 /*
  58  * Bucket size for counting good commands in between bad ones.
  59  */
  60 #define AHD_LINUX_ERR_THRESH    1000
  61
  62 /*
  63  * Set this to the delay in seconds after SCSI bus reset.
  64  * Note, we honor this only for the initial bus reset.
  65  * The scsi error recovery code performs its own bus settle
  66  * delay handling for error recovery actions.
  67  */
  68 #ifdef CONFIG_AIC79XX_RESET_DELAY_MS
  69 #define AIC79XX_RESET_DELAY CONFIG_AIC79XX_RESET_DELAY_MS
  70 #else
  71 #define AIC79XX_RESET_DELAY 5000
  72 #endif
  73
  74 /*
  75  * To change the default number of tagged transactions allowed per-device,
  76  * add a line to the lilo.conf file like:
  77  * append="aic79xx=verbose,tag_info:{{32,32,32,32},{32,32,32,32}}"
  78  * which will result in the first four devices on the first two
  79  * controllers being set to a tagged queue depth of 32.
  80  *
  81  * The tag_commands is an array of 16 to allow for wide and twin adapters.
  82  * Twin adapters will use indexes 0-7 for channel 0, and indexes 8-15
  83  * for channel 1.
  84  */
  85 typedef struct {
  86         uint16_t tag_commands[16];      /* Allow for wide/twin adapters. */
  87 } adapter_tag_info_t;
  88
  89 /*
  90  * Modify this as you see fit for your system.
  91  *
  92  * 0                    tagged queuing disabled
  93  * 1 <= n <= 253        n == max tags ever dispatched.
  94  *
  95  * The driver will throttle the number of commands dispatched to a
  96  * device if it returns queue full.  For devices with a fixed maximum
  97  * queue depth, the driver will eventually determine this depth and
  98  * lock it in (a console message is printed to indicate that a lock
  99  * has occurred).  On some devices, queue full is returned for a temporary
 100  * resource shortage.  These devices will return queue full at varying
 101  * depths.  The driver will throttle back when the queue fulls occur and
 102  * attempt to slowly increase the depth over time as the device recovers
 103  * from the resource shortage.
 104  *
 105  * In this example, the first line will disable tagged queueing for all
 106  * the devices on the first probed aic79xx adapter.
 107  *
 108  * The second line enables tagged queueing with 4 commands/LUN for IDs
 109  * (0, 2-11, 13-15), disables tagged queueing for ID 12, and tells the
 110  * driver to attempt to use up to 64 tags for ID 1.
 111  *
 112  * The third line is the same as the first line.
 113  *
 114  * The fourth line disables tagged queueing for devices 0 and 3.  It
 115  * enables tagged queueing for the other IDs, with 16 commands/LUN
 116  * for IDs 1 and 4, 127 commands/LUN for ID 8, and 4 commands/LUN for
 117  * IDs 2, 5-7, and 9-15.
 118  */
 119
 120 /*
 121  * NOTE: The below structure is for reference only, the actual structure
 122  *       to modify in order to change things is just below this comment block.
 123 adapter_tag_info_t aic79xx_tag_info[] =
 124 {
 125         {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
 126         {{4, 64, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4}},
 127         {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
 128         {{0, 16, 4, 0, 16, 4, 4, 4, 127, 4, 4, 4, 4, 4, 4, 4}}
 129 };
 130 */
 131
 132 #ifdef CONFIG_AIC79XX_CMDS_PER_DEVICE
 133 #define AIC79XX_CMDS_PER_DEVICE CONFIG_AIC79XX_CMDS_PER_DEVICE
 134 #else
 135 #define AIC79XX_CMDS_PER_DEVICE AHD_MAX_QUEUE
 136 #endif
 137
 138 #define AIC79XX_CONFIGED_TAG_COMMANDS {                                 \
 139         AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,               \
 140         AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,               \
 141         AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,               \
 142         AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,               \
 143         AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,               \
 144         AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,               \
 145         AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE,               \
 146         AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE                \
 147 }
 148
 149 /*
 150  * By default, use the number of commands specified by
 151  * the users kernel configuration.
 152  */
 153 static adapter_tag_info_t aic79xx_tag_info[] =
 154 {
 155         {AIC79XX_CONFIGED_TAG_COMMANDS},
 156         {AIC79XX_CONFIGED_TAG_COMMANDS},
 157         {AIC79XX_CONFIGED_TAG_COMMANDS},
 158         {AIC79XX_CONFIGED_TAG_COMMANDS},
 159         {AIC79XX_CONFIGED_TAG_COMMANDS},
 160         {AIC79XX_CONFIGED_TAG_COMMANDS},
 161         {AIC79XX_CONFIGED_TAG_COMMANDS},
 162         {AIC79XX_CONFIGED_TAG_COMMANDS},
 163         {AIC79XX_CONFIGED_TAG_COMMANDS},
 164         {AIC79XX_CONFIGED_TAG_COMMANDS},
 165         {AIC79XX_CONFIGED_TAG_COMMANDS},
 166         {AIC79XX_CONFIGED_TAG_COMMANDS},
 167         {AIC79XX_CONFIGED_TAG_COMMANDS},
 168         {AIC79XX_CONFIGED_TAG_COMMANDS},
 169         {AIC79XX_CONFIGED_TAG_COMMANDS},
 170         {AIC79XX_CONFIGED_TAG_COMMANDS}
 171 };
 172
 173 /*
 174  * The I/O cell on the chip is very configurable in respect to its analog
 175  * characteristics.  Set the defaults here; they can be overriden with
 176  * the proper insmod parameters.
 177  */
 178 struct ahd_linux_iocell_opts
 179 {
 180         uint8_t precomp;
 181         uint8_t slewrate;
 182         uint8_t amplitude;
 183 };
 184 #define AIC79XX_DEFAULT_PRECOMP         0xFF
 185 #define AIC79XX_DEFAULT_SLEWRATE        0xFF
 186 #define AIC79XX_DEFAULT_AMPLITUDE       0xFF
 187 #define AIC79XX_DEFAULT_IOOPTS                  \
 188 {                                               \
 189         AIC79XX_DEFAULT_PRECOMP,                \
 190         AIC79XX_DEFAULT_SLEWRATE,               \
 191         AIC79XX_DEFAULT_AMPLITUDE               \
 192 }
 193 #define AIC79XX_PRECOMP_INDEX   0
 194 #define AIC79XX_SLEWRATE_INDEX  1
 195 #define AIC79XX_AMPLITUDE_INDEX 2
 196 static struct ahd_linux_iocell_opts aic79xx_iocell_info[] =
 197 {
 198         AIC79XX_DEFAULT_IOOPTS,
 199         AIC79XX_DEFAULT_IOOPTS,
 200         AIC79XX_DEFAULT_IOOPTS,
 201         AIC79XX_DEFAULT_IOOPTS,
 202         AIC79XX_DEFAULT_IOOPTS,
 203         AIC79XX_DEFAULT_IOOPTS,
 204         AIC79XX_DEFAULT_IOOPTS,
 205         AIC79XX_DEFAULT_IOOPTS,
 206         AIC79XX_DEFAULT_IOOPTS,
 207         AIC79XX_DEFAULT_IOOPTS,
 208         AIC79XX_DEFAULT_IOOPTS,
 209         AIC79XX_DEFAULT_IOOPTS,
 210         AIC79XX_DEFAULT_IOOPTS,
 211         AIC79XX_DEFAULT_IOOPTS,
 212         AIC79XX_DEFAULT_IOOPTS,
 213         AIC79XX_DEFAULT_IOOPTS
 214 };
 215
 216 /*
 217  * There should be a specific return value for this in scsi.h, but
 218  * it seems that most drivers ignore it.
 219  */
 220 #define DID_UNDERFLOW   DID_ERROR
 221
 222 void
 223 ahd_print_path(struct ahd_softc *ahd, struct scb *scb)
 224 {
 225         printk("(scsi%d:%c:%d:%d): ",
 226                ahd->platform_data->host->host_no,
 227                scb != NULL ? SCB_GET_CHANNEL(ahd, scb) : 'X',
 228                scb != NULL ? SCB_GET_TARGET(ahd, scb) : -1,
 229                scb != NULL ? SCB_GET_LUN(scb) : -1);
 230 }
 231
 232 /*
 233  * XXX - these options apply unilaterally to _all_ adapters
 234  *       cards in the system.  This should be fixed.  Exceptions to this
 235  *       rule are noted in the comments.
 236  */
 237
 238 /*
 239  * Skip the scsi bus reset.  Non 0 make us skip the reset at startup.  This
 240  * has no effect on any later resets that might occur due to things like
 241  * SCSI bus timeouts.
 242  */
 243 static uint32_t aic79xx_no_reset;
 244
 245 /*
 246  * Certain PCI motherboards will scan PCI devices from highest to lowest,
 247  * others scan from lowest to highest, and they tend to do all kinds of
 248  * strange things when they come into contact with PCI bridge chips.  The
 249  * net result of all this is that the PCI card that is actually used to boot
 250  * the machine is very hard to detect.  Most motherboards go from lowest
 251  * PCI slot number to highest, and the first SCSI controller found is the
 252  * one you boot from.  The only exceptions to this are when a controller
 253  * has its BIOS disabled.  So, we by default sort all of our SCSI controllers
 254  * from lowest PCI slot number to highest PCI slot number.  We also force
 255  * all controllers with their BIOS disabled to the end of the list.  This
 256  * works on *almost* all computers.  Where it doesn't work, we have this
 257  * option.  Setting this option to non-0 will reverse the order of the sort
 258  * to highest first, then lowest, but will still leave cards with their BIOS
 259  * disabled at the very end.  That should fix everyone up unless there are
 260  * really strange cirumstances.
 261  */
 262 static uint32_t aic79xx_reverse_scan;
 263
 264 /*
 265  * Should we force EXTENDED translation on a controller.
 266  *     0 == Use whatever is in the SEEPROM or default to off
 267  *     1 == Use whatever is in the SEEPROM or default to on
 268  */
 269 static uint32_t aic79xx_extended;
 270
 271 /*
 272  * PCI bus parity checking of the Adaptec controllers.  This is somewhat
 273  * dubious at best.  To my knowledge, this option has never actually
 274  * solved a PCI parity problem, but on certain machines with broken PCI
 275  * chipset configurations, it can generate tons of false error messages.
 276  * It's included in the driver for completeness.
 277  *   0     = Shut off PCI parity check
 278  *   non-0 = Enable PCI parity check
 279  *
 280  * NOTE: you can't actually pass -1 on the lilo prompt.  So, to set this
 281  * variable to -1 you would actually want to simply pass the variable
 282  * name without a number.  That will invert the 0 which will result in
 283  * -1.
 284  */
 285 static uint32_t aic79xx_pci_parity = ~0;
 286
 287 /*
 288  * There are lots of broken chipsets in the world.  Some of them will
 289  * violate the PCI spec when we issue byte sized memory writes to our
 290  * controller.  I/O mapped register access, if allowed by the given
 291  * platform, will work in almost all cases.
 292  */
 293 uint32_t aic79xx_allow_memio = ~0;
 294
 295 /*
 296  * So that we can set how long each device is given as a selection timeout.
 297  * The table of values goes like this:
 298  *   0 - 256ms
 299  *   1 - 128ms
 300  *   2 - 64ms
 301  *   3 - 32ms
 302  * We default to 256ms because some older devices need a longer time
 303  * to respond to initial selection.
 304  */
 305 static uint32_t aic79xx_seltime;
 306
 307 /*
 308  * Certain devices do not perform any aging on commands.  Should the
 309  * device be saturated by commands in one portion of the disk, it is
 310  * possible for transactions on far away sectors to never be serviced.
 311  * To handle these devices, we can periodically send an ordered tag to
 312  * force all outstanding transactions to be serviced prior to a new
 313  * transaction.
 314  */
 315 uint32_t aic79xx_periodic_otag;
 316
 317 /* Some storage boxes are using an LSI chip which has a bug making it
 318  * impossible to use aic79xx Rev B chip in 320 speeds.  The following
 319  * storage boxes have been reported to be buggy:
 320  * EonStor 3U 16-Bay: U16U-G3A3
 321  * EonStor 2U 12-Bay: U12U-G3A3
 322  * SentinelRAID: 2500F R5 / R6
 323  * SentinelRAID: 2500F R1
 324  * SentinelRAID: 2500F/1500F
 325  * SentinelRAID: 150F
 326  *
 327  * To get around this LSI bug, you can set your board to 160 mode
 328  * or you can enable the SLOWCRC bit.
 329  */
 330 uint32_t aic79xx_slowcrc;
 331
 332 /*
 333  * Module information and settable options.
 334  */
 335 static char *aic79xx = NULL;
 336
 337 MODULE_AUTHOR("Maintainer: Justin T. Gibbs <gibbs@scsiguy.com>");
 338 MODULE_DESCRIPTION("Adaptec Aic790X U320 SCSI Host Bus Adapter driver");
 339 MODULE_LICENSE("Dual BSD/GPL");
 340 MODULE_VERSION(AIC79XX_DRIVER_VERSION);
 341 module_param(aic79xx, charp, 0444);
 342 MODULE_PARM_DESC(aic79xx,
 343 "period delimited, options string.\n"
 344 "       verbose                 Enable verbose/diagnostic logging\n"
 345 "       allow_memio             Allow device registers to be memory mapped\n"
 346 "       debug                   Bitmask of debug values to enable\n"
 347 "       no_reset                Supress initial bus resets\n"
 348 "       extended                Enable extended geometry on all controllers\n"
 349 "       periodic_otag           Send an ordered tagged transaction\n"
 350 "                               periodically to prevent tag starvation.\n"
 351 "                               This may be required by some older disk\n"
 352 "                               or drives/RAID arrays.\n"
 353 "       reverse_scan            Sort PCI devices highest Bus/Slot to lowest\n"
 354 "       tag_info:<tag_str>      Set per-target tag depth\n"
 355 "       global_tag_depth:<int>  Global tag depth for all targets on all buses\n"
 356 "       slewrate:<slewrate_list>Set the signal slew rate (0-15).\n"
 357 "       precomp:<pcomp_list>    Set the signal precompensation (0-7).\n"
 358 "       amplitude:<int>         Set the signal amplitude (0-7).\n"
 359 "       seltime:<int>           Selection Timeout:\n"
 360 "                               (0/256ms,1/128ms,2/64ms,3/32ms)\n"
 361 "       slowcrc                 Turn on the SLOWCRC bit (Rev B only)\n"
 362 "\n"
 363 "       Sample /etc/modprobe.conf line:\n"
 364 "               Enable verbose logging\n"
 365 "               Set tag depth on Controller 2/Target 2 to 10 tags\n"
 366 "               Shorten the selection timeout to 128ms\n"
 367 "\n"
 368 "       options aic79xx 'aic79xx=verbose.tag_info:{{}.{}.{..10}}.seltime:1'\n"
 369 "\n");
 370
 371 static void ahd_linux_handle_scsi_status(struct ahd_softc *,
 372                                          struct scsi_device *,
 373                                          struct scb *);
 374 static void ahd_linux_queue_cmd_complete(struct ahd_softc *ahd,
 375                                          struct scsi_cmnd *cmd);
 376 static int ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd);
 377 static void ahd_linux_initialize_scsi_bus(struct ahd_softc *ahd);
 378 static u_int ahd_linux_user_tagdepth(struct ahd_softc *ahd,
 379                                      struct ahd_devinfo *devinfo);
 380 static void ahd_linux_device_queue_depth(struct scsi_device *);
 381 static int ahd_linux_run_command(struct ahd_softc*,
 382                                  struct ahd_linux_device *,
 383                                  struct scsi_cmnd *);
 384 static void ahd_linux_setup_tag_info_global(char *p);
 385 static int  aic79xx_setup(char *c);
 386
 387 static int ahd_linux_unit;
 388
 389
 390 /****************************** Inlines ***************************************/
 391 static __inline void ahd_linux_unmap_scb(struct ahd_softc*, struct scb*);
 392
 393 static __inline void
 394 ahd_linux_unmap_scb(struct ahd_softc *ahd, struct scb *scb)
 395 {
 396         struct scsi_cmnd *cmd;
 397         int direction;
 398
 399         cmd = scb->io_ctx;
 400         direction = cmd->sc_data_direction;
 401         ahd_sync_sglist(ahd, scb, BUS_DMASYNC_POSTWRITE);
 402         if (cmd->use_sg != 0) {
 403                 struct scatterlist *sg;
 404
 405                 sg = (struct scatterlist *)cmd->request_buffer;
 406                 pci_unmap_sg(ahd->dev_softc, sg, cmd->use_sg, direction);
 407         } else if (cmd->request_bufflen != 0) {
 408                 pci_unmap_single(ahd->dev_softc,
 409                                  scb->platform_data->buf_busaddr,
 410                                  cmd->request_bufflen, direction);
 411         }
 412 }
 413
 414 /******************************** Macros **************************************/
 415 #define BUILD_SCSIID(ahd, cmd)                                          \
 416         (((scmd_id(cmd) << TID_SHIFT) & TID) | (ahd)->our_id)
 417
 418 /*
 419  * Return a string describing the driver.
 420  */
 421 static const char *
 422 ahd_linux_info(struct Scsi_Host *host)
 423 {
 424         static char buffer[512];
 425         char    ahd_info[256];
 426         char   *bp;
 427         struct ahd_softc *ahd;
 428
 429         bp = &buffer[0];
 430         ahd = *(struct ahd_softc **)host->hostdata;
 431         memset(bp, 0, sizeof(buffer));
 432         strcpy(bp, "Adaptec AIC79XX PCI-X SCSI HBA DRIVER, Rev ");
 433         strcat(bp, AIC79XX_DRIVER_VERSION);
 434         strcat(bp, "\n");
 435         strcat(bp, "        <");
 436         strcat(bp, ahd->description);
 437         strcat(bp, ">\n");
 438         strcat(bp, "        ");
 439         ahd_controller_info(ahd, ahd_info);
 440         strcat(bp, ahd_info);
 441         strcat(bp, "\n");
 442
 443         return (bp);
 444 }
 445
 446 /*
 447  * Queue an SCB to the controller.
 448  */
 449 static int
 450 ahd_linux_queue(struct scsi_cmnd * cmd, void (*scsi_done) (struct scsi_cmnd *))
 451 {
 452         struct   ahd_softc *ahd;
 453         struct   ahd_linux_device *dev = scsi_transport_device_data(cmd->device);
 454         int rtn = SCSI_MLQUEUE_HOST_BUSY;
 455
 456         ahd = *(struct ahd_softc **)cmd->device->host->hostdata;
 457
 458         cmd->scsi_done = scsi_done;
 459         cmd->result = CAM_REQ_INPROG << 16;
 460         rtn = ahd_linux_run_command(ahd, dev, cmd);
 461
 462         return rtn;
 463 }
 464
 465 static inline struct scsi_target **
 466 ahd_linux_target_in_softc(struct scsi_target *starget)
 467 {
 468         struct  ahd_softc *ahd =
 469                 *((struct ahd_softc **)dev_to_shost(&starget->dev)->hostdata);
 470         unsigned int target_offset;
 471
 472         target_offset = starget->id;
 473         if (starget->channel != 0)
 474                 target_offset += 8;
 475
 476         return &ahd->platform_data->starget[target_offset];
 477 }
 478
 479 static int
 480 ahd_linux_target_alloc(struct scsi_target *starget)
 481 {
 482         struct  ahd_softc *ahd =
 483                 *((struct ahd_softc **)dev_to_shost(&starget->dev)->hostdata);
 484         unsigned long flags;
 485         struct scsi_target **ahd_targp = ahd_linux_target_in_softc(starget);
 486         struct ahd_linux_target *targ = scsi_transport_target_data(starget);
 487         struct ahd_devinfo devinfo;
 488         struct ahd_initiator_tinfo *tinfo;
 489         struct ahd_tmode_tstate *tstate;
 490         char channel = starget->channel + 'A';
 491
 492         ahd_lock(ahd, &flags);
 493
 494         BUG_ON(*ahd_targp != NULL);
 495
 496         *ahd_targp = starget;
 497         memset(targ, 0, sizeof(*targ));
 498
 499         tinfo = ahd_fetch_transinfo(ahd, channel, ahd->our_id,
 500                                     starget->id, &tstate);
 501         ahd_compile_devinfo(&devinfo, ahd->our_id, starget->id,
 502                             CAM_LUN_WILDCARD, channel,
 503                             ROLE_INITIATOR);
 504         spi_min_period(starget) = AHD_SYNCRATE_MAX; /* We can do U320 */
 505         if ((ahd->bugs & AHD_PACED_NEGTABLE_BUG) != 0)
 506                 spi_max_offset(starget) = MAX_OFFSET_PACED_BUG;
 507         else
 508                 spi_max_offset(starget) = MAX_OFFSET_PACED;
 509         spi_max_width(starget) = ahd->features & AHD_WIDE;
 510
 511         ahd_set_syncrate(ahd, &devinfo, 0, 0, 0,
 512                          AHD_TRANS_GOAL, /*paused*/FALSE);
 513         ahd_set_width(ahd, &devinfo, MSG_EXT_WDTR_BUS_8_BIT,
 514                       AHD_TRANS_GOAL, /*paused*/FALSE);
 515         ahd_unlock(ahd, &flags);
 516
 517         return 0;
 518 }
 519
 520 static void
 521 ahd_linux_target_destroy(struct scsi_target *starget)
 522 {
 523         struct scsi_target **ahd_targp = ahd_linux_target_in_softc(starget);
 524
 525         *ahd_targp = NULL;
 526 }
 527
 528 static int
 529 ahd_linux_slave_alloc(struct scsi_device *sdev)
 530 {
 531         struct  ahd_softc *ahd =
 532                 *((struct ahd_softc **)sdev->host->hostdata);
 533         struct scsi_target *starget = sdev->sdev_target;
 534         struct ahd_linux_target *targ = scsi_transport_target_data(starget);
 535         struct ahd_linux_device *dev;
 536
 537         if (bootverbose)
 538                 printf("%s: Slave Alloc %d\n", ahd_name(ahd), sdev->id);
 539
 540         BUG_ON(targ->sdev[sdev->lun] != NULL);
 541
 542         dev = scsi_transport_device_data(sdev);
 543         memset(dev, 0, sizeof(*dev));
 544
 545         /*
 546          * We start out life using untagged
 547          * transactions of which we allow one.
 548          */
 549         dev->openings = 1;
 550
 551         /*
 552          * Set maxtags to 0.  This will be changed if we
 553          * later determine that we are dealing with
 554          * a tagged queuing capable device.
 555          */
 556         dev->maxtags = 0;
 557
 558         targ->sdev[sdev->lun] = sdev;
 559
 560         return (0);
 561 }
 562
 563 static int
 564 ahd_linux_slave_configure(struct scsi_device *sdev)
 565 {
 566         struct  ahd_softc *ahd;
 567
 568         ahd = *((struct ahd_softc **)sdev->host->hostdata);
 569         if (bootverbose)
 570                 sdev_printk(KERN_INFO, sdev, "Slave Configure\n");
 571
 572         ahd_linux_device_queue_depth(sdev);
 573
 574         /* Initial Domain Validation */
 575         if (!spi_initial_dv(sdev->sdev_target))
 576                 spi_dv_device(sdev);
 577
 578         return 0;
 579 }
 580
 581 static void
 582 ahd_linux_slave_destroy(struct scsi_device *sdev)
 583 {
 584         struct  ahd_softc *ahd;
 585         struct  ahd_linux_device *dev = scsi_transport_device_data(sdev);
 586         struct  ahd_linux_target *targ = scsi_transport_target_data(sdev->sdev_target);
 587
 588         ahd = *((struct ahd_softc **)sdev->host->hostdata);
 589         if (bootverbose)
 590                 printf("%s: Slave Destroy %d\n", ahd_name(ahd), sdev->id);
 591
 592         BUG_ON(dev->active);
 593
 594         targ->sdev[sdev->lun] = NULL;
 595
 596 }
 597
 598 #if defined(__i386__)
 599 /*
 600  * Return the disk geometry for the given SCSI device.
 601  */
 602 static int
 603 ahd_linux_biosparam(struct scsi_device *sdev, struct block_device *bdev,
 604                     sector_t capacity, int geom[])
 605 {
 606         uint8_t *bh;
 607         int      heads;
 608         int      sectors;
 609         int      cylinders;
 610         int      ret;
 611         int      extended;
 612         struct   ahd_softc *ahd;
 613
 614         ahd = *((struct ahd_softc **)sdev->host->hostdata);
 615
 616         bh = scsi_bios_ptable(bdev);
 617         if (bh) {
 618                 ret = scsi_partsize(bh, capacity,
 619                                     &geom[2], &geom[0], &geom[1]);
 620                 kfree(bh);
 621                 if (ret != -1)
 622                         return (ret);
 623         }
 624         heads = 64;
 625         sectors = 32;
 626         cylinders = aic_sector_div(capacity, heads, sectors);
 627
 628         if (aic79xx_extended != 0)
 629                 extended = 1;
 630         else
 631                 extended = (ahd->flags & AHD_EXTENDED_TRANS_A) != 0;
 632         if (extended && cylinders >= 1024) {
 633                 heads = 255;
 634                 sectors = 63;
 635                 cylinders = aic_sector_div(capacity, heads, sectors);
 636         }
 637         geom[0] = heads;
 638         geom[1] = sectors;
 639         geom[2] = cylinders;
 640         return (0);
 641 }
 642 #endif
 643
 644 /*
 645  * Abort the current SCSI command(s).
 646  */
 647 static int
 648 ahd_linux_abort(struct scsi_cmnd *cmd)
 649 {
 650         int error;
 651
 652         error = ahd_linux_queue_abort_cmd(cmd);
 653
 654         return error;
 655 }
 656
 657 /*
 658  * Attempt to send a target reset message to the device that timed out.
 659  */
 660 static int
 661 ahd_linux_dev_reset(struct scsi_cmnd *cmd)
 662 {
 663         struct ahd_softc *ahd;
 664         struct ahd_linux_device *dev;
 665         struct scb *reset_scb;
 666         u_int  cdb_byte;
 667         int    retval = SUCCESS;
 668         int    paused;
 669         int    wait;
 670         struct  ahd_initiator_tinfo *tinfo;
 671         struct  ahd_tmode_tstate *tstate;
 672         unsigned long flags;
 673         DECLARE_COMPLETION(done);
 674
 675         reset_scb = NULL;
 676         paused = FALSE;
 677         wait = FALSE;
 678         ahd = *(struct ahd_softc **)cmd->device->host->hostdata;
 679
 680         scmd_printk(KERN_INFO, cmd,
 681                     "Attempting to queue a TARGET RESET message:");
 682
 683         printf("CDB:");
 684         for (cdb_byte = 0; cdb_byte < cmd->cmd_len; cdb_byte++)
 685                 printf(" 0x%x", cmd->cmnd[cdb_byte]);
 686         printf("\n");
 687
 688         /*
 689          * Determine if we currently own this command.
 690          */
 691         dev = scsi_transport_device_data(cmd->device);
 692
 693         if (dev == NULL) {
 694                 /*
 695                  * No target device for this command exists,
 696                  * so we must not still own the command.
 697                  */
 698                 scmd_printk(KERN_INFO, cmd, "Is not an active device\n");
 699                 return SUCCESS;
 700         }
 701
 702         /*
 703          * Generate us a new SCB
 704          */
 705         reset_scb = ahd_get_scb(ahd, AHD_NEVER_COL_IDX);
 706         if (!reset_scb) {
 707                 scmd_printk(KERN_INFO, cmd, "No SCB available\n");
 708                 return FAILED;
 709         }
 710
 711         tinfo = ahd_fetch_transinfo(ahd, 'A', ahd->our_id,
 712                                     cmd->device->id, &tstate);
 713         reset_scb->io_ctx = cmd;
 714         reset_scb->platform_data->dev = dev;
 715         reset_scb->sg_count = 0;
 716         ahd_set_residual(reset_scb, 0);
 717         ahd_set_sense_residual(reset_scb, 0);
 718         reset_scb->platform_data->xfer_len = 0;
 719         reset_scb->hscb->control = 0;
 720         reset_scb->hscb->scsiid = BUILD_SCSIID(ahd,cmd);
 721         reset_scb->hscb->lun = cmd->device->lun;
 722         reset_scb->hscb->cdb_len = 0;
 723         reset_scb->hscb->task_management = SIU_TASKMGMT_LUN_RESET;
 724         reset_scb->flags |= SCB_DEVICE_RESET|SCB_RECOVERY_SCB|SCB_ACTIVE;
 725         if ((tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ) != 0) {
 726                 reset_scb->flags |= SCB_PACKETIZED;
 727         } else {
 728                 reset_scb->hscb->control |= MK_MESSAGE;
 729         }
 730         dev->openings--;
 731         dev->active++;
 732         dev->commands_issued++;
 733
 734         ahd_lock(ahd, &flags);
 735
 736         LIST_INSERT_HEAD(&ahd->pending_scbs, reset_scb, pending_links);
 737         ahd_queue_scb(ahd, reset_scb);
 738
 739         ahd->platform_data->eh_done = &done;
 740         ahd_unlock(ahd, &flags);
 741
 742         printf("%s: Device reset code sleeping\n", ahd_name(ahd));
 743         if (!wait_for_completion_timeout(&done, 5 * HZ)) {
 744                 ahd_lock(ahd, &flags);
 745                 ahd->platform_data->eh_done = NULL;
 746                 ahd_unlock(ahd, &flags);
 747                 printf("%s: Device reset timer expired (active %d)\n",
 748                        ahd_name(ahd), dev->active);
 749                 retval = FAILED;
 750         }
 751         printf("%s: Device reset returning 0x%x\n", ahd_name(ahd), retval);
 752
 753         return (retval);
 754 }
 755
 756 /*
 757  * Reset the SCSI bus.
 758  */
 759 static int
 760 ahd_linux_bus_reset(struct scsi_cmnd *cmd)
 761 {
 762         struct ahd_softc *ahd;
 763         int    found;
 764
 765         ahd = *(struct ahd_softc **)cmd->device->host->hostdata;
 766 #ifdef AHD_DEBUG
 767         if ((ahd_debug & AHD_SHOW_RECOVERY) != 0)
 768                 printf("%s: Bus reset called for cmd %p\n",
 769                        ahd_name(ahd), cmd);
 770 #endif
 771         found = ahd_reset_channel(ahd, scmd_channel(cmd) + 'A',
 772                                   /*initiate reset*/TRUE);
 773
 774         if (bootverbose)
 775                 printf("%s: SCSI bus reset delivered. "
 776                        "%d SCBs aborted.\n", ahd_name(ahd), found);
 777
 778         return (SUCCESS);
 779 }
 780
 781 struct scsi_host_template aic79xx_driver_template = {
 782         .module                 = THIS_MODULE,
 783         .name                   = "aic79xx",
 784         .proc_name              = "aic79xx",
 785         .proc_info              = ahd_linux_proc_info,
 786         .info                   = ahd_linux_info,
 787         .queuecommand           = ahd_linux_queue,
 788         .eh_abort_handler       = ahd_linux_abort,
 789         .eh_device_reset_handler = ahd_linux_dev_reset,
 790         .eh_bus_reset_handler   = ahd_linux_bus_reset,
 791 #if defined(__i386__)
 792         .bios_param             = ahd_linux_biosparam,
 793 #endif
 794         .can_queue              = AHD_MAX_QUEUE,
 795         .this_id                = -1,
 796         .cmd_per_lun            = 2,
 797         .use_clustering         = ENABLE_CLUSTERING,
 798         .slave_alloc            = ahd_linux_slave_alloc,
 799         .slave_configure        = ahd_linux_slave_configure,
 800         .slave_destroy          = ahd_linux_slave_destroy,
 801         .target_alloc           = ahd_linux_target_alloc,
 802         .target_destroy         = ahd_linux_target_destroy,
 803 };
 804
 805 /******************************** Bus DMA *************************************/
 806 int
 807 ahd_dma_tag_create(struct ahd_softc *ahd, bus_dma_tag_t parent,
 808                    bus_size_t alignment, bus_size_t boundary,
 809                    dma_addr_t lowaddr, dma_addr_t highaddr,
 810                    bus_dma_filter_t *filter, void *filterarg,
 811                    bus_size_t maxsize, int nsegments,
 812                    bus_size_t maxsegsz, int flags, bus_dma_tag_t *ret_tag)
 813 {
 814         bus_dma_tag_t dmat;
 815
 816         dmat = malloc(sizeof(*dmat), M_DEVBUF, M_NOWAIT);
 817         if (dmat == NULL)
 818                 return (ENOMEM);
 819
 820         /*
 821          * Linux is very simplistic about DMA memory.  For now don't
 822          * maintain all specification information.  Once Linux supplies
 823          * better facilities for doing these operations, or the
 824          * needs of this particular driver change, we might need to do
 825          * more here.
 826          */
 827         dmat->alignment = alignment;
 828         dmat->boundary = boundary;
 829         dmat->maxsize = maxsize;
 830         *ret_tag = dmat;
 831         return (0);
 832 }
 833
 834 void
 835 ahd_dma_tag_destroy(struct ahd_softc *ahd, bus_dma_tag_t dmat)
 836 {
 837         free(dmat, M_DEVBUF);
 838 }
 839
 840 int
 841 ahd_dmamem_alloc(struct ahd_softc *ahd, bus_dma_tag_t dmat, void** vaddr,
 842                  int flags, bus_dmamap_t *mapp)
 843 {
 844         *vaddr = pci_alloc_consistent(ahd->dev_softc,
 845                                       dmat->maxsize, mapp);
 846         if (*vaddr == NULL)
 847                 return (ENOMEM);
 848         return(0);
 849 }
 850
 851 void
 852 ahd_dmamem_free(struct ahd_softc *ahd, bus_dma_tag_t dmat,
 853                 void* vaddr, bus_dmamap_t map)
 854 {
 855         pci_free_consistent(ahd->dev_softc, dmat->maxsize,
 856                             vaddr, map);
 857 }
 858
 859 int
 860 ahd_dmamap_load(struct ahd_softc *ahd, bus_dma_tag_t dmat, bus_dmamap_t map,
 861                 void *buf, bus_size_t buflen, bus_dmamap_callback_t *cb,
 862                 void *cb_arg, int flags)
 863 {
 864         /*
 865          * Assume for now that this will only be used during
 866          * initialization and not for per-transaction buffer mapping.
 867          */
 868         bus_dma_segment_t stack_sg;
 869
 870         stack_sg.ds_addr = map;
 871         stack_sg.ds_len = dmat->maxsize;
 872         cb(cb_arg, &stack_sg, /*nseg*/1, /*error*/0);
 873         return (0);
 874 }
 875
 876 void
 877 ahd_dmamap_destroy(struct ahd_softc *ahd, bus_dma_tag_t dmat, bus_dmamap_t map)
 878 {
 879 }
 880
 881 int
 882 ahd_dmamap_unload(struct ahd_softc *ahd, bus_dma_tag_t dmat, bus_dmamap_t map)
 883 {
 884         /* Nothing to do */
 885         return (0);
 886 }
 887
 888 /********************* Platform Dependent Functions ***************************/
 889 static void
 890 ahd_linux_setup_iocell_info(u_long index, int instance, int targ, int32_t value)
 891 {
 892
 893         if ((instance >= 0)
 894          && (instance < NUM_ELEMENTS(aic79xx_iocell_info))) {
 895                 uint8_t *iocell_info;
 896
 897                 iocell_info = (uint8_t*)&aic79xx_iocell_info[instance];
 898                 iocell_info[index] = value & 0xFFFF;
 899                 if (bootverbose)
 900                         printf("iocell[%d:%ld] = %d\n", instance, index, value);
 901         }
 902 }
 903
 904 static void
 905 ahd_linux_setup_tag_info_global(char *p)
 906 {
 907         int tags, i, j;
 908
 909         tags = simple_strtoul(p + 1, NULL, 0) & 0xff;
 910         printf("Setting Global Tags= %d\n", tags);
 911
 912         for (i = 0; i < NUM_ELEMENTS(aic79xx_tag_info); i++) {
 913                 for (j = 0; j < AHD_NUM_TARGETS; j++) {
 914                         aic79xx_tag_info[i].tag_commands[j] = tags;
 915                 }
 916         }
 917 }
 918
 919 static void
 920 ahd_linux_setup_tag_info(u_long arg, int instance, int targ, int32_t value)
 921 {
 922
 923         if ((instance >= 0) && (targ >= 0)
 924          && (instance < NUM_ELEMENTS(aic79xx_tag_info))
 925          && (targ < AHD_NUM_TARGETS)) {
 926                 aic79xx_tag_info[instance].tag_commands[targ] = value & 0x1FF;
 927                 if (bootverbose)
 928                         printf("tag_info[%d:%d] = %d\n", instance, targ, value);
 929         }
 930 }
 931
 932 static char *
 933 ahd_parse_brace_option(char *opt_name, char *opt_arg, char *end, int depth,
 934                        void (*callback)(u_long, int, int, int32_t),
 935                        u_long callback_arg)
 936 {
 937         char    *tok_end;
 938         char    *tok_end2;
 939         int      i;
 940         int      instance;
 941         int      targ;
 942         int      done;
 943         char     tok_list[] = {'.', ',', '{', '}', '\0'};
 944
 945         /* All options use a ':' name/arg separator */
 946         if (*opt_arg != ':')
 947                 return (opt_arg);
 948         opt_arg++;
 949         instance = -1;
 950         targ = -1;
 951         done = FALSE;
 952         /*
 953          * Restore separator that may be in
 954          * the middle of our option argument.
 955          */
 956         tok_end = strchr(opt_arg, '\0');
 957         if (tok_end < end)
 958                 *tok_end = ',';
 959         while (!done) {
 960                 switch (*opt_arg) {
 961                 case '{':
 962                         if (instance == -1) {
 963                                 instance = 0;
 964                         } else {
 965                                 if (depth > 1) {
 966                                         if (targ == -1)
 967                                                 targ = 0;
 968                                 } else {
 969                                         printf("Malformed Option %s\n",
 970                                                opt_name);
 971                                         done = TRUE;
 972                                 }
 973                         }
 974                         opt_arg++;
 975                         break;
 976                 case '}':
 977                         if (targ != -1)
 978                                 targ = -1;
 979                         else if (instance != -1)
 980                                 instance = -1;
 981                         opt_arg++;
 982                         break;
 983                 case ',':
 984                 case '.':
 985                         if (instance == -1)
 986                                 done = TRUE;
 987                         else if (targ >= 0)
 988                                 targ++;
 989                         else if (instance >= 0)
 990                                 instance++;
 991                         opt_arg++;
 992                         break;
 993                 case '\0':
 994                         done = TRUE;
 995                         break;
 996                 default:
 997                         tok_end = end;
 998                         for (i = 0; tok_list[i]; i++) {
 999                                 tok_end2 = strchr(opt_arg, tok_list[i]);
1000                                 if ((tok_end2) && (tok_end2 < tok_end))
1001                                         tok_end = tok_end2;
1002                         }
1003                         callback(callback_arg, instance, targ,
1004                                  simple_strtol(opt_arg, NULL, 0));
1005                         opt_arg = tok_end;
1006                         break;
1007                 }
1008         }
1009         return (opt_arg);
1010 }
1011
1012 /*
1013  * Handle Linux boot parameters. This routine allows for assigning a value
1014  * to a parameter with a ':' between the parameter and the value.
1015  * ie. aic79xx=stpwlev:1,extended
1016  */
1017 static int
1018 aic79xx_setup(char *s)
1019 {
1020         int     i, n;
1021         char   *p;
1022         char   *end;
1023
1024         static struct {
1025                 const char *name;
1026                 uint32_t *flag;
1027         } options[] = {
1028                 { "extended", &aic79xx_extended },
1029                 { "no_reset", &aic79xx_no_reset },
1030                 { "verbose", &aic79xx_verbose },
1031                 { "allow_memio", &aic79xx_allow_memio},
1032 #ifdef AHD_DEBUG
1033                 { "debug", &ahd_debug },
1034 #endif
1035                 { "reverse_scan", &aic79xx_reverse_scan },
1036                 { "periodic_otag", &aic79xx_periodic_otag },
1037                 { "pci_parity", &aic79xx_pci_parity },
1038                 { "seltime", &aic79xx_seltime },
1039                 { "tag_info", NULL },
1040                 { "global_tag_depth", NULL},
1041                 { "slewrate", NULL },
1042                 { "precomp", NULL },
1043                 { "amplitude", NULL },
1044                 { "slowcrc", &aic79xx_slowcrc },
1045         };
1046
1047         end = strchr(s, '\0');
1048
1049         /*
1050          * XXX ia64 gcc isn't smart enough to know that NUM_ELEMENTS
1051          * will never be 0 in this case.
1052          */
1053         n = 0;
1054
1055         while ((p = strsep(&s, ",.")) != NULL) {
1056                 if (*p == '\0')
1057                         continue;
1058                 for (i = 0; i < NUM_ELEMENTS(options); i++) {
1059
1060                         n = strlen(options[i].name);
1061                         if (strncmp(options[i].name, p, n) == 0)
1062                                 break;
1063                 }
1064                 if (i == NUM_ELEMENTS(options))
1065                         continue;
1066
1067                 if (strncmp(p, "global_tag_depth", n) == 0) {
1068                         ahd_linux_setup_tag_info_global(p + n);
1069                 } else if (strncmp(p, "tag_info", n) == 0) {
1070                         s = ahd_parse_brace_option("tag_info", p + n, end,
1071                             2, ahd_linux_setup_tag_info, 0);
1072                 } else if (strncmp(p, "slewrate", n) == 0) {
1073                         s = ahd_parse_brace_option("slewrate",
1074                             p + n, end, 1, ahd_linux_setup_iocell_info,
1075                             AIC79XX_SLEWRATE_INDEX);
1076                 } else if (strncmp(p, "precomp", n) == 0) {
1077                         s = ahd_parse_brace_option("precomp",
1078                             p + n, end, 1, ahd_linux_setup_iocell_info,
1079                             AIC79XX_PRECOMP_INDEX);
1080                 } else if (strncmp(p, "amplitude", n) == 0) {
1081                         s = ahd_parse_brace_option("amplitude",
1082                             p + n, end, 1, ahd_linux_setup_iocell_info,
1083                             AIC79XX_AMPLITUDE_INDEX);
1084                 } else if (p[n] == ':') {
1085                         *(options[i].flag) = simple_strtoul(p + n + 1, NULL, 0);
1086                 } else if (!strncmp(p, "verbose", n)) {
1087                         *(options[i].flag) = 1;
1088                 } else {
1089                         *(options[i].flag) ^= 0xFFFFFFFF;
1090                 }
1091         }
1092         return 1;
1093 }
1094
1095 __setup("aic79xx=", aic79xx_setup);
1096
1097 uint32_t aic79xx_verbose;
1098
1099 int
1100 ahd_linux_register_host(struct ahd_softc *ahd, struct scsi_host_template *template)
1101 {
1102         char    buf[80];
1103         struct  Scsi_Host *host;
1104         char    *new_name;
1105         u_long  s;
1106         int     retval;
1107
1108         template->name = ahd->description;
1109         host = scsi_host_alloc(template, sizeof(struct ahd_softc *));
1110         if (host == NULL)
1111                 return (ENOMEM);
1112
1113         *((struct ahd_softc **)host->hostdata) = ahd;
1114         ahd->platform_data->host = host;
1115         host->can_queue = AHD_MAX_QUEUE;
1116         host->cmd_per_lun = 2;
1117         host->sg_tablesize = AHD_NSEG;
1118         host->this_id = ahd->our_id;
1119         host->irq = ahd->platform_data->irq;
1120         host->max_id = (ahd->features & AHD_WIDE) ? 16 : 8;
1121         host->max_lun = AHD_NUM_LUNS;
1122         host->max_channel = 0;
1123         host->sg_tablesize = AHD_NSEG;
1124         ahd_lock(ahd, &s);
1125         ahd_set_unit(ahd, ahd_linux_unit++);
1126         ahd_unlock(ahd, &s);
1127         sprintf(buf, "scsi%d", host->host_no);
1128         new_name = malloc(strlen(buf) + 1, M_DEVBUF, M_NOWAIT);
1129         if (new_name != NULL) {
1130                 strcpy(new_name, buf);
1131                 ahd_set_name(ahd, new_name);
1132         }
1133         host->unique_id = ahd->unit;
1134         ahd_linux_initialize_scsi_bus(ahd);
1135         ahd_intr_enable(ahd, TRUE);
1136
1137         host->transportt = ahd_linux_transport_template;
1138
1139         retval = scsi_add_host(host, &ahd->dev_softc->dev);
1140         if (retval) {
1141                 printk(KERN_WARNING "aic79xx: scsi_add_host failed\n");
1142                 scsi_host_put(host);
1143                 return retval;
1144         }
1145
1146         scsi_scan_host(host);
1147         return 0;
1148 }
1149
1150 uint64_t
1151 ahd_linux_get_memsize(void)
1152 {
1153         struct sysinfo si;
1154
1155         si_meminfo(&si);
1156         return ((uint64_t)si.totalram << PAGE_SHIFT);
1157 }
1158
1159 /*
1160  * Place the SCSI bus into a known state by either resetting it,
1161  * or forcing transfer negotiations on the next command to any
1162  * target.
1163  */
1164 static void
1165 ahd_linux_initialize_scsi_bus(struct ahd_softc *ahd)
1166 {
1167         u_int target_id;
1168         u_int numtarg;
1169         unsigned long s;
1170
1171         target_id = 0;
1172         numtarg = 0;
1173
1174         if (aic79xx_no_reset != 0)
1175                 ahd->flags &= ~AHD_RESET_BUS_A;
1176
1177         if ((ahd->flags & AHD_RESET_BUS_A) != 0)
1178                 ahd_reset_channel(ahd, 'A', /*initiate_reset*/TRUE);
1179         else
1180                 numtarg = (ahd->features & AHD_WIDE) ? 16 : 8;
1181
1182         ahd_lock(ahd, &s);
1183
1184         /*
1185          * Force negotiation to async for all targets that
1186          * will not see an initial bus reset.
1187          */
1188         for (; target_id < numtarg; target_id++) {
1189                 struct ahd_devinfo devinfo;
1190                 struct ahd_initiator_tinfo *tinfo;
1191                 struct ahd_tmode_tstate *tstate;
1192
1193                 tinfo = ahd_fetch_transinfo(ahd, 'A', ahd->our_id,
1194                                             target_id, &tstate);
1195                 ahd_compile_devinfo(&devinfo, ahd->our_id, target_id,
1196                                     CAM_LUN_WILDCARD, 'A', ROLE_INITIATOR);
1197                 ahd_update_neg_request(ahd, &devinfo, tstate,
1198                                        tinfo, AHD_NEG_ALWAYS);
1199         }
1200         ahd_unlock(ahd, &s);
1201         /* Give the bus some time to recover */
1202         if ((ahd->flags & AHD_RESET_BUS_A) != 0) {
1203                 ahd_freeze_simq(ahd);
1204                 msleep(AIC79XX_RESET_DELAY);
1205                 ahd_release_simq(ahd);
1206         }
1207 }
1208
1209 int
1210 ahd_platform_alloc(struct ahd_softc *ahd, void *platform_arg)
1211 {
1212         ahd->platform_data =
1213             malloc(sizeof(struct ahd_platform_data), M_DEVBUF, M_NOWAIT);
1214         if (ahd->platform_data == NULL)
1215                 return (ENOMEM);
1216         memset(ahd->platform_data, 0, sizeof(struct ahd_platform_data));
1217         ahd->platform_data->irq = AHD_LINUX_NOIRQ;
1218         ahd_lockinit(ahd);
1219         ahd->seltime = (aic79xx_seltime & 0x3) << 4;
1220         return (0);
1221 }
1222
1223 void
1224 ahd_platform_free(struct ahd_softc *ahd)
1225 {
1226         struct scsi_target *starget;
1227         int i, j;
1228
1229         if (ahd->platform_data != NULL) {
1230                 /* destroy all of the device and target objects */
1231                 for (i = 0; i < AHD_NUM_TARGETS; i++) {
1232                         starget = ahd->platform_data->starget[i];
1233                         if (starget != NULL) {
1234                                 for (j = 0; j < AHD_NUM_LUNS; j++) {
1235                                         struct ahd_linux_target *targ =
1236                                                 scsi_transport_target_data(starget);
1237                                         if (targ->sdev[j] == NULL)
1238                                                 continue;
1239                                         targ->sdev[j] = NULL;
1240                                 }
1241                                 ahd->platform_data->starget[i] = NULL;
1242                         }
1243                 }
1244
1245                 if (ahd->platform_data->irq != AHD_LINUX_NOIRQ)
1246                         free_irq(ahd->platform_data->irq, ahd);
1247                 if (ahd->tags[0] == BUS_SPACE_PIO
1248                  && ahd->bshs[0].ioport != 0)
1249                         release_region(ahd->bshs[0].ioport, 256);
1250                 if (ahd->tags[1] == BUS_SPACE_PIO
1251                  && ahd->bshs[1].ioport != 0)
1252                         release_region(ahd->bshs[1].ioport, 256);
1253                 if (ahd->tags[0] == BUS_SPACE_MEMIO
1254                  && ahd->bshs[0].maddr != NULL) {
1255                         iounmap(ahd->bshs[0].maddr);
1256                         release_mem_region(ahd->platform_data->mem_busaddr,
1257                                            0x1000);
1258                 }
1259                 if (ahd->platform_data->host)
1260                         scsi_host_put(ahd->platform_data->host);
1261
1262                 free(ahd->platform_data, M_DEVBUF);
1263         }
1264 }
1265
1266 void
1267 ahd_platform_init(struct ahd_softc *ahd)
1268 {
1269         /*
1270          * Lookup and commit any modified IO Cell options.
1271          */
1272         if (ahd->unit < NUM_ELEMENTS(aic79xx_iocell_info)) {
1273                 struct ahd_linux_iocell_opts *iocell_opts;
1274
1275                 iocell_opts = &aic79xx_iocell_info[ahd->unit];
1276                 if (iocell_opts->precomp != AIC79XX_DEFAULT_PRECOMP)
1277                         AHD_SET_PRECOMP(ahd, iocell_opts->precomp);
1278                 if (iocell_opts->slewrate != AIC79XX_DEFAULT_SLEWRATE)
1279                         AHD_SET_SLEWRATE(ahd, iocell_opts->slewrate);
1280                 if (iocell_opts->amplitude != AIC79XX_DEFAULT_AMPLITUDE)
1281                         AHD_SET_AMPLITUDE(ahd, iocell_opts->amplitude);
1282         }
1283
1284 }
1285
1286 void
1287 ahd_platform_freeze_devq(struct ahd_softc *ahd, struct scb *scb)
1288 {
1289         ahd_platform_abort_scbs(ahd, SCB_GET_TARGET(ahd, scb),
1290                                 SCB_GET_CHANNEL(ahd, scb),
1291                                 SCB_GET_LUN(scb), SCB_LIST_NULL,
1292                                 ROLE_UNKNOWN, CAM_REQUEUE_REQ);
1293 }
1294
1295 void
1296 ahd_platform_set_tags(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
1297                       ahd_queue_alg alg)
1298 {
1299         struct scsi_target *starget;
1300         struct ahd_linux_target *targ;
1301         struct ahd_linux_device *dev;
1302         struct scsi_device *sdev;
1303         int was_queuing;
1304         int now_queuing;
1305
1306         starget = ahd->platform_data->starget[devinfo->target];
1307         targ = scsi_transport_target_data(starget);
1308         BUG_ON(targ == NULL);
1309         sdev = targ->sdev[devinfo->lun];
1310         if (sdev == NULL)
1311                 return;
1312
1313         dev = scsi_transport_device_data(sdev);
1314
1315         if (dev == NULL)
1316                 return;
1317         was_queuing = dev->flags & (AHD_DEV_Q_BASIC|AHD_DEV_Q_TAGGED);
1318         switch (alg) {
1319         default:
1320         case AHD_QUEUE_NONE:
1321                 now_queuing = 0;
1322                 break;
1323         case AHD_QUEUE_BASIC:
1324                 now_queuing = AHD_DEV_Q_BASIC;
1325                 break;
1326         case AHD_QUEUE_TAGGED:
1327                 now_queuing = AHD_DEV_Q_TAGGED;
1328                 break;
1329         }
1330         if ((dev->flags & AHD_DEV_FREEZE_TIL_EMPTY) == 0
1331          && (was_queuing != now_queuing)
1332          && (dev->active != 0)) {
1333                 dev->flags |= AHD_DEV_FREEZE_TIL_EMPTY;
1334                 dev->qfrozen++;
1335         }
1336
1337         dev->flags &= ~(AHD_DEV_Q_BASIC|AHD_DEV_Q_TAGGED|AHD_DEV_PERIODIC_OTAG);
1338         if (now_queuing) {
1339                 u_int usertags;
1340
1341                 usertags = ahd_linux_user_tagdepth(ahd, devinfo);
1342                 if (!was_queuing) {
1343                         /*
1344                          * Start out agressively and allow our
1345                          * dynamic queue depth algorithm to take
1346                          * care of the rest.
1347                          */
1348                         dev->maxtags = usertags;
1349                         dev->openings = dev->maxtags - dev->active;
1350                 }
1351                 if (dev->maxtags == 0) {
1352                         /*
1353                          * Queueing is disabled by the user.
1354                          */
1355                         dev->openings = 1;
1356                 } else if (alg == AHD_QUEUE_TAGGED) {
1357                         dev->flags |= AHD_DEV_Q_TAGGED;
1358                         if (aic79xx_periodic_otag != 0)
1359                                 dev->flags |= AHD_DEV_PERIODIC_OTAG;
1360                 } else
1361                         dev->flags |= AHD_DEV_Q_BASIC;
1362         } else {
1363                 /* We can only have one opening. */
1364                 dev->maxtags = 0;
1365                 dev->openings =  1 - dev->active;
1366         }
1367
1368         switch ((dev->flags & (AHD_DEV_Q_BASIC|AHD_DEV_Q_TAGGED))) {
1369         case AHD_DEV_Q_BASIC:
1370                 scsi_set_tag_type(sdev, MSG_SIMPLE_TASK);
1371                 scsi_activate_tcq(sdev, dev->openings + dev->active);
1372                 break;
1373         case AHD_DEV_Q_TAGGED:
1374                 scsi_set_tag_type(sdev, MSG_ORDERED_TASK);
1375                 scsi_activate_tcq(sdev, dev->openings + dev->active);
1376                 break;
1377         default:
1378                 /*
1379                  * We allow the OS to queue 2 untagged transactions to
1380                  * us at any time even though we can only execute them
1381                  * serially on the controller/device.  This should
1382                  * remove some latency.
1383                  */
1384                 scsi_deactivate_tcq(sdev, 1);
1385                 break;
1386         }
1387 }
1388
1389 int
1390 ahd_platform_abort_scbs(struct ahd_softc *ahd, int target, char channel,
1391                         int lun, u_int tag, role_t role, uint32_t status)
1392 {
1393         return 0;
1394 }
1395
1396 static u_int
1397 ahd_linux_user_tagdepth(struct ahd_softc *ahd, struct ahd_devinfo *devinfo)
1398 {
1399         static int warned_user;
1400         u_int tags;
1401
1402         tags = 0;
1403         if ((ahd->user_discenable & devinfo->target_mask) != 0) {
1404                 if (ahd->unit >= NUM_ELEMENTS(aic79xx_tag_info)) {
1405
1406                         if (warned_user == 0) {
1407                                 printf(KERN_WARNING
1408 "aic79xx: WARNING: Insufficient tag_info instances\n"
1409 "aic79xx: for installed controllers.  Using defaults\n"
1410 "aic79xx: Please update the aic79xx_tag_info array in\n"
1411 "aic79xx: the aic79xx_osm.c source file.\n");
1412                                 warned_user++;
1413                         }
1414                         tags = AHD_MAX_QUEUE;
1415                 } else {
1416                         adapter_tag_info_t *tag_info;
1417
1418                         tag_info = &aic79xx_tag_info[ahd->unit];
1419                         tags = tag_info->tag_commands[devinfo->target_offset];
1420                         if (tags > AHD_MAX_QUEUE)
1421                                 tags = AHD_MAX_QUEUE;
1422                 }
1423         }
1424         return (tags);
1425 }
1426
1427 /*
1428  * Determines the queue depth for a given device.
1429  */
1430 static void
1431 ahd_linux_device_queue_depth(struct scsi_device *sdev)
1432 {
1433         struct  ahd_devinfo devinfo;
1434         u_int   tags;
1435         struct ahd_softc *ahd = *((struct ahd_softc **)sdev->host->hostdata);
1436
1437         ahd_compile_devinfo(&devinfo,
1438                             ahd->our_id,
1439                             sdev->sdev_target->id, sdev->lun,
1440                             sdev->sdev_target->channel == 0 ? 'A' : 'B',
1441                             ROLE_INITIATOR);
1442         tags = ahd_linux_user_tagdepth(ahd, &devinfo);
1443         if (tags != 0 && sdev->tagged_supported != 0) {
1444
1445                 ahd_set_tags(ahd, &devinfo, AHD_QUEUE_TAGGED);
1446                 ahd_print_devinfo(ahd, &devinfo);
1447                 printf("Tagged Queuing enabled.  Depth %d\n", tags);
1448         } else {
1449                 ahd_set_tags(ahd, &devinfo, AHD_QUEUE_NONE);
1450         }
1451 }
1452
1453 static int
1454 ahd_linux_run_command(struct ahd_softc *ahd, struct ahd_linux_device *dev,
1455                       struct scsi_cmnd *cmd)
1456 {
1457         struct   scb *scb;
1458         struct   hardware_scb *hscb;
1459         struct   ahd_initiator_tinfo *tinfo;
1460         struct   ahd_tmode_tstate *tstate;
1461         u_int    col_idx;
1462         uint16_t mask;
1463         unsigned long flags;
1464
1465         ahd_lock(ahd, &flags);
1466
1467         /*
1468          * Get an scb to use.
1469          */
1470         tinfo = ahd_fetch_transinfo(ahd, 'A', ahd->our_id,
1471                                     cmd->device->id, &tstate);
1472         if ((dev->flags & (AHD_DEV_Q_TAGGED|AHD_DEV_Q_BASIC)) == 0
1473          || (tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ) != 0) {
1474                 col_idx = AHD_NEVER_COL_IDX;
1475         } else {
1476                 col_idx = AHD_BUILD_COL_IDX(cmd->device->id,
1477                                             cmd->device->lun);
1478         }
1479         if ((scb = ahd_get_scb(ahd, col_idx)) == NULL) {
1480                 ahd->flags |= AHD_RESOURCE_SHORTAGE;
1481                 ahd_unlock(ahd, &flags);
1482                 return SCSI_MLQUEUE_HOST_BUSY;
1483         }
1484
1485         scb->io_ctx = cmd;
1486         scb->platform_data->dev = dev;
1487         hscb = scb->hscb;
1488         cmd->host_scribble = (char *)scb;
1489
1490         /*
1491          * Fill out basics of the HSCB.
1492          */
1493         hscb->control = 0;
1494         hscb->scsiid = BUILD_SCSIID(ahd, cmd);
1495         hscb->lun = cmd->device->lun;
1496         scb->hscb->task_management = 0;
1497         mask = SCB_GET_TARGET_MASK(ahd, scb);
1498
1499         if ((ahd->user_discenable & mask) != 0)
1500                 hscb->control |= DISCENB;
1501
1502         if ((tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ) != 0)
1503                 scb->flags |= SCB_PACKETIZED;
1504
1505         if ((tstate->auto_negotiate & mask) != 0) {
1506                 scb->flags |= SCB_AUTO_NEGOTIATE;
1507                 scb->hscb->control |= MK_MESSAGE;
1508                 } else if (cmd->cmnd[0] == INQUIRY
1509                         && (tinfo->curr.offset != 0
1510                          || tinfo->curr.width != MSG_EXT_WDTR_BUS_8_BIT
1511                          || tinfo->curr.ppr_options != 0)
1512                         && (tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ)==0) {
1513                         /*
1514                          * The SCSI spec requires inquiry
1515                          * commands to complete without
1516                          * reporting unit attention conditions.
1517                          * Because of this, an inquiry command
1518                          * that occurs just after a device is
1519                          * reset will result in a data phase
1520                          * with mismatched negotiated rates.
1521                          * The core already forces a renegotiation
1522                          * for reset events that are visible to
1523                          * our controller or that we initiate,
1524                          * but a third party device reset or a
1525                          * hot-plug insertion can still cause this
1526                          * issue.  Therefore, we force a re-negotiation
1527                          * for every inquiry command unless we
1528                          * are async.
1529                          */
1530                         scb->flags |= SCB_NEGOTIATE;
1531                         scb->hscb->control |= MK_MESSAGE;
1532         }
1533
1534         if ((dev->flags & (AHD_DEV_Q_TAGGED|AHD_DEV_Q_BASIC)) != 0) {
1535                 int     msg_bytes;
1536                 uint8_t tag_msgs[2];
1537
1538                 msg_bytes = scsi_populate_tag_msg(cmd, tag_msgs);
1539                 if (msg_bytes && tag_msgs[0] != MSG_SIMPLE_TASK) {
1540                         hscb->control |= tag_msgs[0];
1541                         if (tag_msgs[0] == MSG_ORDERED_TASK)
1542                                 dev->commands_since_idle_or_otag = 0;
1543                 } else
1544                 if (dev->commands_since_idle_or_otag == AHD_OTAG_THRESH
1545                  && (dev->flags & AHD_DEV_Q_TAGGED) != 0) {
1546                         hscb->control |= MSG_ORDERED_TASK;
1547                         dev->commands_since_idle_or_otag = 0;
1548                 } else {
1549                         hscb->control |= MSG_SIMPLE_TASK;
1550                 }
1551         }
1552
1553         hscb->cdb_len = cmd->cmd_len;
1554         memcpy(hscb->shared_data.idata.cdb, cmd->cmnd, hscb->cdb_len);
1555
1556         scb->platform_data->xfer_len = 0;
1557         ahd_set_residual(scb, 0);
1558         ahd_set_sense_residual(scb, 0);
1559         scb->sg_count = 0;
1560         if (cmd->use_sg != 0) {
1561                 void    *sg;
1562                 struct   scatterlist *cur_seg;
1563                 u_int    nseg;
1564                 int      dir;
1565
1566                 cur_seg = (struct scatterlist *)cmd->request_buffer;
1567                 dir = cmd->sc_data_direction;
1568                 nseg = pci_map_sg(ahd->dev_softc, cur_seg,
1569                                   cmd->use_sg, dir);
1570                 scb->platform_data->xfer_len = 0;
1571                 for (sg = scb->sg_list; nseg > 0; nseg--, cur_seg++) {
1572                         dma_addr_t addr;
1573                         bus_size_t len;
1574
1575                         addr = sg_dma_address(cur_seg);
1576                         len = sg_dma_len(cur_seg);
1577                         scb->platform_data->xfer_len += len;
1578                         sg = ahd_sg_setup(ahd, scb, sg, addr, len,
1579                                           /*last*/nseg == 1);
1580                 }
1581         } else if (cmd->request_bufflen != 0) {
1582                 void *sg;
1583                 dma_addr_t addr;
1584                 int dir;
1585
1586                 sg = scb->sg_list;
1587                 dir = cmd->sc_data_direction;
1588                 addr = pci_map_single(ahd->dev_softc,
1589                                       cmd->request_buffer,
1590                                       cmd->request_bufflen, dir);
1591                 scb->platform_data->xfer_len = cmd->request_bufflen;
1592                 scb->platform_data->buf_busaddr = addr;
1593                 sg = ahd_sg_setup(ahd, scb, sg, addr,
1594                                   cmd->request_bufflen, /*last*/TRUE);
1595         }
1596
1597         LIST_INSERT_HEAD(&ahd->pending_scbs, scb, pending_links);
1598         dev->openings--;
1599         dev->active++;
1600         dev->commands_issued++;
1601
1602         if ((dev->flags & AHD_DEV_PERIODIC_OTAG) != 0)
1603                 dev->commands_since_idle_or_otag++;
1604         scb->flags |= SCB_ACTIVE;
1605         ahd_queue_scb(ahd, scb);
1606
1607         ahd_unlock(ahd, &flags);
1608
1609         return 0;
1610 }
1611
1612 /*
1613  * SCSI controller interrupt handler.
1614  */
1615 irqreturn_t
1616 ahd_linux_isr(int irq, void *dev_id, struct pt_regs * regs)
1617 {
1618         struct  ahd_softc *ahd;
1619         u_long  flags;
1620         int     ours;
1621
1622         ahd = (struct ahd_softc *) dev_id;
1623         ahd_lock(ahd, &flags);
1624         ours = ahd_intr(ahd);
1625         ahd_unlock(ahd, &flags);
1626         return IRQ_RETVAL(ours);
1627 }
1628
1629 void
1630 ahd_send_async(struct ahd_softc *ahd, char channel,
1631                u_int target, u_int lun, ac_code code, void *arg)
1632 {
1633         switch (code) {
1634         case AC_TRANSFER_NEG:
1635         {
1636                 char    buf[80];
1637                 struct  scsi_target *starget;
1638                 struct  info_str info;
1639                 struct  ahd_initiator_tinfo *tinfo;
1640                 struct  ahd_tmode_tstate *tstate;
1641                 unsigned int target_ppr_options;
1642
1643                 BUG_ON(target == CAM_TARGET_WILDCARD);
1644
1645                 info.buffer = buf;
1646                 info.length = sizeof(buf);
1647                 info.offset = 0;
1648                 info.pos = 0;
1649                 tinfo = ahd_fetch_transinfo(ahd, channel, ahd->our_id,
1650                                             target, &tstate);
1651
1652                 /*
1653                  * Don't bother reporting results while
1654                  * negotiations are still pending.
1655                  */
1656                 if (tinfo->curr.period != tinfo->goal.period
1657                  || tinfo->curr.width != tinfo->goal.width
1658                  || tinfo->curr.offset != tinfo->goal.offset
1659                  || tinfo->curr.ppr_options != tinfo->goal.ppr_options)
1660                         if (bootverbose == 0)
1661                                 break;
1662
1663                 /*
1664                  * Don't bother reporting results that
1665                  * are identical to those last reported.
1666                  */
1667                 starget = ahd->platform_data->starget[target];
1668                 if (starget == NULL)
1669                         break;
1670
1671                 target_ppr_options =
1672                         (spi_dt(starget) ? MSG_EXT_PPR_DT_REQ : 0)
1673                         + (spi_qas(starget) ? MSG_EXT_PPR_QAS_REQ : 0)
1674                         + (spi_iu(starget) ?  MSG_EXT_PPR_IU_REQ : 0)
1675                         + (spi_rd_strm(starget) ? MSG_EXT_PPR_RD_STRM : 0)
1676                         + (spi_pcomp_en(starget) ? MSG_EXT_PPR_PCOMP_EN : 0)
1677                         + (spi_rti(starget) ? MSG_EXT_PPR_RTI : 0)
1678                         + (spi_wr_flow(starget) ? MSG_EXT_PPR_WR_FLOW : 0)
1679                         + (spi_hold_mcs(starget) ? MSG_EXT_PPR_HOLD_MCS : 0);
1680
1681                 if (tinfo->curr.period == spi_period(starget)
1682                     && tinfo->curr.width == spi_width(starget)
1683                     && tinfo->curr.offset == spi_offset(starget)
1684                  && tinfo->curr.ppr_options == target_ppr_options)
1685                         if (bootverbose == 0)
1686                                 break;
1687
1688                 spi_period(starget) = tinfo->curr.period;
1689                 spi_width(starget) = tinfo->curr.width;
1690                 spi_offset(starget) = tinfo->curr.offset;
1691                 spi_dt(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_DT_REQ ? 1 : 0;
1692                 spi_qas(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_QAS_REQ ? 1 : 0;
1693                 spi_iu(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ ? 1 : 0;
1694                 spi_rd_strm(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_RD_STRM ? 1 : 0;
1695                 spi_pcomp_en(starget) =  tinfo->curr.ppr_options & MSG_EXT_PPR_PCOMP_EN ? 1 : 0;
1696                 spi_rti(starget) =  tinfo->curr.ppr_options &  MSG_EXT_PPR_RTI ? 1 : 0;
1697                 spi_wr_flow(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_WR_FLOW ? 1 : 0;
1698                 spi_hold_mcs(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_HOLD_MCS ? 1 : 0;
1699                 spi_display_xfer_agreement(starget);
1700                 break;
1701         }
1702         case AC_SENT_BDR:
1703         {
1704                 WARN_ON(lun != CAM_LUN_WILDCARD);
1705                 scsi_report_device_reset(ahd->platform_data->host,
1706                                          channel - 'A', target);
1707                 break;
1708         }
1709         case AC_BUS_RESET:
1710                 if (ahd->platform_data->host != NULL) {
1711                         scsi_report_bus_reset(ahd->platform_data->host,
1712                                               channel - 'A');
1713                 }
1714                 break;
1715         default:
1716                 panic("ahd_send_async: Unexpected async event");
1717         }
1718 }
1719
1720 /*
1721  * Calls the higher level scsi done function and frees the scb.
1722  */
1723 void
1724 ahd_done(struct ahd_softc *ahd, struct scb *scb)
1725 {
1726         struct scsi_cmnd *cmd;
1727         struct    ahd_linux_device *dev;
1728
1729         if ((scb->flags & SCB_ACTIVE) == 0) {
1730                 printf("SCB %d done'd twice\n", SCB_GET_TAG(scb));
1731                 ahd_dump_card_state(ahd);
1732                 panic("Stopping for safety");
1733         }
1734         LIST_REMOVE(scb, pending_links);
1735         cmd = scb->io_ctx;
1736         dev = scb->platform_data->dev;
1737         dev->active--;
1738         dev->openings++;
1739         if ((cmd->result & (CAM_DEV_QFRZN << 16)) != 0) {
1740                 cmd->result &= ~(CAM_DEV_QFRZN << 16);
1741                 dev->qfrozen--;
1742         }
1743         ahd_linux_unmap_scb(ahd, scb);
1744
1745         /*
1746          * Guard against stale sense data.
1747          * The Linux mid-layer assumes that sense
1748          * was retrieved anytime the first byte of
1749          * the sense buffer looks "sane".
1750          */
1751         cmd->sense_buffer[0] = 0;
1752         if (ahd_get_transaction_status(scb) == CAM_REQ_INPROG) {
1753                 uint32_t amount_xferred;
1754
1755                 amount_xferred =
1756                     ahd_get_transfer_length(scb) - ahd_get_residual(scb);
1757                 if ((scb->flags & SCB_TRANSMISSION_ERROR) != 0) {
1758 #ifdef AHD_DEBUG
1759                         if ((ahd_debug & AHD_SHOW_MISC) != 0) {
1760                                 ahd_print_path(ahd, scb);
1761                                 printf("Set CAM_UNCOR_PARITY\n");
1762                         }
1763 #endif
1764                         ahd_set_transaction_status(scb, CAM_UNCOR_PARITY);
1765 #ifdef AHD_REPORT_UNDERFLOWS
1766                 /*
1767                  * This code is disabled by default as some
1768                  * clients of the SCSI system do not properly
1769                  * initialize the underflow parameter.  This
1770                  * results in spurious termination of commands
1771                  * that complete as expected (e.g. underflow is
1772                  * allowed as command can return variable amounts
1773                  * of data.
1774                  */
1775                 } else if (amount_xferred < scb->io_ctx->underflow) {
1776                         u_int i;
1777
1778                         ahd_print_path(ahd, scb);
1779                         printf("CDB:");
1780                         for (i = 0; i < scb->io_ctx->cmd_len; i++)
1781                                 printf(" 0x%x", scb->io_ctx->cmnd[i]);
1782                         printf("\n");
1783                         ahd_print_path(ahd, scb);
1784                         printf("Saw underflow (%ld of %ld bytes). "
1785                                "Treated as error\n",
1786                                 ahd_get_residual(scb),
1787                                 ahd_get_transfer_length(scb));
1788                         ahd_set_transaction_status(scb, CAM_DATA_RUN_ERR);
1789 #endif
1790                 } else {
1791                         ahd_set_transaction_status(scb, CAM_REQ_CMP);
1792                 }
1793         } else if (ahd_get_transaction_status(scb) == CAM_SCSI_STATUS_ERROR) {
1794                 ahd_linux_handle_scsi_status(ahd, cmd->device, scb);
1795         }
1796
1797         if (dev->openings == 1
1798          && ahd_get_transaction_status(scb) == CAM_REQ_CMP
1799          && ahd_get_scsi_status(scb) != SCSI_STATUS_QUEUE_FULL)
1800                 dev->tag_success_count++;
1801         /*
1802          * Some devices deal with temporary internal resource
1803          * shortages by returning queue full.  When the queue
1804          * full occurrs, we throttle back.  Slowly try to get
1805          * back to our previous queue depth.
1806          */
1807         if ((dev->openings + dev->active) < dev->maxtags
1808          && dev->tag_success_count > AHD_TAG_SUCCESS_INTERVAL) {
1809                 dev->tag_success_count = 0;
1810                 dev->openings++;
1811         }
1812
1813         if (dev->active == 0)
1814                 dev->commands_since_idle_or_otag = 0;
1815
1816         if ((scb->flags & SCB_RECOVERY_SCB) != 0) {
1817                 printf("Recovery SCB completes\n");
1818                 if (ahd_get_transaction_status(scb) == CAM_BDR_SENT
1819                  || ahd_get_transaction_status(scb) == CAM_REQ_ABORTED)
1820                         ahd_set_transaction_status(scb, CAM_CMD_TIMEOUT);
1821
1822                 if (ahd->platform_data->eh_done)
1823                         complete(ahd->platform_data->eh_done);
1824         }
1825
1826         ahd_free_scb(ahd, scb);
1827         ahd_linux_queue_cmd_complete(ahd, cmd);
1828 }
1829
1830 static void
1831 ahd_linux_handle_scsi_status(struct ahd_softc *ahd,
1832                              struct scsi_device *sdev, struct scb *scb)
1833 {
1834         struct  ahd_devinfo devinfo;
1835         struct ahd_linux_device *dev = scsi_transport_device_data(sdev);
1836
1837         ahd_compile_devinfo(&devinfo,
1838                             ahd->our_id,
1839                             sdev->sdev_target->id, sdev->lun,
1840                             sdev->sdev_target->channel == 0 ? 'A' : 'B',
1841                             ROLE_INITIATOR);
1842
1843         /*
1844          * We don't currently trust the mid-layer to
1845          * properly deal with queue full or busy.  So,
1846          * when one occurs, we tell the mid-layer to
1847          * unconditionally requeue the command to us
1848          * so that we can retry it ourselves.  We also
1849          * implement our own throttling mechanism so
1850          * we don't clobber the device with too many
1851          * commands.
1852          */
1853         switch (ahd_get_scsi_status(scb)) {
1854         default:
1855                 break;
1856         case SCSI_STATUS_CHECK_COND:
1857         case SCSI_STATUS_CMD_TERMINATED:
1858         {
1859                 struct scsi_cmnd *cmd;
1860
1861                 /*
1862                  * Copy sense information to the OS's cmd
1863                  * structure if it is available.
1864                  */
1865                 cmd = scb->io_ctx;
1866                 if ((scb->flags & (SCB_SENSE|SCB_PKT_SENSE)) != 0) {
1867                         struct scsi_status_iu_header *siu;
1868                         u_int sense_size;
1869                         u_int sense_offset;
1870
1871                         if (scb->flags & SCB_SENSE) {
1872                                 sense_size = MIN(sizeof(struct scsi_sense_data)
1873                                                - ahd_get_sense_residual(scb),
1874                                                  sizeof(cmd->sense_buffer));
1875                                 sense_offset = 0;
1876                         } else {
1877                                 /*
1878                                  * Copy only the sense data into the provided
1879                                  * buffer.
1880                                  */
1881                                 siu = (struct scsi_status_iu_header *)
1882                                     scb->sense_data;
1883                                 sense_size = MIN(scsi_4btoul(siu->sense_length),
1884                                                 sizeof(cmd->sense_buffer));
1885                                 sense_offset = SIU_SENSE_OFFSET(siu);
1886                         }
1887
1888                         memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
1889                         memcpy(cmd->sense_buffer,
1890                                ahd_get_sense_buf(ahd, scb)
1891                                + sense_offset, sense_size);
1892                         cmd->result |= (DRIVER_SENSE << 24);
1893
1894 #ifdef AHD_DEBUG
1895                         if (ahd_debug & AHD_SHOW_SENSE) {
1896                                 int i;
1897
1898                                 printf("Copied %d bytes of sense data at %d:",
1899                                        sense_size, sense_offset);
1900                                 for (i = 0; i < sense_size; i++) {
1901                                         if ((i & 0xF) == 0)
1902                                                 printf("\n");
1903                                         printf("0x%x ", cmd->sense_buffer[i]);
1904                                 }
1905                                 printf("\n");
1906                         }
1907 #endif
1908                 }
1909                 break;
1910         }
1911         case SCSI_STATUS_QUEUE_FULL:
1912                 /*
1913                  * By the time the core driver has returned this
1914                  * command, all other commands that were queued
1915                  * to us but not the device have been returned.
1916                  * This ensures that dev->active is equal to
1917                  * the number of commands actually queued to
1918                  * the device.
1919                  */
1920                 dev->tag_success_count = 0;
1921                 if (dev->active != 0) {
1922                         /*
1923                          * Drop our opening count to the number
1924                          * of commands currently outstanding.
1925                          */
1926                         dev->openings = 0;
1927 #ifdef AHD_DEBUG
1928                         if ((ahd_debug & AHD_SHOW_QFULL) != 0) {
1929                                 ahd_print_path(ahd, scb);
1930                                 printf("Dropping tag count to %d\n",
1931                                        dev->active);
1932                         }
1933 #endif
1934                         if (dev->active == dev->tags_on_last_queuefull) {
1935
1936                                 dev->last_queuefull_same_count++;
1937                                 /*
1938                                  * If we repeatedly see a queue full
1939                                  * at the same queue depth, this
1940                                  * device has a fixed number of tag
1941                                  * slots.  Lock in this tag depth
1942                                  * so we stop seeing queue fulls from
1943                                  * this device.
1944                                  */
1945                                 if (dev->last_queuefull_same_count
1946                                  == AHD_LOCK_TAGS_COUNT) {
1947                                         dev->maxtags = dev->active;
1948                                         ahd_print_path(ahd, scb);
1949                                         printf("Locking max tag count at %d\n",
1950                                                dev->active);
1951                                 }
1952                         } else {
1953                                 dev->tags_on_last_queuefull = dev->active;
1954                                 dev->last_queuefull_same_count = 0;
1955                         }
1956                         ahd_set_transaction_status(scb, CAM_REQUEUE_REQ);
1957                         ahd_set_scsi_status(scb, SCSI_STATUS_OK);
1958                         ahd_platform_set_tags(ahd, &devinfo,
1959                                      (dev->flags & AHD_DEV_Q_BASIC)
1960                                    ? AHD_QUEUE_BASIC : AHD_QUEUE_TAGGED);
1961                         break;
1962                 }
1963                 /*
1964                  * Drop down to a single opening, and treat this
1965                  * as if the target returned BUSY SCSI status.
1966                  */
1967                 dev->openings = 1;
1968                 ahd_platform_set_tags(ahd, &devinfo,
1969                              (dev->flags & AHD_DEV_Q_BASIC)
1970                            ? AHD_QUEUE_BASIC : AHD_QUEUE_TAGGED);
1971                 ahd_set_scsi_status(scb, SCSI_STATUS_BUSY);
1972         }
1973 }
1974
1975 static void
1976 ahd_linux_queue_cmd_complete(struct ahd_softc *ahd, struct scsi_cmnd *cmd)
1977 {
1978         int status;
1979         int new_status = DID_OK;
1980         int do_fallback = 0;
1981         int scsi_status;
1982
1983         /*
1984          * Map CAM error codes into Linux Error codes.  We
1985          * avoid the conversion so that the DV code has the
1986          * full error information available when making
1987          * state change decisions.
1988          */
1989
1990         status = ahd_cmd_get_transaction_status(cmd);
1991         switch (status) {
1992         case CAM_REQ_INPROG:
1993         case CAM_REQ_CMP:
1994                 new_status = DID_OK;
1995                 break;
1996         case CAM_AUTOSENSE_FAIL:
1997                 new_status = DID_ERROR;
1998                 /* Fallthrough */
1999         case CAM_SCSI_STATUS_ERROR:
2000                 scsi_status = ahd_cmd_get_scsi_status(cmd);
2001
2002                 switch(scsi_status) {
2003                 case SCSI_STATUS_CMD_TERMINATED:
2004                 case SCSI_STATUS_CHECK_COND:
2005                         if ((cmd->result >> 24) != DRIVER_SENSE) {
2006                                 do_fallback = 1;
2007                         } else {
2008                                 struct scsi_sense_data *sense;
2009
2010                                 sense = (struct scsi_sense_data *)
2011                                         &cmd->sense_buffer;
2012                                 if (sense->extra_len >= 5 &&
2013                                     (sense->add_sense_code == 0x47
2014                                      || sense->add_sense_code == 0x48))
2015                                         do_fallback = 1;
2016                         }
2017                         break;
2018                 default:
2019                         break;
2020                 }
2021                 break;
2022         case CAM_REQ_ABORTED:
2023                 new_status = DID_ABORT;
2024                 break;
2025         case CAM_BUSY:
2026                 new_status = DID_BUS_BUSY;
2027                 break;
2028         case CAM_REQ_INVALID:
2029         case CAM_PATH_INVALID:
2030                 new_status = DID_BAD_TARGET;
2031                 break;
2032         case CAM_SEL_TIMEOUT:
2033                 new_status = DID_NO_CONNECT;
2034                 break;
2035         case CAM_SCSI_BUS_RESET:
2036         case CAM_BDR_SENT:
2037                 new_status = DID_RESET;
2038                 break;
2039         case CAM_UNCOR_PARITY:
2040                 new_status = DID_PARITY;
2041                 do_fallback = 1;
2042                 break;
2043         case CAM_CMD_TIMEOUT:
2044                 new_status = DID_TIME_OUT;
2045                 do_fallback = 1;
2046                 break;
2047         case CAM_REQ_CMP_ERR:
2048         case CAM_UNEXP_BUSFREE:
2049         case CAM_DATA_RUN_ERR:
2050                 new_status = DID_ERROR;
2051                 do_fallback = 1;
2052                 break;
2053         case CAM_UA_ABORT:
2054         case CAM_NO_HBA:
2055         case CAM_SEQUENCE_FAIL:
2056         case CAM_CCB_LEN_ERR:
2057         case CAM_PROVIDE_FAIL:
2058         case CAM_REQ_TERMIO:
2059         case CAM_UNREC_HBA_ERROR:
2060         case CAM_REQ_TOO_BIG:
2061                 new_status = DID_ERROR;
2062                 break;
2063         case CAM_REQUEUE_REQ:
2064                 new_status = DID_REQUEUE;
2065                 break;
2066         default:
2067                 /* We should never get here */
2068                 new_status = DID_ERROR;
2069                 break;
2070         }
2071
2072         if (do_fallback) {
2073                 printf("%s: device overrun (status %x) on %d:%d:%d\n",
2074                        ahd_name(ahd), status, cmd->device->channel,
2075                        cmd->device->id, cmd->device->lun);
2076         }
2077
2078         ahd_cmd_set_transaction_status(cmd, new_status);
2079
2080         cmd->scsi_done(cmd);
2081 }
2082
2083 void
2084 ahd_freeze_simq(struct ahd_softc *ahd)
2085 {
2086         scsi_block_requests(ahd->platform_data->host);
2087 }
2088
2089 void
2090 ahd_release_simq(struct ahd_softc *ahd)
2091 {
2092         scsi_unblock_requests(ahd->platform_data->host);
2093 }
2094
2095 static int
2096 ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd)
2097 {
2098         struct ahd_softc *ahd;
2099         struct ahd_linux_device *dev;
2100         struct scb *pending_scb;
2101         u_int  saved_scbptr;
2102         u_int  active_scbptr;
2103         u_int  last_phase;
2104         u_int  saved_scsiid;
2105         u_int  cdb_byte;
2106         int    retval;
2107         int    was_paused;
2108         int    paused;
2109         int    wait;
2110         int    disconnected;
2111         ahd_mode_state saved_modes;
2112         unsigned long flags;
2113
2114         pending_scb = NULL;
2115         paused = FALSE;
2116         wait = FALSE;
2117         ahd = *(struct ahd_softc **)cmd->device->host->hostdata;
2118
2119         scmd_printk(KERN_INFO, cmd,
2120                     "Attempting to queue an ABORT message:");
2121
2122         printf("CDB:");
2123         for (cdb_byte = 0; cdb_byte < cmd->cmd_len; cdb_byte++)
2124                 printf(" 0x%x", cmd->cmnd[cdb_byte]);
2125         printf("\n");
2126
2127         ahd_lock(ahd, &flags);
2128
2129         /*
2130          * First determine if we currently own this command.
2131          * Start by searching the device queue.  If not found
2132          * there, check the pending_scb list.  If not found
2133          * at all, and the system wanted us to just abort the
2134          * command, return success.
2135          */
2136         dev = scsi_transport_device_data(cmd->device);
2137
2138         if (dev == NULL) {
2139                 /*
2140                  * No target device for this command exists,
2141                  * so we must not still own the command.
2142                  */
2143                 scmd_printk(KERN_INFO, cmd, "Is not an active device\n");
2144                 retval = SUCCESS;
2145                 goto no_cmd;
2146         }
2147
2148         /*
2149          * See if we can find a matching cmd in the pending list.
2150          */
2151         LIST_FOREACH(pending_scb, &ahd->pending_scbs, pending_links) {
2152                 if (pending_scb->io_ctx == cmd)
2153                         break;
2154         }
2155
2156         if (pending_scb == NULL) {
2157                 scmd_printk(KERN_INFO, cmd, "Command not found\n");
2158                 goto no_cmd;
2159         }
2160
2161         if ((pending_scb->flags & SCB_RECOVERY_SCB) != 0) {
2162                 /*
2163                  * We can't queue two recovery actions using the same SCB
2164                  */
2165                 retval = FAILED;
2166                 goto  done;
2167         }
2168
2169         /*
2170          * Ensure that the card doesn't do anything
2171          * behind our back.  Also make sure that we
2172          * didn't "just" miss an interrupt that would
2173          * affect this cmd.
2174          */
2175         was_paused = ahd_is_paused(ahd);
2176         ahd_pause_and_flushwork(ahd);
2177         paused = TRUE;
2178
2179         if ((pending_scb->flags & SCB_ACTIVE) == 0) {
2180                 scmd_printk(KERN_INFO, cmd, "Command already completed\n");
2181                 goto no_cmd;
2182         }
2183
2184         printf("%s: At time of recovery, card was %spaused\n",
2185                ahd_name(ahd), was_paused ? "" : "not ");
2186         ahd_dump_card_state(ahd);
2187
2188         disconnected = TRUE;
2189         if (ahd_search_qinfifo(ahd, cmd->device->id,
2190                                cmd->device->channel + 'A',
2191                                cmd->device->lun,
2192                                pending_scb->hscb->tag,
2193                                ROLE_INITIATOR, CAM_REQ_ABORTED,
2194                                SEARCH_COMPLETE) > 0) {
2195                 printf("%s:%d:%d:%d: Cmd aborted from QINFIFO\n",
2196                        ahd_name(ahd), cmd->device->channel,
2197                        cmd->device->id, cmd->device->lun);
2198                 retval = SUCCESS;
2199                 goto done;
2200         }
2201
2202         saved_modes = ahd_save_modes(ahd);
2203         ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
2204         last_phase = ahd_inb(ahd, LASTPHASE);
2205         saved_scbptr = ahd_get_scbptr(ahd);
2206         active_scbptr = saved_scbptr;
2207         if (disconnected && (ahd_inb(ahd, SEQ_FLAGS) & NOT_IDENTIFIED) == 0) {
2208                 struct scb *bus_scb;
2209
2210                 bus_scb = ahd_lookup_scb(ahd, active_scbptr);
2211                 if (bus_scb == pending_scb)
2212                         disconnected = FALSE;
2213         }
2214
2215         /*
2216          * At this point, pending_scb is the scb associated with the
2217          * passed in command.  That command is currently active on the
2218          * bus or is in the disconnected state.
2219          */
2220         saved_scsiid = ahd_inb(ahd, SAVED_SCSIID);
2221         if (last_phase != P_BUSFREE
2222             && SCB_GET_TAG(pending_scb) == active_scbptr) {
2223
2224                 /*
2225                  * We're active on the bus, so assert ATN
2226                  * and hope that the target responds.
2227                  */
2228                 pending_scb = ahd_lookup_scb(ahd, active_scbptr);
2229                 pending_scb->flags |= SCB_RECOVERY_SCB|SCB_ABORT;
2230                 ahd_outb(ahd, MSG_OUT, HOST_MSG);
2231                 ahd_outb(ahd, SCSISIGO, last_phase|ATNO);
2232                 scmd_printk(KERN_INFO, cmd, "Device is active, asserting ATN\n");
2233                 wait = TRUE;
2234         } else if (disconnected) {
2235
2236                 /*
2237                  * Actually re-queue this SCB in an attempt
2238                  * to select the device before it reconnects.
2239                  */
2240                 pending_scb->flags |= SCB_RECOVERY_SCB|SCB_ABORT;
2241                 ahd_set_scbptr(ahd, SCB_GET_TAG(pending_scb));
2242                 pending_scb->hscb->cdb_len = 0;
2243                 pending_scb->hscb->task_attribute = 0;
2244                 pending_scb->hscb->task_management = SIU_TASKMGMT_ABORT_TASK;
2245
2246                 if ((pending_scb->flags & SCB_PACKETIZED) != 0) {
2247                         /*
2248                          * Mark the SCB has having an outstanding
2249                          * task management function.  Should the command
2250                          * complete normally before the task management
2251                          * function can be sent, the host will be notified
2252                          * to abort our requeued SCB.
2253                          */
2254                         ahd_outb(ahd, SCB_TASK_MANAGEMENT,
2255                                  pending_scb->hscb->task_management);
2256                 } else {
2257                         /*
2258                          * If non-packetized, set the MK_MESSAGE control
2259                          * bit indicating that we desire to send a message.
2260                          * We also set the disconnected flag since there is
2261                          * no guarantee that our SCB control byte matches
2262                          * the version on the card.  We don't want the
2263                          * sequencer to abort the command thinking an
2264                          * unsolicited reselection occurred.
2265                          */
2266                         pending_scb->hscb->control |= MK_MESSAGE|DISCONNECTED;
2267
2268                         /*
2269                          * The sequencer will never re-reference the
2270                          * in-core SCB.  To make sure we are notified
2271                          * during reslection, set the MK_MESSAGE flag in
2272                          * the card's copy of the SCB.
2273                          */
2274                         ahd_outb(ahd, SCB_CONTROL,
2275                                  ahd_inb(ahd, SCB_CONTROL)|MK_MESSAGE);
2276                 }
2277
2278                 /*
2279                  * Clear out any entries in the QINFIFO first
2280                  * so we are the next SCB for this target
2281                  * to run.
2282                  */
2283                 ahd_search_qinfifo(ahd, cmd->device->id,
2284                                    cmd->device->channel + 'A', cmd->device->lun,
2285                                    SCB_LIST_NULL, ROLE_INITIATOR,
2286                                    CAM_REQUEUE_REQ, SEARCH_COMPLETE);
2287                 ahd_qinfifo_requeue_tail(ahd, pending_scb);
2288                 ahd_set_scbptr(ahd, saved_scbptr);
2289                 ahd_print_path(ahd, pending_scb);
2290                 printf("Device is disconnected, re-queuing SCB\n");
2291                 wait = TRUE;
2292         } else {
2293                 scmd_printk(KERN_INFO, cmd, "Unable to deliver message\n");
2294                 retval = FAILED;
2295                 goto done;
2296         }
2297
2298 no_cmd:
2299         /*
2300          * Our assumption is that if we don't have the command, no
2301          * recovery action was required, so we return success.  Again,
2302          * the semantics of the mid-layer recovery engine are not
2303          * well defined, so this may change in time.
2304          */
2305         retval = SUCCESS;
2306 done:
2307         if (paused)
2308                 ahd_unpause(ahd);
2309         if (wait) {
2310                 DECLARE_COMPLETION(done);
2311
2312                 ahd->platform_data->eh_done = &done;
2313                 ahd_unlock(ahd, &flags);
2314
2315                 printf("%s: Recovery code sleeping\n", ahd_name(ahd));
2316                 if (!wait_for_completion_timeout(&done, 5 * HZ)) {
2317                         ahd_lock(ahd, &flags);
2318                         ahd->platform_data->eh_done = NULL;
2319                         ahd_unlock(ahd, &flags);
2320                         printf("%s: Timer Expired (active %d)\n",
2321                                ahd_name(ahd), dev->active);
2322                         retval = FAILED;
2323                 }
2324                 printf("Recovery code awake\n");
2325         } else
2326                 ahd_unlock(ahd, &flags);
2327
2328         if (retval != SUCCESS)
2329                 printf("%s: Command abort returning 0x%x\n",
2330                        ahd_name(ahd), retval);
2331
2332         return retval;
2333 }
2334
2335 static void ahd_linux_set_width(struct scsi_target *starget, int width)
2336 {
2337         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2338         struct ahd_softc *ahd = *((struct ahd_softc **)shost->hostdata);
2339         struct ahd_devinfo devinfo;
2340         unsigned long flags;
2341
2342         ahd_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2343                             starget->channel + 'A', ROLE_INITIATOR);
2344         ahd_lock(ahd, &flags);
2345         ahd_set_width(ahd, &devinfo, width, AHD_TRANS_GOAL, FALSE);
2346         ahd_unlock(ahd, &flags);
2347 }
2348
2349 static void ahd_linux_set_period(struct scsi_target *starget, int period)
2350 {
2351         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2352         struct ahd_softc *ahd = *((struct ahd_softc **)shost->hostdata);
2353         struct ahd_tmode_tstate *tstate;
2354         struct ahd_initiator_tinfo *tinfo
2355                 = ahd_fetch_transinfo(ahd,
2356                                       starget->channel + 'A',
2357                                       shost->this_id, starget->id, &tstate);
2358         struct ahd_devinfo devinfo;
2359         unsigned int ppr_options = tinfo->goal.ppr_options;
2360         unsigned int dt;
2361         unsigned long flags;
2362         unsigned long offset = tinfo->goal.offset;
2363
2364 #ifdef AHD_DEBUG
2365         if ((ahd_debug & AHD_SHOW_DV) != 0)
2366                 printf("%s: set period to %d\n", ahd_name(ahd), period);
2367 #endif
2368         if (offset == 0)
2369                 offset = MAX_OFFSET;
2370
2371         if (period < 8)
2372                 period = 8;
2373         if (period < 10) {
2374                 ppr_options |= MSG_EXT_PPR_DT_REQ;
2375                 if (period == 8)
2376                         ppr_options |= MSG_EXT_PPR_IU_REQ;
2377         }
2378
2379         dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2380
2381         ahd_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2382                             starget->channel + 'A', ROLE_INITIATOR);
2383
2384         /* all PPR requests apart from QAS require wide transfers */
2385         if (ppr_options & ~MSG_EXT_PPR_QAS_REQ) {
2386                 if (spi_width(starget) == 0)
2387                         ppr_options &= MSG_EXT_PPR_QAS_REQ;
2388         }
2389
2390         ahd_find_syncrate(ahd, &period, &ppr_options,
2391                           dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2392
2393         ahd_lock(ahd, &flags);
2394         ahd_set_syncrate(ahd, &devinfo, period, offset,
2395                          ppr_options, AHD_TRANS_GOAL, FALSE);
2396         ahd_unlock(ahd, &flags);
2397 }
2398
2399 static void ahd_linux_set_offset(struct scsi_target *starget, int offset)
2400 {
2401         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2402         struct ahd_softc *ahd = *((struct ahd_softc **)shost->hostdata);
2403         struct ahd_tmode_tstate *tstate;
2404         struct ahd_initiator_tinfo *tinfo
2405                 = ahd_fetch_transinfo(ahd,
2406                                       starget->channel + 'A',
2407                                       shost->this_id, starget->id, &tstate);
2408         struct ahd_devinfo devinfo;
2409         unsigned int ppr_options = 0;
2410         unsigned int period = 0;
2411         unsigned int dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2412         unsigned long flags;
2413
2414 #ifdef AHD_DEBUG
2415         if ((ahd_debug & AHD_SHOW_DV) != 0)
2416                 printf("%s: set offset to %d\n", ahd_name(ahd), offset);
2417 #endif
2418
2419         ahd_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2420                             starget->channel + 'A', ROLE_INITIATOR);
2421         if (offset != 0) {
2422                 period = tinfo->goal.period;
2423                 ppr_options = tinfo->goal.ppr_options;
2424                 ahd_find_syncrate(ahd, &period, &ppr_options,
2425                                   dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2426         }
2427
2428         ahd_lock(ahd, &flags);
2429         ahd_set_syncrate(ahd, &devinfo, period, offset, ppr_options,
2430                          AHD_TRANS_GOAL, FALSE);
2431         ahd_unlock(ahd, &flags);
2432 }
2433
2434 static void ahd_linux_set_dt(struct scsi_target *starget, int dt)
2435 {
2436         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2437         struct ahd_softc *ahd = *((struct ahd_softc **)shost->hostdata);
2438         struct ahd_tmode_tstate *tstate;
2439         struct ahd_initiator_tinfo *tinfo
2440                 = ahd_fetch_transinfo(ahd,
2441                                       starget->channel + 'A',
2442                                       shost->this_id, starget->id, &tstate);
2443         struct ahd_devinfo devinfo;
2444         unsigned int ppr_options = tinfo->goal.ppr_options
2445                 & ~MSG_EXT_PPR_DT_REQ;
2446         unsigned int period = tinfo->goal.period;
2447         unsigned int width = tinfo->goal.width;
2448         unsigned long flags;
2449
2450 #ifdef AHD_DEBUG
2451         if ((ahd_debug & AHD_SHOW_DV) != 0)
2452                 printf("%s: %s DT\n", ahd_name(ahd),
2453                        dt ? "enabling" : "disabling");
2454 #endif
2455         if (dt) {
2456                 ppr_options |= MSG_EXT_PPR_DT_REQ;
2457                 if (!width)
2458                         ahd_linux_set_width(starget, 1);
2459         } else {
2460                 if (period <= 9)
2461                         period = 10; /* If resetting DT, period must be >= 25ns */
2462                 /* IU is invalid without DT set */
2463                 ppr_options &= ~MSG_EXT_PPR_IU_REQ;
2464         }
2465         ahd_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2466                             starget->channel + 'A', ROLE_INITIATOR);
2467         ahd_find_syncrate(ahd, &period, &ppr_options,
2468                           dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2469
2470         ahd_lock(ahd, &flags);
2471         ahd_set_syncrate(ahd, &devinfo, period, tinfo->goal.offset,
2472                          ppr_options, AHD_TRANS_GOAL, FALSE);
2473         ahd_unlock(ahd, &flags);
2474 }
2475
2476 static void ahd_linux_set_qas(struct scsi_target *starget, int qas)
2477 {
2478         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2479         struct ahd_softc *ahd = *((struct ahd_softc **)shost->hostdata);
2480         struct ahd_tmode_tstate *tstate;
2481         struct ahd_initiator_tinfo *tinfo
2482                 = ahd_fetch_transinfo(ahd,
2483                                       starget->channel + 'A',
2484                                       shost->this_id, starget->id, &tstate);
2485         struct ahd_devinfo devinfo;
2486         unsigned int ppr_options = tinfo->goal.ppr_options
2487                 & ~MSG_EXT_PPR_QAS_REQ;
2488         unsigned int period = tinfo->goal.period;
2489         unsigned int dt;
2490         unsigned long flags;
2491
2492 #ifdef AHD_DEBUG
2493         if ((ahd_debug & AHD_SHOW_DV) != 0)
2494                 printf("%s: %s QAS\n", ahd_name(ahd),
2495                        qas ? "enabling" : "disabling");
2496 #endif
2497
2498         if (qas) {
2499                 ppr_options |= MSG_EXT_PPR_QAS_REQ;
2500         }
2501
2502         dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2503
2504         ahd_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2505                             starget->channel + 'A', ROLE_INITIATOR);
2506         ahd_find_syncrate(ahd, &period, &ppr_options,
2507                           dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2508
2509         ahd_lock(ahd, &flags);
2510         ahd_set_syncrate(ahd, &devinfo, period, tinfo->goal.offset,
2511                          ppr_options, AHD_TRANS_GOAL, FALSE);
2512         ahd_unlock(ahd, &flags);
2513 }
2514
2515 static void ahd_linux_set_iu(struct scsi_target *starget, int iu)
2516 {
2517         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2518         struct ahd_softc *ahd = *((struct ahd_softc **)shost->hostdata);
2519         struct ahd_tmode_tstate *tstate;
2520         struct ahd_initiator_tinfo *tinfo
2521                 = ahd_fetch_transinfo(ahd,
2522                                       starget->channel + 'A',
2523                                       shost->this_id, starget->id, &tstate);
2524         struct ahd_devinfo devinfo;
2525         unsigned int ppr_options = tinfo->goal.ppr_options
2526                 & ~MSG_EXT_PPR_IU_REQ;
2527         unsigned int period = tinfo->goal.period;
2528         unsigned int dt;
2529         unsigned long flags;
2530
2531 #ifdef AHD_DEBUG
2532         if ((ahd_debug & AHD_SHOW_DV) != 0)
2533                 printf("%s: %s IU\n", ahd_name(ahd),
2534                        iu ? "enabling" : "disabling");
2535 #endif
2536
2537         if (iu) {
2538                 ppr_options |= MSG_EXT_PPR_IU_REQ;
2539                 ppr_options |= MSG_EXT_PPR_DT_REQ; /* IU requires DT */
2540         }
2541
2542         dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2543
2544         ahd_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2545                             starget->channel + 'A', ROLE_INITIATOR);
2546         ahd_find_syncrate(ahd, &period, &ppr_options,
2547                           dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2548
2549         ahd_lock(ahd, &flags);
2550         ahd_set_syncrate(ahd, &devinfo, period, tinfo->goal.offset,
2551                          ppr_options, AHD_TRANS_GOAL, FALSE);
2552         ahd_unlock(ahd, &flags);
2553 }
2554
2555 static void ahd_linux_set_rd_strm(struct scsi_target *starget, int rdstrm)
2556 {
2557         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2558         struct ahd_softc *ahd = *((struct ahd_softc **)shost->hostdata);
2559         struct ahd_tmode_tstate *tstate;
2560         struct ahd_initiator_tinfo *tinfo
2561                 = ahd_fetch_transinfo(ahd,
2562                                       starget->channel + 'A',
2563                                       shost->this_id, starget->id, &tstate);
2564         struct ahd_devinfo devinfo;
2565         unsigned int ppr_options = tinfo->goal.ppr_options
2566                 & ~MSG_EXT_PPR_RD_STRM;
2567         unsigned int period = tinfo->goal.period;
2568         unsigned int dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2569         unsigned long flags;
2570
2571 #ifdef AHD_DEBUG
2572         if ((ahd_debug & AHD_SHOW_DV) != 0)
2573                 printf("%s: %s Read Streaming\n", ahd_name(ahd),
2574                        rdstrm  ? "enabling" : "disabling");
2575 #endif
2576
2577         if (rdstrm)
2578                 ppr_options |= MSG_EXT_PPR_RD_STRM;
2579
2580         ahd_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2581                             starget->channel + 'A', ROLE_INITIATOR);
2582         ahd_find_syncrate(ahd, &period, &ppr_options,
2583                           dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2584
2585         ahd_lock(ahd, &flags);
2586         ahd_set_syncrate(ahd, &devinfo, period, tinfo->goal.offset,
2587                          ppr_options, AHD_TRANS_GOAL, FALSE);
2588         ahd_unlock(ahd, &flags);
2589 }
2590
2591 static void ahd_linux_set_wr_flow(struct scsi_target *starget, int wrflow)
2592 {
2593         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2594         struct ahd_softc *ahd = *((struct ahd_softc **)shost->hostdata);
2595         struct ahd_tmode_tstate *tstate;
2596         struct ahd_initiator_tinfo *tinfo
2597                 = ahd_fetch_transinfo(ahd,
2598                                       starget->channel + 'A',
2599                                       shost->this_id, starget->id, &tstate);
2600         struct ahd_devinfo devinfo;
2601         unsigned int ppr_options = tinfo->goal.ppr_options
2602                 & ~MSG_EXT_PPR_WR_FLOW;
2603         unsigned int period = tinfo->goal.period;
2604         unsigned int dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2605         unsigned long flags;
2606
2607 #ifdef AHD_DEBUG
2608         if ((ahd_debug & AHD_SHOW_DV) != 0)
2609                 printf("%s: %s Write Flow Control\n", ahd_name(ahd),
2610                        wrflow ? "enabling" : "disabling");
2611 #endif
2612
2613         if (wrflow)
2614                 ppr_options |= MSG_EXT_PPR_WR_FLOW;
2615
2616         ahd_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2617                             starget->channel + 'A', ROLE_INITIATOR);
2618         ahd_find_syncrate(ahd, &period, &ppr_options,
2619                           dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2620
2621         ahd_lock(ahd, &flags);
2622         ahd_set_syncrate(ahd, &devinfo, period, tinfo->goal.offset,
2623                          ppr_options, AHD_TRANS_GOAL, FALSE);
2624         ahd_unlock(ahd, &flags);
2625 }
2626
2627 static void ahd_linux_set_rti(struct scsi_target *starget, int rti)
2628 {
2629         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2630         struct ahd_softc *ahd = *((struct ahd_softc **)shost->hostdata);
2631         struct ahd_tmode_tstate *tstate;
2632         struct ahd_initiator_tinfo *tinfo
2633                 = ahd_fetch_transinfo(ahd,
2634                                       starget->channel + 'A',
2635                                       shost->this_id, starget->id, &tstate);
2636         struct ahd_devinfo devinfo;
2637         unsigned int ppr_options = tinfo->goal.ppr_options
2638                 & ~MSG_EXT_PPR_RTI;
2639         unsigned int period = tinfo->goal.period;
2640         unsigned int dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2641         unsigned long flags;
2642
2643         if ((ahd->features & AHD_RTI) == 0) {
2644 #ifdef AHD_DEBUG
2645                 if ((ahd_debug & AHD_SHOW_DV) != 0)
2646                         printf("%s: RTI not available\n", ahd_name(ahd));
2647 #endif
2648                 return;
2649         }
2650
2651 #ifdef AHD_DEBUG
2652         if ((ahd_debug & AHD_SHOW_DV) != 0)
2653                 printf("%s: %s RTI\n", ahd_name(ahd),
2654                        rti ? "enabling" : "disabling");
2655 #endif
2656
2657         if (rti)
2658                 ppr_options |= MSG_EXT_PPR_RTI;
2659
2660         ahd_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2661                             starget->channel + 'A', ROLE_INITIATOR);
2662         ahd_find_syncrate(ahd, &period, &ppr_options,
2663                           dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2664
2665         ahd_lock(ahd, &flags);
2666         ahd_set_syncrate(ahd, &devinfo, period, tinfo->goal.offset,
2667                          ppr_options, AHD_TRANS_GOAL, FALSE);
2668         ahd_unlock(ahd, &flags);
2669 }
2670
2671 static void ahd_linux_set_pcomp_en(struct scsi_target *starget, int pcomp)
2672 {
2673         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2674         struct ahd_softc *ahd = *((struct ahd_softc **)shost->hostdata);
2675         struct ahd_tmode_tstate *tstate;
2676         struct ahd_initiator_tinfo *tinfo
2677                 = ahd_fetch_transinfo(ahd,
2678                                       starget->channel + 'A',
2679                                       shost->this_id, starget->id, &tstate);
2680         struct ahd_devinfo devinfo;
2681         unsigned int ppr_options = tinfo->goal.ppr_options
2682                 & ~MSG_EXT_PPR_PCOMP_EN;
2683         unsigned int period = tinfo->goal.period;
2684         unsigned int dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2685         unsigned long flags;
2686
2687 #ifdef AHD_DEBUG
2688         if ((ahd_debug & AHD_SHOW_DV) != 0)
2689                 printf("%s: %s Precompensation\n", ahd_name(ahd),
2690                        pcomp ? "Enable" : "Disable");
2691 #endif
2692
2693         if (pcomp)
2694                 ppr_options |= MSG_EXT_PPR_PCOMP_EN;
2695
2696         ahd_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2697                             starget->channel + 'A', ROLE_INITIATOR);
2698         ahd_find_syncrate(ahd, &period, &ppr_options,
2699                           dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2700
2701         ahd_lock(ahd, &flags);
2702         ahd_set_syncrate(ahd, &devinfo, period, tinfo->goal.offset,
2703                          ppr_options, AHD_TRANS_GOAL, FALSE);
2704         ahd_unlock(ahd, &flags);
2705 }
2706
2707 static void ahd_linux_set_hold_mcs(struct scsi_target *starget, int hold)
2708 {
2709         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2710         struct ahd_softc *ahd = *((struct ahd_softc **)shost->hostdata);
2711         struct ahd_tmode_tstate *tstate;
2712         struct ahd_initiator_tinfo *tinfo
2713                 = ahd_fetch_transinfo(ahd,
2714                                       starget->channel + 'A',
2715                                       shost->this_id, starget->id, &tstate);
2716         struct ahd_devinfo devinfo;
2717         unsigned int ppr_options = tinfo->goal.ppr_options
2718                 & ~MSG_EXT_PPR_HOLD_MCS;
2719         unsigned int period = tinfo->goal.period;
2720         unsigned int dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2721         unsigned long flags;
2722
2723         if (hold)
2724                 ppr_options |= MSG_EXT_PPR_HOLD_MCS;
2725
2726         ahd_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2727                             starget->channel + 'A', ROLE_INITIATOR);
2728         ahd_find_syncrate(ahd, &period, &ppr_options,
2729                           dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2730
2731         ahd_lock(ahd, &flags);
2732         ahd_set_syncrate(ahd, &devinfo, period, tinfo->goal.offset,
2733                          ppr_options, AHD_TRANS_GOAL, FALSE);
2734         ahd_unlock(ahd, &flags);
2735 }
2736
2737
2738
2739 static struct spi_function_template ahd_linux_transport_functions = {
2740         .set_offset     = ahd_linux_set_offset,
2741         .show_offset    = 1,
2742         .set_period     = ahd_linux_set_period,
2743         .show_period    = 1,
2744         .set_width      = ahd_linux_set_width,
2745         .show_width     = 1,
2746         .set_dt         = ahd_linux_set_dt,
2747         .show_dt        = 1,
2748         .set_iu         = ahd_linux_set_iu,
2749         .show_iu        = 1,
2750         .set_qas        = ahd_linux_set_qas,
2751         .show_qas       = 1,
2752         .set_rd_strm    = ahd_linux_set_rd_strm,
2753         .show_rd_strm   = 1,
2754         .set_wr_flow    = ahd_linux_set_wr_flow,
2755         .show_wr_flow   = 1,
2756         .set_rti        = ahd_linux_set_rti,
2757         .show_rti       = 1,
2758         .set_pcomp_en   = ahd_linux_set_pcomp_en,
2759         .show_pcomp_en  = 1,
2760         .set_hold_mcs   = ahd_linux_set_hold_mcs,
2761         .show_hold_mcs  = 1,
2762 };
2763
2764 static int __init
2765 ahd_linux_init(void)
2766 {
2767         int     error = 0;
2768
2769         /*
2770          * If we've been passed any parameters, process them now.
2771          */
2772         if (aic79xx)
2773                 aic79xx_setup(aic79xx);
2774
2775         ahd_linux_transport_template =
2776                 spi_attach_transport(&ahd_linux_transport_functions);
2777         if (!ahd_linux_transport_template)
2778                 return -ENODEV;
2779
2780         scsi_transport_reserve_target(ahd_linux_transport_template,
2781                                       sizeof(struct ahd_linux_target));
2782         scsi_transport_reserve_device(ahd_linux_transport_template,
2783                                       sizeof(struct ahd_linux_device));
2784
2785         error = ahd_linux_pci_init();
2786         if (error)
2787                 spi_release_transport(ahd_linux_transport_template);
2788         return error;
2789 }
2790
2791 static void __exit
2792 ahd_linux_exit(void)
2793 {
2794         ahd_linux_pci_exit();
2795         spi_release_transport(ahd_linux_transport_template);
2796 }
2797
2798 module_init(ahd_linux_init);
2799 module_exit(ahd_linux_exit);