Merge HEAD from ../scsi-misc-2.6-tmp
[sfrench/cifs-2.6.git] / drivers / scsi / aic7xxx / aic7xxx_osm.c
1 /*
2  * Adaptec AIC7xxx device driver for Linux.
3  *
4  * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic7xxx_osm.c#235 $
5  *
6  * Copyright (c) 1994 John Aycock
7  *   The University of Calgary Department of Computer Science.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2, or (at your option)
12  * any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; see the file COPYING.  If not, write to
21  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
22  *
23  * Sources include the Adaptec 1740 driver (aha1740.c), the Ultrastor 24F
24  * driver (ultrastor.c), various Linux kernel source, the Adaptec EISA
25  * config file (!adp7771.cfg), the Adaptec AHA-2740A Series User's Guide,
26  * the Linux Kernel Hacker's Guide, Writing a SCSI Device Driver for Linux,
27  * the Adaptec 1542 driver (aha1542.c), the Adaptec EISA overlay file
28  * (adp7770.ovl), the Adaptec AHA-2740 Series Technical Reference Manual,
29  * the Adaptec AIC-7770 Data Book, the ANSI SCSI specification, the
30  * ANSI SCSI-2 specification (draft 10c), ...
31  *
32  * --------------------------------------------------------------------------
33  *
34  *  Modifications by Daniel M. Eischen (deischen@iworks.InterWorks.org):
35  *
36  *  Substantially modified to include support for wide and twin bus
37  *  adapters, DMAing of SCBs, tagged queueing, IRQ sharing, bug fixes,
38  *  SCB paging, and other rework of the code.
39  *
40  * --------------------------------------------------------------------------
41  * Copyright (c) 1994-2000 Justin T. Gibbs.
42  * Copyright (c) 2000-2001 Adaptec Inc.
43  * All rights reserved.
44  *
45  * Redistribution and use in source and binary forms, with or without
46  * modification, are permitted provided that the following conditions
47  * are met:
48  * 1. Redistributions of source code must retain the above copyright
49  *    notice, this list of conditions, and the following disclaimer,
50  *    without modification.
51  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
52  *    substantially similar to the "NO WARRANTY" disclaimer below
53  *    ("Disclaimer") and any redistribution must be conditioned upon
54  *    including a substantially similar Disclaimer requirement for further
55  *    binary redistribution.
56  * 3. Neither the names of the above-listed copyright holders nor the names
57  *    of any contributors may be used to endorse or promote products derived
58  *    from this software without specific prior written permission.
59  *
60  * Alternatively, this software may be distributed under the terms of the
61  * GNU General Public License ("GPL") version 2 as published by the Free
62  * Software Foundation.
63  *
64  * NO WARRANTY
65  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
66  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
67  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
68  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
69  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
70  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
71  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
72  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
73  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
74  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
75  * POSSIBILITY OF SUCH DAMAGES.
76  *
77  *---------------------------------------------------------------------------
78  *
79  *  Thanks also go to (in alphabetical order) the following:
80  *
81  *    Rory Bolt     - Sequencer bug fixes
82  *    Jay Estabrook - Initial DEC Alpha support
83  *    Doug Ledford  - Much needed abort/reset bug fixes
84  *    Kai Makisara  - DMAing of SCBs
85  *
86  *  A Boot time option was also added for not resetting the scsi bus.
87  *
88  *    Form:  aic7xxx=extended
89  *           aic7xxx=no_reset
90  *           aic7xxx=verbose
91  *
92  *  Daniel M. Eischen, deischen@iworks.InterWorks.org, 1/23/97
93  *
94  *  Id: aic7xxx.c,v 4.1 1997/06/12 08:23:42 deang Exp
95  */
96
97 /*
98  * Further driver modifications made by Doug Ledford <dledford@redhat.com>
99  *
100  * Copyright (c) 1997-1999 Doug Ledford
101  *
102  * These changes are released under the same licensing terms as the FreeBSD
103  * driver written by Justin Gibbs.  Please see his Copyright notice above
104  * for the exact terms and conditions covering my changes as well as the
105  * warranty statement.
106  *
107  * Modifications made to the aic7xxx.c,v 4.1 driver from Dan Eischen include
108  * but are not limited to:
109  *
110  *  1: Import of the latest FreeBSD sequencer code for this driver
111  *  2: Modification of kernel code to accommodate different sequencer semantics
112  *  3: Extensive changes throughout kernel portion of driver to improve
113  *     abort/reset processing and error hanndling
114  *  4: Other work contributed by various people on the Internet
115  *  5: Changes to printk information and verbosity selection code
116  *  6: General reliability related changes, especially in IRQ management
117  *  7: Modifications to the default probe/attach order for supported cards
118  *  8: SMP friendliness has been improved
119  *
120  */
121
122 #include "aic7xxx_osm.h"
123 #include "aic7xxx_inline.h"
124 #include <scsi/scsicam.h>
125
126 static struct scsi_transport_template *ahc_linux_transport_template = NULL;
127
128 /*
129  * Include aiclib.c as part of our
130  * "module dependencies are hard" work around.
131  */
132 #include "aiclib.c"
133
134 #include <linux/init.h>         /* __setup */
135 #include <linux/mm.h>           /* For fetching system memory size */
136 #include <linux/blkdev.h>               /* For block_size() */
137 #include <linux/delay.h>        /* For ssleep/msleep */
138
139
140 /*
141  * Set this to the delay in seconds after SCSI bus reset.
142  * Note, we honor this only for the initial bus reset.
143  * The scsi error recovery code performs its own bus settle
144  * delay handling for error recovery actions.
145  */
146 #ifdef CONFIG_AIC7XXX_RESET_DELAY_MS
147 #define AIC7XXX_RESET_DELAY CONFIG_AIC7XXX_RESET_DELAY_MS
148 #else
149 #define AIC7XXX_RESET_DELAY 5000
150 #endif
151
152 /*
153  * Control collection of SCSI transfer statistics for the /proc filesystem.
154  *
155  * NOTE: Do NOT enable this when running on kernels version 1.2.x and below.
156  * NOTE: This does affect performance since it has to maintain statistics.
157  */
158 #ifdef CONFIG_AIC7XXX_PROC_STATS
159 #define AIC7XXX_PROC_STATS
160 #endif
161
162 /*
163  * To change the default number of tagged transactions allowed per-device,
164  * add a line to the lilo.conf file like:
165  * append="aic7xxx=verbose,tag_info:{{32,32,32,32},{32,32,32,32}}"
166  * which will result in the first four devices on the first two
167  * controllers being set to a tagged queue depth of 32.
168  *
169  * The tag_commands is an array of 16 to allow for wide and twin adapters.
170  * Twin adapters will use indexes 0-7 for channel 0, and indexes 8-15
171  * for channel 1.
172  */
173 typedef struct {
174         uint8_t tag_commands[16];       /* Allow for wide/twin adapters. */
175 } adapter_tag_info_t;
176
177 /*
178  * Modify this as you see fit for your system.
179  *
180  * 0                    tagged queuing disabled
181  * 1 <= n <= 253        n == max tags ever dispatched.
182  *
183  * The driver will throttle the number of commands dispatched to a
184  * device if it returns queue full.  For devices with a fixed maximum
185  * queue depth, the driver will eventually determine this depth and
186  * lock it in (a console message is printed to indicate that a lock
187  * has occurred).  On some devices, queue full is returned for a temporary
188  * resource shortage.  These devices will return queue full at varying
189  * depths.  The driver will throttle back when the queue fulls occur and
190  * attempt to slowly increase the depth over time as the device recovers
191  * from the resource shortage.
192  *
193  * In this example, the first line will disable tagged queueing for all
194  * the devices on the first probed aic7xxx adapter.
195  *
196  * The second line enables tagged queueing with 4 commands/LUN for IDs
197  * (0, 2-11, 13-15), disables tagged queueing for ID 12, and tells the
198  * driver to attempt to use up to 64 tags for ID 1.
199  *
200  * The third line is the same as the first line.
201  *
202  * The fourth line disables tagged queueing for devices 0 and 3.  It
203  * enables tagged queueing for the other IDs, with 16 commands/LUN
204  * for IDs 1 and 4, 127 commands/LUN for ID 8, and 4 commands/LUN for
205  * IDs 2, 5-7, and 9-15.
206  */
207
208 /*
209  * NOTE: The below structure is for reference only, the actual structure
210  *       to modify in order to change things is just below this comment block.
211 adapter_tag_info_t aic7xxx_tag_info[] =
212 {
213         {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
214         {{4, 64, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4}},
215         {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
216         {{0, 16, 4, 0, 16, 4, 4, 4, 127, 4, 4, 4, 4, 4, 4, 4}}
217 };
218 */
219
220 #ifdef CONFIG_AIC7XXX_CMDS_PER_DEVICE
221 #define AIC7XXX_CMDS_PER_DEVICE CONFIG_AIC7XXX_CMDS_PER_DEVICE
222 #else
223 #define AIC7XXX_CMDS_PER_DEVICE AHC_MAX_QUEUE
224 #endif
225
226 #define AIC7XXX_CONFIGED_TAG_COMMANDS {                                 \
227         AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,               \
228         AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,               \
229         AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,               \
230         AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,               \
231         AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,               \
232         AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,               \
233         AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,               \
234         AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE                \
235 }
236
237 /*
238  * By default, use the number of commands specified by
239  * the users kernel configuration.
240  */
241 static adapter_tag_info_t aic7xxx_tag_info[] =
242 {
243         {AIC7XXX_CONFIGED_TAG_COMMANDS},
244         {AIC7XXX_CONFIGED_TAG_COMMANDS},
245         {AIC7XXX_CONFIGED_TAG_COMMANDS},
246         {AIC7XXX_CONFIGED_TAG_COMMANDS},
247         {AIC7XXX_CONFIGED_TAG_COMMANDS},
248         {AIC7XXX_CONFIGED_TAG_COMMANDS},
249         {AIC7XXX_CONFIGED_TAG_COMMANDS},
250         {AIC7XXX_CONFIGED_TAG_COMMANDS},
251         {AIC7XXX_CONFIGED_TAG_COMMANDS},
252         {AIC7XXX_CONFIGED_TAG_COMMANDS},
253         {AIC7XXX_CONFIGED_TAG_COMMANDS},
254         {AIC7XXX_CONFIGED_TAG_COMMANDS},
255         {AIC7XXX_CONFIGED_TAG_COMMANDS},
256         {AIC7XXX_CONFIGED_TAG_COMMANDS},
257         {AIC7XXX_CONFIGED_TAG_COMMANDS},
258         {AIC7XXX_CONFIGED_TAG_COMMANDS}
259 };
260
261 /*
262  * There should be a specific return value for this in scsi.h, but
263  * it seems that most drivers ignore it.
264  */
265 #define DID_UNDERFLOW   DID_ERROR
266
267 void
268 ahc_print_path(struct ahc_softc *ahc, struct scb *scb)
269 {
270         printk("(scsi%d:%c:%d:%d): ",
271                ahc->platform_data->host->host_no,
272                scb != NULL ? SCB_GET_CHANNEL(ahc, scb) : 'X',
273                scb != NULL ? SCB_GET_TARGET(ahc, scb) : -1,
274                scb != NULL ? SCB_GET_LUN(scb) : -1);
275 }
276
277 /*
278  * XXX - these options apply unilaterally to _all_ 274x/284x/294x
279  *       cards in the system.  This should be fixed.  Exceptions to this
280  *       rule are noted in the comments.
281  */
282
283 /*
284  * Skip the scsi bus reset.  Non 0 make us skip the reset at startup.  This
285  * has no effect on any later resets that might occur due to things like
286  * SCSI bus timeouts.
287  */
288 static uint32_t aic7xxx_no_reset;
289
290 /*
291  * Should we force EXTENDED translation on a controller.
292  *     0 == Use whatever is in the SEEPROM or default to off
293  *     1 == Use whatever is in the SEEPROM or default to on
294  */
295 static uint32_t aic7xxx_extended;
296
297 /*
298  * PCI bus parity checking of the Adaptec controllers.  This is somewhat
299  * dubious at best.  To my knowledge, this option has never actually
300  * solved a PCI parity problem, but on certain machines with broken PCI
301  * chipset configurations where stray PCI transactions with bad parity are
302  * the norm rather than the exception, the error messages can be overwelming.
303  * It's included in the driver for completeness.
304  *   0     = Shut off PCI parity check
305  *   non-0 = reverse polarity pci parity checking
306  */
307 static uint32_t aic7xxx_pci_parity = ~0;
308
309 /*
310  * There are lots of broken chipsets in the world.  Some of them will
311  * violate the PCI spec when we issue byte sized memory writes to our
312  * controller.  I/O mapped register access, if allowed by the given
313  * platform, will work in almost all cases.
314  */
315 uint32_t aic7xxx_allow_memio = ~0;
316
317 /*
318  * So that we can set how long each device is given as a selection timeout.
319  * The table of values goes like this:
320  *   0 - 256ms
321  *   1 - 128ms
322  *   2 - 64ms
323  *   3 - 32ms
324  * We default to 256ms because some older devices need a longer time
325  * to respond to initial selection.
326  */
327 static uint32_t aic7xxx_seltime;
328
329 /*
330  * Certain devices do not perform any aging on commands.  Should the
331  * device be saturated by commands in one portion of the disk, it is
332  * possible for transactions on far away sectors to never be serviced.
333  * To handle these devices, we can periodically send an ordered tag to
334  * force all outstanding transactions to be serviced prior to a new
335  * transaction.
336  */
337 uint32_t aic7xxx_periodic_otag;
338
339 /*
340  * Module information and settable options.
341  */
342 static char *aic7xxx = NULL;
343
344 MODULE_AUTHOR("Maintainer: Justin T. Gibbs <gibbs@scsiguy.com>");
345 MODULE_DESCRIPTION("Adaptec Aic77XX/78XX SCSI Host Bus Adapter driver");
346 MODULE_LICENSE("Dual BSD/GPL");
347 MODULE_VERSION(AIC7XXX_DRIVER_VERSION);
348 module_param(aic7xxx, charp, 0444);
349 MODULE_PARM_DESC(aic7xxx,
350 "period delimited, options string.\n"
351 "       verbose                 Enable verbose/diagnostic logging\n"
352 "       allow_memio             Allow device registers to be memory mapped\n"
353 "       debug                   Bitmask of debug values to enable\n"
354 "       no_probe                Toggle EISA/VLB controller probing\n"
355 "       probe_eisa_vl           Toggle EISA/VLB controller probing\n"
356 "       no_reset                Supress initial bus resets\n"
357 "       extended                Enable extended geometry on all controllers\n"
358 "       periodic_otag           Send an ordered tagged transaction\n"
359 "                               periodically to prevent tag starvation.\n"
360 "                               This may be required by some older disk\n"
361 "                               drives or RAID arrays.\n"
362 "       reverse_scan            Sort PCI devices highest Bus/Slot to lowest\n"
363 "       tag_info:<tag_str>      Set per-target tag depth\n"
364 "       global_tag_depth:<int>  Global tag depth for every target\n"
365 "                               on every bus\n"
366 "       seltime:<int>           Selection Timeout\n"
367 "                               (0/256ms,1/128ms,2/64ms,3/32ms)\n"
368 "\n"
369 "       Sample /etc/modprobe.conf line:\n"
370 "               Toggle EISA/VLB probing\n"
371 "               Set tag depth on Controller 1/Target 1 to 10 tags\n"
372 "               Shorten the selection timeout to 128ms\n"
373 "\n"
374 "       options aic7xxx 'aic7xxx=probe_eisa_vl.tag_info:{{}.{.10}}.seltime:1'\n"
375 );
376
377 static void ahc_linux_handle_scsi_status(struct ahc_softc *,
378                                          struct scsi_device *,
379                                          struct scb *);
380 static void ahc_linux_queue_cmd_complete(struct ahc_softc *ahc,
381                                          struct scsi_cmnd *cmd);
382 static void ahc_linux_sem_timeout(u_long arg);
383 static void ahc_linux_freeze_simq(struct ahc_softc *ahc);
384 static void ahc_linux_release_simq(u_long arg);
385 static int  ahc_linux_queue_recovery_cmd(struct scsi_cmnd *cmd, scb_flag flag);
386 static void ahc_linux_initialize_scsi_bus(struct ahc_softc *ahc);
387 static u_int ahc_linux_user_tagdepth(struct ahc_softc *ahc,
388                                      struct ahc_devinfo *devinfo);
389 static void ahc_linux_device_queue_depth(struct scsi_device *);
390 static int ahc_linux_run_command(struct ahc_softc*,
391                                  struct ahc_linux_device *,
392                                  struct scsi_cmnd *);
393 static void ahc_linux_setup_tag_info_global(char *p);
394 static aic_option_callback_t ahc_linux_setup_tag_info;
395 static int  aic7xxx_setup(char *s);
396
397 static int ahc_linux_unit;
398
399
400 /********************************* Inlines ************************************/
401 static __inline void ahc_linux_unmap_scb(struct ahc_softc*, struct scb*);
402
403 static __inline int ahc_linux_map_seg(struct ahc_softc *ahc, struct scb *scb,
404                                       struct ahc_dma_seg *sg,
405                                       dma_addr_t addr, bus_size_t len);
406
407 static __inline void
408 ahc_linux_unmap_scb(struct ahc_softc *ahc, struct scb *scb)
409 {
410         struct scsi_cmnd *cmd;
411
412         cmd = scb->io_ctx;
413         ahc_sync_sglist(ahc, scb, BUS_DMASYNC_POSTWRITE);
414         if (cmd->use_sg != 0) {
415                 struct scatterlist *sg;
416
417                 sg = (struct scatterlist *)cmd->request_buffer;
418                 pci_unmap_sg(ahc->dev_softc, sg, cmd->use_sg,
419                              cmd->sc_data_direction);
420         } else if (cmd->request_bufflen != 0) {
421                 pci_unmap_single(ahc->dev_softc,
422                                  scb->platform_data->buf_busaddr,
423                                  cmd->request_bufflen,
424                                  cmd->sc_data_direction);
425         }
426 }
427
428 static __inline int
429 ahc_linux_map_seg(struct ahc_softc *ahc, struct scb *scb,
430                   struct ahc_dma_seg *sg, dma_addr_t addr, bus_size_t len)
431 {
432         int      consumed;
433
434         if ((scb->sg_count + 1) > AHC_NSEG)
435                 panic("Too few segs for dma mapping.  "
436                       "Increase AHC_NSEG\n");
437
438         consumed = 1;
439         sg->addr = ahc_htole32(addr & 0xFFFFFFFF);
440         scb->platform_data->xfer_len += len;
441
442         if (sizeof(dma_addr_t) > 4
443          && (ahc->flags & AHC_39BIT_ADDRESSING) != 0)
444                 len |= (addr >> 8) & AHC_SG_HIGH_ADDR_MASK;
445
446         sg->len = ahc_htole32(len);
447         return (consumed);
448 }
449
450 /*
451  * Return a string describing the driver.
452  */
453 static const char *
454 ahc_linux_info(struct Scsi_Host *host)
455 {
456         static char buffer[512];
457         char    ahc_info[256];
458         char   *bp;
459         struct ahc_softc *ahc;
460
461         bp = &buffer[0];
462         ahc = *(struct ahc_softc **)host->hostdata;
463         memset(bp, 0, sizeof(buffer));
464         strcpy(bp, "Adaptec AIC7XXX EISA/VLB/PCI SCSI HBA DRIVER, Rev ");
465         strcat(bp, AIC7XXX_DRIVER_VERSION);
466         strcat(bp, "\n");
467         strcat(bp, "        <");
468         strcat(bp, ahc->description);
469         strcat(bp, ">\n");
470         strcat(bp, "        ");
471         ahc_controller_info(ahc, ahc_info);
472         strcat(bp, ahc_info);
473         strcat(bp, "\n");
474
475         return (bp);
476 }
477
478 /*
479  * Queue an SCB to the controller.
480  */
481 static int
482 ahc_linux_queue(struct scsi_cmnd * cmd, void (*scsi_done) (struct scsi_cmnd *))
483 {
484         struct   ahc_softc *ahc;
485         struct   ahc_linux_device *dev = scsi_transport_device_data(cmd->device);
486
487         ahc = *(struct ahc_softc **)cmd->device->host->hostdata;
488
489         /*
490          * Save the callback on completion function.
491          */
492         cmd->scsi_done = scsi_done;
493
494         /*
495          * Close the race of a command that was in the process of
496          * being queued to us just as our simq was frozen.  Let
497          * DV commands through so long as we are only frozen to
498          * perform DV.
499          */
500         if (ahc->platform_data->qfrozen != 0)
501                 return SCSI_MLQUEUE_HOST_BUSY;
502
503         cmd->result = CAM_REQ_INPROG << 16;
504
505         return ahc_linux_run_command(ahc, dev, cmd);
506 }
507
508 static inline struct scsi_target **
509 ahc_linux_target_in_softc(struct scsi_target *starget)
510 {
511         struct  ahc_softc *ahc =
512                 *((struct ahc_softc **)dev_to_shost(&starget->dev)->hostdata);
513         unsigned int target_offset;
514
515         target_offset = starget->id;
516         if (starget->channel != 0)
517                 target_offset += 8;
518
519         return &ahc->platform_data->starget[target_offset];
520 }
521
522 static int
523 ahc_linux_target_alloc(struct scsi_target *starget)
524 {
525         struct  ahc_softc *ahc =
526                 *((struct ahc_softc **)dev_to_shost(&starget->dev)->hostdata);
527         struct seeprom_config *sc = ahc->seep_config;
528         unsigned long flags;
529         struct scsi_target **ahc_targp = ahc_linux_target_in_softc(starget);
530         struct ahc_linux_target *targ = scsi_transport_target_data(starget);
531         unsigned short scsirate;
532         struct ahc_devinfo devinfo;
533         struct ahc_initiator_tinfo *tinfo;
534         struct ahc_tmode_tstate *tstate;
535         char channel = starget->channel + 'A';
536         unsigned int our_id = ahc->our_id;
537         unsigned int target_offset;
538
539         target_offset = starget->id;
540         if (starget->channel != 0)
541                 target_offset += 8;
542           
543         if (starget->channel)
544                 our_id = ahc->our_id_b;
545
546         ahc_lock(ahc, &flags);
547
548         BUG_ON(*ahc_targp != NULL);
549
550         *ahc_targp = starget;
551         memset(targ, 0, sizeof(*targ));
552
553         if (sc) {
554                 int maxsync = AHC_SYNCRATE_DT;
555                 int ultra = 0;
556                 int flags = sc->device_flags[target_offset];
557
558                 if (ahc->flags & AHC_NEWEEPROM_FMT) {
559                     if (flags & CFSYNCHISULTRA)
560                         ultra = 1;
561                 } else if (flags & CFULTRAEN)
562                         ultra = 1;
563                 /* AIC nutcase; 10MHz appears as ultra = 1, CFXFER = 0x04
564                  * change it to ultra=0, CFXFER = 0 */
565                 if(ultra && (flags & CFXFER) == 0x04) {
566                         ultra = 0;
567                         flags &= ~CFXFER;
568                 }
569             
570                 if ((ahc->features & AHC_ULTRA2) != 0) {
571                         scsirate = (flags & CFXFER) | (ultra ? 0x8 : 0);
572                 } else {
573                         scsirate = (flags & CFXFER) << 4;
574                         maxsync = ultra ? AHC_SYNCRATE_ULTRA : 
575                                 AHC_SYNCRATE_FAST;
576                 }
577                 spi_max_width(starget) = (flags & CFWIDEB) ? 1 : 0;
578                 if (!(flags & CFSYNCH))
579                         spi_max_offset(starget) = 0;
580                 spi_min_period(starget) = 
581                         ahc_find_period(ahc, scsirate, maxsync);
582
583                 tinfo = ahc_fetch_transinfo(ahc, channel, ahc->our_id,
584                                             starget->id, &tstate);
585         }
586         ahc_compile_devinfo(&devinfo, our_id, starget->id,
587                             CAM_LUN_WILDCARD, channel,
588                             ROLE_INITIATOR);
589         ahc_set_syncrate(ahc, &devinfo, NULL, 0, 0, 0,
590                          AHC_TRANS_GOAL, /*paused*/FALSE);
591         ahc_set_width(ahc, &devinfo, MSG_EXT_WDTR_BUS_8_BIT,
592                       AHC_TRANS_GOAL, /*paused*/FALSE);
593         ahc_unlock(ahc, &flags);
594
595         return 0;
596 }
597
598 static void
599 ahc_linux_target_destroy(struct scsi_target *starget)
600 {
601         struct scsi_target **ahc_targp = ahc_linux_target_in_softc(starget);
602
603         *ahc_targp = NULL;
604 }
605
606 static int
607 ahc_linux_slave_alloc(struct scsi_device *sdev)
608 {
609         struct  ahc_softc *ahc =
610                 *((struct ahc_softc **)sdev->host->hostdata);
611         struct scsi_target *starget = sdev->sdev_target;
612         struct ahc_linux_target *targ = scsi_transport_target_data(starget);
613         struct ahc_linux_device *dev;
614
615         if (bootverbose)
616                 printf("%s: Slave Alloc %d\n", ahc_name(ahc), sdev->id);
617
618         BUG_ON(targ->sdev[sdev->lun] != NULL);
619
620         dev = scsi_transport_device_data(sdev);
621         memset(dev, 0, sizeof(*dev));
622
623         /*
624          * We start out life using untagged
625          * transactions of which we allow one.
626          */
627         dev->openings = 1;
628
629         /*
630          * Set maxtags to 0.  This will be changed if we
631          * later determine that we are dealing with
632          * a tagged queuing capable device.
633          */
634         dev->maxtags = 0;
635         
636         targ->sdev[sdev->lun] = sdev;
637
638         spi_period(starget) = 0;
639
640         return 0;
641 }
642
643 static int
644 ahc_linux_slave_configure(struct scsi_device *sdev)
645 {
646         struct  ahc_softc *ahc;
647
648         ahc = *((struct ahc_softc **)sdev->host->hostdata);
649
650         if (bootverbose)
651                 printf("%s: Slave Configure %d\n", ahc_name(ahc), sdev->id);
652
653         ahc_linux_device_queue_depth(sdev);
654
655         /* Initial Domain Validation */
656         if (!spi_initial_dv(sdev->sdev_target))
657                 spi_dv_device(sdev);
658
659         return 0;
660 }
661
662 static void
663 ahc_linux_slave_destroy(struct scsi_device *sdev)
664 {
665         struct  ahc_softc *ahc;
666         struct  ahc_linux_device *dev = scsi_transport_device_data(sdev);
667         struct  ahc_linux_target *targ = scsi_transport_target_data(sdev->sdev_target);
668
669         ahc = *((struct ahc_softc **)sdev->host->hostdata);
670         if (bootverbose)
671                 printf("%s: Slave Destroy %d\n", ahc_name(ahc), sdev->id);
672
673         BUG_ON(dev->active);
674
675         targ->sdev[sdev->lun] = NULL;
676 }
677
678 #if defined(__i386__)
679 /*
680  * Return the disk geometry for the given SCSI device.
681  */
682 static int
683 ahc_linux_biosparam(struct scsi_device *sdev, struct block_device *bdev,
684                     sector_t capacity, int geom[])
685 {
686         uint8_t *bh;
687         int      heads;
688         int      sectors;
689         int      cylinders;
690         int      ret;
691         int      extended;
692         struct   ahc_softc *ahc;
693         u_int    channel;
694
695         ahc = *((struct ahc_softc **)sdev->host->hostdata);
696         channel = sdev->channel;
697
698         bh = scsi_bios_ptable(bdev);
699         if (bh) {
700                 ret = scsi_partsize(bh, capacity,
701                                     &geom[2], &geom[0], &geom[1]);
702                 kfree(bh);
703                 if (ret != -1)
704                         return (ret);
705         }
706         heads = 64;
707         sectors = 32;
708         cylinders = aic_sector_div(capacity, heads, sectors);
709
710         if (aic7xxx_extended != 0)
711                 extended = 1;
712         else if (channel == 0)
713                 extended = (ahc->flags & AHC_EXTENDED_TRANS_A) != 0;
714         else
715                 extended = (ahc->flags & AHC_EXTENDED_TRANS_B) != 0;
716         if (extended && cylinders >= 1024) {
717                 heads = 255;
718                 sectors = 63;
719                 cylinders = aic_sector_div(capacity, heads, sectors);
720         }
721         geom[0] = heads;
722         geom[1] = sectors;
723         geom[2] = cylinders;
724         return (0);
725 }
726 #endif
727
728 /*
729  * Abort the current SCSI command(s).
730  */
731 static int
732 ahc_linux_abort(struct scsi_cmnd *cmd)
733 {
734         int error;
735
736         error = ahc_linux_queue_recovery_cmd(cmd, SCB_ABORT);
737         if (error != 0)
738                 printf("aic7xxx_abort returns 0x%x\n", error);
739         return (error);
740 }
741
742 /*
743  * Attempt to send a target reset message to the device that timed out.
744  */
745 static int
746 ahc_linux_dev_reset(struct scsi_cmnd *cmd)
747 {
748         int error;
749
750         error = ahc_linux_queue_recovery_cmd(cmd, SCB_DEVICE_RESET);
751         if (error != 0)
752                 printf("aic7xxx_dev_reset returns 0x%x\n", error);
753         return (error);
754 }
755
756 /*
757  * Reset the SCSI bus.
758  */
759 static int
760 ahc_linux_bus_reset(struct scsi_cmnd *cmd)
761 {
762         struct ahc_softc *ahc;
763         int    found;
764         unsigned long flags;
765
766         ahc = *(struct ahc_softc **)cmd->device->host->hostdata;
767
768         ahc_lock(ahc, &flags);
769         found = ahc_reset_channel(ahc, cmd->device->channel + 'A',
770                                   /*initiate reset*/TRUE);
771         ahc_unlock(ahc, &flags);
772
773         if (bootverbose)
774                 printf("%s: SCSI bus reset delivered. "
775                        "%d SCBs aborted.\n", ahc_name(ahc), found);
776
777         return SUCCESS;
778 }
779
780 struct scsi_host_template aic7xxx_driver_template = {
781         .module                 = THIS_MODULE,
782         .name                   = "aic7xxx",
783         .proc_name              = "aic7xxx",
784         .proc_info              = ahc_linux_proc_info,
785         .info                   = ahc_linux_info,
786         .queuecommand           = ahc_linux_queue,
787         .eh_abort_handler       = ahc_linux_abort,
788         .eh_device_reset_handler = ahc_linux_dev_reset,
789         .eh_bus_reset_handler   = ahc_linux_bus_reset,
790 #if defined(__i386__)
791         .bios_param             = ahc_linux_biosparam,
792 #endif
793         .can_queue              = AHC_MAX_QUEUE,
794         .this_id                = -1,
795         .cmd_per_lun            = 2,
796         .use_clustering         = ENABLE_CLUSTERING,
797         .slave_alloc            = ahc_linux_slave_alloc,
798         .slave_configure        = ahc_linux_slave_configure,
799         .slave_destroy          = ahc_linux_slave_destroy,
800         .target_alloc           = ahc_linux_target_alloc,
801         .target_destroy         = ahc_linux_target_destroy,
802 };
803
804 /**************************** Tasklet Handler *********************************/
805
806 /******************************** Macros **************************************/
807 #define BUILD_SCSIID(ahc, cmd)                                              \
808         ((((cmd)->device->id << TID_SHIFT) & TID)                           \
809         | (((cmd)->device->channel == 0) ? (ahc)->our_id : (ahc)->our_id_b) \
810         | (((cmd)->device->channel == 0) ? 0 : TWIN_CHNLB))
811
812 /******************************** Bus DMA *************************************/
813 int
814 ahc_dma_tag_create(struct ahc_softc *ahc, bus_dma_tag_t parent,
815                    bus_size_t alignment, bus_size_t boundary,
816                    dma_addr_t lowaddr, dma_addr_t highaddr,
817                    bus_dma_filter_t *filter, void *filterarg,
818                    bus_size_t maxsize, int nsegments,
819                    bus_size_t maxsegsz, int flags, bus_dma_tag_t *ret_tag)
820 {
821         bus_dma_tag_t dmat;
822
823         dmat = malloc(sizeof(*dmat), M_DEVBUF, M_NOWAIT);
824         if (dmat == NULL)
825                 return (ENOMEM);
826
827         /*
828          * Linux is very simplistic about DMA memory.  For now don't
829          * maintain all specification information.  Once Linux supplies
830          * better facilities for doing these operations, or the
831          * needs of this particular driver change, we might need to do
832          * more here.
833          */
834         dmat->alignment = alignment;
835         dmat->boundary = boundary;
836         dmat->maxsize = maxsize;
837         *ret_tag = dmat;
838         return (0);
839 }
840
841 void
842 ahc_dma_tag_destroy(struct ahc_softc *ahc, bus_dma_tag_t dmat)
843 {
844         free(dmat, M_DEVBUF);
845 }
846
847 int
848 ahc_dmamem_alloc(struct ahc_softc *ahc, bus_dma_tag_t dmat, void** vaddr,
849                  int flags, bus_dmamap_t *mapp)
850 {
851         *vaddr = pci_alloc_consistent(ahc->dev_softc,
852                                       dmat->maxsize, mapp);
853         if (*vaddr == NULL)
854                 return ENOMEM;
855         return 0;
856 }
857
858 void
859 ahc_dmamem_free(struct ahc_softc *ahc, bus_dma_tag_t dmat,
860                 void* vaddr, bus_dmamap_t map)
861 {
862         pci_free_consistent(ahc->dev_softc, dmat->maxsize,
863                             vaddr, map);
864 }
865
866 int
867 ahc_dmamap_load(struct ahc_softc *ahc, bus_dma_tag_t dmat, bus_dmamap_t map,
868                 void *buf, bus_size_t buflen, bus_dmamap_callback_t *cb,
869                 void *cb_arg, int flags)
870 {
871         /*
872          * Assume for now that this will only be used during
873          * initialization and not for per-transaction buffer mapping.
874          */
875         bus_dma_segment_t stack_sg;
876
877         stack_sg.ds_addr = map;
878         stack_sg.ds_len = dmat->maxsize;
879         cb(cb_arg, &stack_sg, /*nseg*/1, /*error*/0);
880         return (0);
881 }
882
883 void
884 ahc_dmamap_destroy(struct ahc_softc *ahc, bus_dma_tag_t dmat, bus_dmamap_t map)
885 {
886 }
887
888 int
889 ahc_dmamap_unload(struct ahc_softc *ahc, bus_dma_tag_t dmat, bus_dmamap_t map)
890 {
891         /* Nothing to do */
892         return (0);
893 }
894
895 static void
896 ahc_linux_setup_tag_info_global(char *p)
897 {
898         int tags, i, j;
899
900         tags = simple_strtoul(p + 1, NULL, 0) & 0xff;
901         printf("Setting Global Tags= %d\n", tags);
902
903         for (i = 0; i < NUM_ELEMENTS(aic7xxx_tag_info); i++) {
904                 for (j = 0; j < AHC_NUM_TARGETS; j++) {
905                         aic7xxx_tag_info[i].tag_commands[j] = tags;
906                 }
907         }
908 }
909
910 static void
911 ahc_linux_setup_tag_info(u_long arg, int instance, int targ, int32_t value)
912 {
913
914         if ((instance >= 0) && (targ >= 0)
915          && (instance < NUM_ELEMENTS(aic7xxx_tag_info))
916          && (targ < AHC_NUM_TARGETS)) {
917                 aic7xxx_tag_info[instance].tag_commands[targ] = value & 0xff;
918                 if (bootverbose)
919                         printf("tag_info[%d:%d] = %d\n", instance, targ, value);
920         }
921 }
922
923 /*
924  * Handle Linux boot parameters. This routine allows for assigning a value
925  * to a parameter with a ':' between the parameter and the value.
926  * ie. aic7xxx=stpwlev:1,extended
927  */
928 static int
929 aic7xxx_setup(char *s)
930 {
931         int     i, n;
932         char   *p;
933         char   *end;
934
935         static struct {
936                 const char *name;
937                 uint32_t *flag;
938         } options[] = {
939                 { "extended", &aic7xxx_extended },
940                 { "no_reset", &aic7xxx_no_reset },
941                 { "verbose", &aic7xxx_verbose },
942                 { "allow_memio", &aic7xxx_allow_memio},
943 #ifdef AHC_DEBUG
944                 { "debug", &ahc_debug },
945 #endif
946                 { "periodic_otag", &aic7xxx_periodic_otag },
947                 { "pci_parity", &aic7xxx_pci_parity },
948                 { "seltime", &aic7xxx_seltime },
949                 { "tag_info", NULL },
950                 { "global_tag_depth", NULL },
951                 { "dv", NULL }
952         };
953
954         end = strchr(s, '\0');
955
956         /*
957          * XXX ia64 gcc isn't smart enough to know that NUM_ELEMENTS
958          * will never be 0 in this case.
959          */
960         n = 0;
961
962         while ((p = strsep(&s, ",.")) != NULL) {
963                 if (*p == '\0')
964                         continue;
965                 for (i = 0; i < NUM_ELEMENTS(options); i++) {
966
967                         n = strlen(options[i].name);
968                         if (strncmp(options[i].name, p, n) == 0)
969                                 break;
970                 }
971                 if (i == NUM_ELEMENTS(options))
972                         continue;
973
974                 if (strncmp(p, "global_tag_depth", n) == 0) {
975                         ahc_linux_setup_tag_info_global(p + n);
976                 } else if (strncmp(p, "tag_info", n) == 0) {
977                         s = aic_parse_brace_option("tag_info", p + n, end,
978                             2, ahc_linux_setup_tag_info, 0);
979                 } else if (p[n] == ':') {
980                         *(options[i].flag) = simple_strtoul(p + n + 1, NULL, 0);
981                 } else if (strncmp(p, "verbose", n) == 0) {
982                         *(options[i].flag) = 1;
983                 } else {
984                         *(options[i].flag) ^= 0xFFFFFFFF;
985                 }
986         }
987         return 1;
988 }
989
990 __setup("aic7xxx=", aic7xxx_setup);
991
992 uint32_t aic7xxx_verbose;
993
994 int
995 ahc_linux_register_host(struct ahc_softc *ahc, struct scsi_host_template *template)
996 {
997         char     buf[80];
998         struct   Scsi_Host *host;
999         char    *new_name;
1000         u_long   s;
1001
1002         template->name = ahc->description;
1003         host = scsi_host_alloc(template, sizeof(struct ahc_softc *));
1004         if (host == NULL)
1005                 return (ENOMEM);
1006
1007         *((struct ahc_softc **)host->hostdata) = ahc;
1008         ahc_lock(ahc, &s);
1009         scsi_assign_lock(host, &ahc->platform_data->spin_lock);
1010         ahc->platform_data->host = host;
1011         host->can_queue = AHC_MAX_QUEUE;
1012         host->cmd_per_lun = 2;
1013         /* XXX No way to communicate the ID for multiple channels */
1014         host->this_id = ahc->our_id;
1015         host->irq = ahc->platform_data->irq;
1016         host->max_id = (ahc->features & AHC_WIDE) ? 16 : 8;
1017         host->max_lun = AHC_NUM_LUNS;
1018         host->max_channel = (ahc->features & AHC_TWIN) ? 1 : 0;
1019         host->sg_tablesize = AHC_NSEG;
1020         ahc_set_unit(ahc, ahc_linux_unit++);
1021         sprintf(buf, "scsi%d", host->host_no);
1022         new_name = malloc(strlen(buf) + 1, M_DEVBUF, M_NOWAIT);
1023         if (new_name != NULL) {
1024                 strcpy(new_name, buf);
1025                 ahc_set_name(ahc, new_name);
1026         }
1027         host->unique_id = ahc->unit;
1028         ahc_linux_initialize_scsi_bus(ahc);
1029         ahc_intr_enable(ahc, TRUE);
1030         ahc_unlock(ahc, &s);
1031
1032         host->transportt = ahc_linux_transport_template;
1033
1034         scsi_add_host(host, (ahc->dev_softc ? &ahc->dev_softc->dev : NULL)); /* XXX handle failure */
1035         scsi_scan_host(host);
1036         return (0);
1037 }
1038
1039 uint64_t
1040 ahc_linux_get_memsize(void)
1041 {
1042         struct sysinfo si;
1043
1044         si_meminfo(&si);
1045         return ((uint64_t)si.totalram << PAGE_SHIFT);
1046 }
1047
1048 /*
1049  * Place the SCSI bus into a known state by either resetting it,
1050  * or forcing transfer negotiations on the next command to any
1051  * target.
1052  */
1053 void
1054 ahc_linux_initialize_scsi_bus(struct ahc_softc *ahc)
1055 {
1056         int i;
1057         int numtarg;
1058
1059         i = 0;
1060         numtarg = 0;
1061
1062         if (aic7xxx_no_reset != 0)
1063                 ahc->flags &= ~(AHC_RESET_BUS_A|AHC_RESET_BUS_B);
1064
1065         if ((ahc->flags & AHC_RESET_BUS_A) != 0)
1066                 ahc_reset_channel(ahc, 'A', /*initiate_reset*/TRUE);
1067         else
1068                 numtarg = (ahc->features & AHC_WIDE) ? 16 : 8;
1069
1070         if ((ahc->features & AHC_TWIN) != 0) {
1071
1072                 if ((ahc->flags & AHC_RESET_BUS_B) != 0) {
1073                         ahc_reset_channel(ahc, 'B', /*initiate_reset*/TRUE);
1074                 } else {
1075                         if (numtarg == 0)
1076                                 i = 8;
1077                         numtarg += 8;
1078                 }
1079         }
1080
1081         /*
1082          * Force negotiation to async for all targets that
1083          * will not see an initial bus reset.
1084          */
1085         for (; i < numtarg; i++) {
1086                 struct ahc_devinfo devinfo;
1087                 struct ahc_initiator_tinfo *tinfo;
1088                 struct ahc_tmode_tstate *tstate;
1089                 u_int our_id;
1090                 u_int target_id;
1091                 char channel;
1092
1093                 channel = 'A';
1094                 our_id = ahc->our_id;
1095                 target_id = i;
1096                 if (i > 7 && (ahc->features & AHC_TWIN) != 0) {
1097                         channel = 'B';
1098                         our_id = ahc->our_id_b;
1099                         target_id = i % 8;
1100                 }
1101                 tinfo = ahc_fetch_transinfo(ahc, channel, our_id,
1102                                             target_id, &tstate);
1103                 ahc_compile_devinfo(&devinfo, our_id, target_id,
1104                                     CAM_LUN_WILDCARD, channel, ROLE_INITIATOR);
1105                 ahc_update_neg_request(ahc, &devinfo, tstate,
1106                                        tinfo, AHC_NEG_ALWAYS);
1107         }
1108         /* Give the bus some time to recover */
1109         if ((ahc->flags & (AHC_RESET_BUS_A|AHC_RESET_BUS_B)) != 0) {
1110                 ahc_linux_freeze_simq(ahc);
1111                 init_timer(&ahc->platform_data->reset_timer);
1112                 ahc->platform_data->reset_timer.data = (u_long)ahc;
1113                 ahc->platform_data->reset_timer.expires =
1114                     jiffies + (AIC7XXX_RESET_DELAY * HZ)/1000;
1115                 ahc->platform_data->reset_timer.function =
1116                     ahc_linux_release_simq;
1117                 add_timer(&ahc->platform_data->reset_timer);
1118         }
1119 }
1120
1121 int
1122 ahc_platform_alloc(struct ahc_softc *ahc, void *platform_arg)
1123 {
1124
1125         ahc->platform_data =
1126             malloc(sizeof(struct ahc_platform_data), M_DEVBUF, M_NOWAIT);
1127         if (ahc->platform_data == NULL)
1128                 return (ENOMEM);
1129         memset(ahc->platform_data, 0, sizeof(struct ahc_platform_data));
1130         ahc->platform_data->irq = AHC_LINUX_NOIRQ;
1131         ahc_lockinit(ahc);
1132         init_MUTEX_LOCKED(&ahc->platform_data->eh_sem);
1133         ahc->seltime = (aic7xxx_seltime & 0x3) << 4;
1134         ahc->seltime_b = (aic7xxx_seltime & 0x3) << 4;
1135         if (aic7xxx_pci_parity == 0)
1136                 ahc->flags |= AHC_DISABLE_PCI_PERR;
1137
1138         return (0);
1139 }
1140
1141 void
1142 ahc_platform_free(struct ahc_softc *ahc)
1143 {
1144         struct scsi_target *starget;
1145         int i, j;
1146
1147         if (ahc->platform_data != NULL) {
1148                 if (ahc->platform_data->host != NULL) {
1149                         scsi_remove_host(ahc->platform_data->host);
1150                         scsi_host_put(ahc->platform_data->host);
1151                 }
1152
1153                 /* destroy all of the device and target objects */
1154                 for (i = 0; i < AHC_NUM_TARGETS; i++) {
1155                         starget = ahc->platform_data->starget[i];
1156                         if (starget != NULL) {
1157                                 for (j = 0; j < AHC_NUM_LUNS; j++) {
1158                                         struct ahc_linux_target *targ =
1159                                                 scsi_transport_target_data(starget);
1160
1161                                         if (targ->sdev[j] == NULL)
1162                                                 continue;
1163                                         targ->sdev[j] = NULL;
1164                                 }
1165                                 ahc->platform_data->starget[i] = NULL;
1166                         }
1167                 }
1168
1169                 if (ahc->platform_data->irq != AHC_LINUX_NOIRQ)
1170                         free_irq(ahc->platform_data->irq, ahc);
1171                 if (ahc->tag == BUS_SPACE_PIO
1172                  && ahc->bsh.ioport != 0)
1173                         release_region(ahc->bsh.ioport, 256);
1174                 if (ahc->tag == BUS_SPACE_MEMIO
1175                  && ahc->bsh.maddr != NULL) {
1176                         iounmap(ahc->bsh.maddr);
1177                         release_mem_region(ahc->platform_data->mem_busaddr,
1178                                            0x1000);
1179                 }
1180
1181                 free(ahc->platform_data, M_DEVBUF);
1182         }
1183 }
1184
1185 void
1186 ahc_platform_freeze_devq(struct ahc_softc *ahc, struct scb *scb)
1187 {
1188         ahc_platform_abort_scbs(ahc, SCB_GET_TARGET(ahc, scb),
1189                                 SCB_GET_CHANNEL(ahc, scb),
1190                                 SCB_GET_LUN(scb), SCB_LIST_NULL,
1191                                 ROLE_UNKNOWN, CAM_REQUEUE_REQ);
1192 }
1193
1194 void
1195 ahc_platform_set_tags(struct ahc_softc *ahc, struct ahc_devinfo *devinfo,
1196                       ahc_queue_alg alg)
1197 {
1198         struct scsi_target *starget;
1199         struct ahc_linux_target *targ;
1200         struct ahc_linux_device *dev;
1201         struct scsi_device *sdev;
1202         u_int target_offset;
1203         int was_queuing;
1204         int now_queuing;
1205
1206         target_offset = devinfo->target;
1207         if (devinfo->channel != 'A')
1208                 target_offset += 8;
1209         starget = ahc->platform_data->starget[target_offset];
1210         targ = scsi_transport_target_data(starget);
1211         BUG_ON(targ == NULL);
1212         sdev = targ->sdev[devinfo->lun];
1213         if (sdev == NULL)
1214                 return;
1215         dev = scsi_transport_device_data(sdev);
1216
1217         was_queuing = dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED);
1218         switch (alg) {
1219         default:
1220         case AHC_QUEUE_NONE:
1221                 now_queuing = 0;
1222                 break; 
1223         case AHC_QUEUE_BASIC:
1224                 now_queuing = AHC_DEV_Q_BASIC;
1225                 break;
1226         case AHC_QUEUE_TAGGED:
1227                 now_queuing = AHC_DEV_Q_TAGGED;
1228                 break;
1229         }
1230         if ((dev->flags & AHC_DEV_FREEZE_TIL_EMPTY) == 0
1231          && (was_queuing != now_queuing)
1232          && (dev->active != 0)) {
1233                 dev->flags |= AHC_DEV_FREEZE_TIL_EMPTY;
1234                 dev->qfrozen++;
1235         }
1236
1237         dev->flags &= ~(AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED|AHC_DEV_PERIODIC_OTAG);
1238         if (now_queuing) {
1239                 u_int usertags;
1240
1241                 usertags = ahc_linux_user_tagdepth(ahc, devinfo);
1242                 if (!was_queuing) {
1243                         /*
1244                          * Start out agressively and allow our
1245                          * dynamic queue depth algorithm to take
1246                          * care of the rest.
1247                          */
1248                         dev->maxtags = usertags;
1249                         dev->openings = dev->maxtags - dev->active;
1250                 }
1251                 if (dev->maxtags == 0) {
1252                         /*
1253                          * Queueing is disabled by the user.
1254                          */
1255                         dev->openings = 1;
1256                 } else if (alg == AHC_QUEUE_TAGGED) {
1257                         dev->flags |= AHC_DEV_Q_TAGGED;
1258                         if (aic7xxx_periodic_otag != 0)
1259                                 dev->flags |= AHC_DEV_PERIODIC_OTAG;
1260                 } else
1261                         dev->flags |= AHC_DEV_Q_BASIC;
1262         } else {
1263                 /* We can only have one opening. */
1264                 dev->maxtags = 0;
1265                 dev->openings =  1 - dev->active;
1266         }
1267         switch ((dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED))) {
1268         case AHC_DEV_Q_BASIC:
1269                 scsi_set_tag_type(sdev, MSG_SIMPLE_TAG);
1270                 scsi_activate_tcq(sdev, dev->openings + dev->active);
1271                 break;
1272         case AHC_DEV_Q_TAGGED:
1273                 scsi_set_tag_type(sdev, MSG_ORDERED_TAG);
1274                 scsi_activate_tcq(sdev, dev->openings + dev->active);
1275                 break;
1276         default:
1277                 /*
1278                  * We allow the OS to queue 2 untagged transactions to
1279                  * us at any time even though we can only execute them
1280                  * serially on the controller/device.  This should
1281                  * remove some latency.
1282                  */
1283                 scsi_deactivate_tcq(sdev, 2);
1284                 break;
1285         }
1286 }
1287
1288 int
1289 ahc_platform_abort_scbs(struct ahc_softc *ahc, int target, char channel,
1290                         int lun, u_int tag, role_t role, uint32_t status)
1291 {
1292         return 0;
1293 }
1294
1295 static u_int
1296 ahc_linux_user_tagdepth(struct ahc_softc *ahc, struct ahc_devinfo *devinfo)
1297 {
1298         static int warned_user;
1299         u_int tags;
1300
1301         tags = 0;
1302         if ((ahc->user_discenable & devinfo->target_mask) != 0) {
1303                 if (ahc->unit >= NUM_ELEMENTS(aic7xxx_tag_info)) {
1304                         if (warned_user == 0) {
1305
1306                                 printf(KERN_WARNING
1307 "aic7xxx: WARNING: Insufficient tag_info instances\n"
1308 "aic7xxx: for installed controllers. Using defaults\n"
1309 "aic7xxx: Please update the aic7xxx_tag_info array in\n"
1310 "aic7xxx: the aic7xxx_osm..c source file.\n");
1311                                 warned_user++;
1312                         }
1313                         tags = AHC_MAX_QUEUE;
1314                 } else {
1315                         adapter_tag_info_t *tag_info;
1316
1317                         tag_info = &aic7xxx_tag_info[ahc->unit];
1318                         tags = tag_info->tag_commands[devinfo->target_offset];
1319                         if (tags > AHC_MAX_QUEUE)
1320                                 tags = AHC_MAX_QUEUE;
1321                 }
1322         }
1323         return (tags);
1324 }
1325
1326 /*
1327  * Determines the queue depth for a given device.
1328  */
1329 static void
1330 ahc_linux_device_queue_depth(struct scsi_device *sdev)
1331 {
1332         struct  ahc_devinfo devinfo;
1333         u_int   tags;
1334         struct ahc_softc *ahc = *((struct ahc_softc **)sdev->host->hostdata);
1335
1336         ahc_compile_devinfo(&devinfo,
1337                             sdev->sdev_target->channel == 0
1338                           ? ahc->our_id : ahc->our_id_b,
1339                             sdev->sdev_target->id, sdev->lun,
1340                             sdev->sdev_target->channel == 0 ? 'A' : 'B',
1341                             ROLE_INITIATOR);
1342         tags = ahc_linux_user_tagdepth(ahc, &devinfo);
1343         if (tags != 0 && sdev->tagged_supported != 0) {
1344
1345                 ahc_set_tags(ahc, &devinfo, AHC_QUEUE_TAGGED);
1346                 ahc_print_devinfo(ahc, &devinfo);
1347                 printf("Tagged Queuing enabled.  Depth %d\n", tags);
1348         } else {
1349                 ahc_set_tags(ahc, &devinfo, AHC_QUEUE_NONE);
1350         }
1351 }
1352
1353 static int
1354 ahc_linux_run_command(struct ahc_softc *ahc, struct ahc_linux_device *dev,
1355                       struct scsi_cmnd *cmd)
1356 {
1357         struct   scb *scb;
1358         struct   hardware_scb *hscb;
1359         struct   ahc_initiator_tinfo *tinfo;
1360         struct   ahc_tmode_tstate *tstate;
1361         uint16_t mask;
1362         struct scb_tailq *untagged_q = NULL;
1363
1364         /*
1365          * Schedule us to run later.  The only reason we are not
1366          * running is because the whole controller Q is frozen.
1367          */
1368         if (ahc->platform_data->qfrozen != 0)
1369                 return SCSI_MLQUEUE_HOST_BUSY;
1370
1371         /*
1372          * We only allow one untagged transaction
1373          * per target in the initiator role unless
1374          * we are storing a full busy target *lun*
1375          * table in SCB space.
1376          */
1377         if (!blk_rq_tagged(cmd->request)
1378             && (ahc->features & AHC_SCB_BTT) == 0) {
1379                 int target_offset;
1380
1381                 target_offset = cmd->device->id + cmd->device->channel * 8;
1382                 untagged_q = &(ahc->untagged_queues[target_offset]);
1383                 if (!TAILQ_EMPTY(untagged_q))
1384                         /* if we're already executing an untagged command
1385                          * we're busy to another */
1386                         return SCSI_MLQUEUE_DEVICE_BUSY;
1387         }
1388
1389         /*
1390          * Get an scb to use.
1391          */
1392         scb = ahc_get_scb(ahc);
1393         if (!scb)
1394                 return SCSI_MLQUEUE_HOST_BUSY;
1395
1396         scb->io_ctx = cmd;
1397         scb->platform_data->dev = dev;
1398         hscb = scb->hscb;
1399         cmd->host_scribble = (char *)scb;
1400
1401         /*
1402          * Fill out basics of the HSCB.
1403          */
1404         hscb->control = 0;
1405         hscb->scsiid = BUILD_SCSIID(ahc, cmd);
1406         hscb->lun = cmd->device->lun;
1407         mask = SCB_GET_TARGET_MASK(ahc, scb);
1408         tinfo = ahc_fetch_transinfo(ahc, SCB_GET_CHANNEL(ahc, scb),
1409                                     SCB_GET_OUR_ID(scb),
1410                                     SCB_GET_TARGET(ahc, scb), &tstate);
1411         hscb->scsirate = tinfo->scsirate;
1412         hscb->scsioffset = tinfo->curr.offset;
1413         if ((tstate->ultraenb & mask) != 0)
1414                 hscb->control |= ULTRAENB;
1415         
1416         if ((ahc->user_discenable & mask) != 0)
1417                 hscb->control |= DISCENB;
1418         
1419         if ((tstate->auto_negotiate & mask) != 0) {
1420                 scb->flags |= SCB_AUTO_NEGOTIATE;
1421                 scb->hscb->control |= MK_MESSAGE;
1422         }
1423
1424         if ((dev->flags & (AHC_DEV_Q_TAGGED|AHC_DEV_Q_BASIC)) != 0) {
1425                 int     msg_bytes;
1426                 uint8_t tag_msgs[2];
1427                 
1428                 msg_bytes = scsi_populate_tag_msg(cmd, tag_msgs);
1429                 if (msg_bytes && tag_msgs[0] != MSG_SIMPLE_TASK) {
1430                         hscb->control |= tag_msgs[0];
1431                         if (tag_msgs[0] == MSG_ORDERED_TASK)
1432                                 dev->commands_since_idle_or_otag = 0;
1433                 } else if (dev->commands_since_idle_or_otag == AHC_OTAG_THRESH
1434                                 && (dev->flags & AHC_DEV_Q_TAGGED) != 0) {
1435                         hscb->control |= MSG_ORDERED_TASK;
1436                         dev->commands_since_idle_or_otag = 0;
1437                 } else {
1438                         hscb->control |= MSG_SIMPLE_TASK;
1439                 }
1440         }
1441
1442         hscb->cdb_len = cmd->cmd_len;
1443         if (hscb->cdb_len <= 12) {
1444                 memcpy(hscb->shared_data.cdb, cmd->cmnd, hscb->cdb_len);
1445         } else {
1446                 memcpy(hscb->cdb32, cmd->cmnd, hscb->cdb_len);
1447                 scb->flags |= SCB_CDB32_PTR;
1448         }
1449
1450         scb->platform_data->xfer_len = 0;
1451         ahc_set_residual(scb, 0);
1452         ahc_set_sense_residual(scb, 0);
1453         scb->sg_count = 0;
1454         if (cmd->use_sg != 0) {
1455                 struct  ahc_dma_seg *sg;
1456                 struct  scatterlist *cur_seg;
1457                 struct  scatterlist *end_seg;
1458                 int     nseg;
1459
1460                 cur_seg = (struct scatterlist *)cmd->request_buffer;
1461                 nseg = pci_map_sg(ahc->dev_softc, cur_seg, cmd->use_sg,
1462                                   cmd->sc_data_direction);
1463                 end_seg = cur_seg + nseg;
1464                 /* Copy the segments into the SG list. */
1465                 sg = scb->sg_list;
1466                 /*
1467                  * The sg_count may be larger than nseg if
1468                  * a transfer crosses a 32bit page.
1469                  */ 
1470                 while (cur_seg < end_seg) {
1471                         dma_addr_t addr;
1472                         bus_size_t len;
1473                         int consumed;
1474
1475                         addr = sg_dma_address(cur_seg);
1476                         len = sg_dma_len(cur_seg);
1477                         consumed = ahc_linux_map_seg(ahc, scb,
1478                                                      sg, addr, len);
1479                         sg += consumed;
1480                         scb->sg_count += consumed;
1481                         cur_seg++;
1482                 }
1483                 sg--;
1484                 sg->len |= ahc_htole32(AHC_DMA_LAST_SEG);
1485
1486                 /*
1487                  * Reset the sg list pointer.
1488                  */
1489                 scb->hscb->sgptr =
1490                         ahc_htole32(scb->sg_list_phys | SG_FULL_RESID);
1491                 
1492                 /*
1493                  * Copy the first SG into the "current"
1494                  * data pointer area.
1495                  */
1496                 scb->hscb->dataptr = scb->sg_list->addr;
1497                 scb->hscb->datacnt = scb->sg_list->len;
1498         } else if (cmd->request_bufflen != 0) {
1499                 struct   ahc_dma_seg *sg;
1500                 dma_addr_t addr;
1501
1502                 sg = scb->sg_list;
1503                 addr = pci_map_single(ahc->dev_softc,
1504                                       cmd->request_buffer,
1505                                       cmd->request_bufflen,
1506                                       cmd->sc_data_direction);
1507                 scb->platform_data->buf_busaddr = addr;
1508                 scb->sg_count = ahc_linux_map_seg(ahc, scb,
1509                                                   sg, addr,
1510                                                   cmd->request_bufflen);
1511                 sg->len |= ahc_htole32(AHC_DMA_LAST_SEG);
1512
1513                 /*
1514                  * Reset the sg list pointer.
1515                  */
1516                 scb->hscb->sgptr =
1517                         ahc_htole32(scb->sg_list_phys | SG_FULL_RESID);
1518
1519                 /*
1520                  * Copy the first SG into the "current"
1521                  * data pointer area.
1522                  */
1523                 scb->hscb->dataptr = sg->addr;
1524                 scb->hscb->datacnt = sg->len;
1525         } else {
1526                 scb->hscb->sgptr = ahc_htole32(SG_LIST_NULL);
1527                 scb->hscb->dataptr = 0;
1528                 scb->hscb->datacnt = 0;
1529                 scb->sg_count = 0;
1530         }
1531
1532         LIST_INSERT_HEAD(&ahc->pending_scbs, scb, pending_links);
1533         dev->openings--;
1534         dev->active++;
1535         dev->commands_issued++;
1536         if ((dev->flags & AHC_DEV_PERIODIC_OTAG) != 0)
1537                 dev->commands_since_idle_or_otag++;
1538         
1539         scb->flags |= SCB_ACTIVE;
1540         if (untagged_q) {
1541                 TAILQ_INSERT_TAIL(untagged_q, scb, links.tqe);
1542                 scb->flags |= SCB_UNTAGGEDQ;
1543         }
1544         ahc_queue_scb(ahc, scb);
1545         return 0;
1546 }
1547
1548 /*
1549  * SCSI controller interrupt handler.
1550  */
1551 irqreturn_t
1552 ahc_linux_isr(int irq, void *dev_id, struct pt_regs * regs)
1553 {
1554         struct  ahc_softc *ahc;
1555         u_long  flags;
1556         int     ours;
1557
1558         ahc = (struct ahc_softc *) dev_id;
1559         ahc_lock(ahc, &flags); 
1560         ours = ahc_intr(ahc);
1561         ahc_unlock(ahc, &flags);
1562         return IRQ_RETVAL(ours);
1563 }
1564
1565 void
1566 ahc_platform_flushwork(struct ahc_softc *ahc)
1567 {
1568
1569 }
1570
1571 void
1572 ahc_send_async(struct ahc_softc *ahc, char channel,
1573                u_int target, u_int lun, ac_code code, void *arg)
1574 {
1575         switch (code) {
1576         case AC_TRANSFER_NEG:
1577         {
1578                 char    buf[80];
1579                 struct  scsi_target *starget;
1580                 struct  ahc_linux_target *targ;
1581                 struct  info_str info;
1582                 struct  ahc_initiator_tinfo *tinfo;
1583                 struct  ahc_tmode_tstate *tstate;
1584                 int     target_offset;
1585                 unsigned int target_ppr_options;
1586
1587                 BUG_ON(target == CAM_TARGET_WILDCARD);
1588
1589                 info.buffer = buf;
1590                 info.length = sizeof(buf);
1591                 info.offset = 0;
1592                 info.pos = 0;
1593                 tinfo = ahc_fetch_transinfo(ahc, channel,
1594                                                 channel == 'A' ? ahc->our_id
1595                                                                : ahc->our_id_b,
1596                                                 target, &tstate);
1597
1598                 /*
1599                  * Don't bother reporting results while
1600                  * negotiations are still pending.
1601                  */
1602                 if (tinfo->curr.period != tinfo->goal.period
1603                  || tinfo->curr.width != tinfo->goal.width
1604                  || tinfo->curr.offset != tinfo->goal.offset
1605                  || tinfo->curr.ppr_options != tinfo->goal.ppr_options)
1606                         if (bootverbose == 0)
1607                                 break;
1608
1609                 /*
1610                  * Don't bother reporting results that
1611                  * are identical to those last reported.
1612                  */
1613                 target_offset = target;
1614                 if (channel == 'B')
1615                         target_offset += 8;
1616                 starget = ahc->platform_data->starget[target_offset];
1617                 if (starget == NULL)
1618                         break;
1619                 targ = scsi_transport_target_data(starget);
1620
1621                 target_ppr_options =
1622                         (spi_dt(starget) ? MSG_EXT_PPR_DT_REQ : 0)
1623                         + (spi_qas(starget) ? MSG_EXT_PPR_QAS_REQ : 0)
1624                         + (spi_iu(starget) ?  MSG_EXT_PPR_IU_REQ : 0);
1625
1626                 if (tinfo->curr.period == spi_period(starget)
1627                     && tinfo->curr.width == spi_width(starget)
1628                     && tinfo->curr.offset == spi_offset(starget)
1629                  && tinfo->curr.ppr_options == target_ppr_options)
1630                         if (bootverbose == 0)
1631                                 break;
1632
1633                 spi_period(starget) = tinfo->curr.period;
1634                 spi_width(starget) = tinfo->curr.width;
1635                 spi_offset(starget) = tinfo->curr.offset;
1636                 spi_dt(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_DT_REQ ? 1 : 0;
1637                 spi_qas(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_QAS_REQ ? 1 : 0;
1638                 spi_iu(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ ? 1 : 0;
1639                 spi_display_xfer_agreement(starget);
1640                 break;
1641         }
1642         case AC_SENT_BDR:
1643         {
1644                 WARN_ON(lun != CAM_LUN_WILDCARD);
1645                 scsi_report_device_reset(ahc->platform_data->host,
1646                                          channel - 'A', target);
1647                 break;
1648         }
1649         case AC_BUS_RESET:
1650                 if (ahc->platform_data->host != NULL) {
1651                         scsi_report_bus_reset(ahc->platform_data->host,
1652                                               channel - 'A');
1653                 }
1654                 break;
1655         default:
1656                 panic("ahc_send_async: Unexpected async event");
1657         }
1658 }
1659
1660 /*
1661  * Calls the higher level scsi done function and frees the scb.
1662  */
1663 void
1664 ahc_done(struct ahc_softc *ahc, struct scb *scb)
1665 {
1666         struct scsi_cmnd *cmd;
1667         struct     ahc_linux_device *dev;
1668
1669         LIST_REMOVE(scb, pending_links);
1670         if ((scb->flags & SCB_UNTAGGEDQ) != 0) {
1671                 struct scb_tailq *untagged_q;
1672                 int target_offset;
1673
1674                 target_offset = SCB_GET_TARGET_OFFSET(ahc, scb);
1675                 untagged_q = &(ahc->untagged_queues[target_offset]);
1676                 TAILQ_REMOVE(untagged_q, scb, links.tqe);
1677                 BUG_ON(!TAILQ_EMPTY(untagged_q));
1678         }
1679
1680         if ((scb->flags & SCB_ACTIVE) == 0) {
1681                 printf("SCB %d done'd twice\n", scb->hscb->tag);
1682                 ahc_dump_card_state(ahc);
1683                 panic("Stopping for safety");
1684         }
1685         cmd = scb->io_ctx;
1686         dev = scb->platform_data->dev;
1687         dev->active--;
1688         dev->openings++;
1689         if ((cmd->result & (CAM_DEV_QFRZN << 16)) != 0) {
1690                 cmd->result &= ~(CAM_DEV_QFRZN << 16);
1691                 dev->qfrozen--;
1692         }
1693         ahc_linux_unmap_scb(ahc, scb);
1694
1695         /*
1696          * Guard against stale sense data.
1697          * The Linux mid-layer assumes that sense
1698          * was retrieved anytime the first byte of
1699          * the sense buffer looks "sane".
1700          */
1701         cmd->sense_buffer[0] = 0;
1702         if (ahc_get_transaction_status(scb) == CAM_REQ_INPROG) {
1703                 uint32_t amount_xferred;
1704
1705                 amount_xferred =
1706                     ahc_get_transfer_length(scb) - ahc_get_residual(scb);
1707                 if ((scb->flags & SCB_TRANSMISSION_ERROR) != 0) {
1708 #ifdef AHC_DEBUG
1709                         if ((ahc_debug & AHC_SHOW_MISC) != 0) {
1710                                 ahc_print_path(ahc, scb);
1711                                 printf("Set CAM_UNCOR_PARITY\n");
1712                         }
1713 #endif
1714                         ahc_set_transaction_status(scb, CAM_UNCOR_PARITY);
1715 #ifdef AHC_REPORT_UNDERFLOWS
1716                 /*
1717                  * This code is disabled by default as some
1718                  * clients of the SCSI system do not properly
1719                  * initialize the underflow parameter.  This
1720                  * results in spurious termination of commands
1721                  * that complete as expected (e.g. underflow is
1722                  * allowed as command can return variable amounts
1723                  * of data.
1724                  */
1725                 } else if (amount_xferred < scb->io_ctx->underflow) {
1726                         u_int i;
1727
1728                         ahc_print_path(ahc, scb);
1729                         printf("CDB:");
1730                         for (i = 0; i < scb->io_ctx->cmd_len; i++)
1731                                 printf(" 0x%x", scb->io_ctx->cmnd[i]);
1732                         printf("\n");
1733                         ahc_print_path(ahc, scb);
1734                         printf("Saw underflow (%ld of %ld bytes). "
1735                                "Treated as error\n",
1736                                 ahc_get_residual(scb),
1737                                 ahc_get_transfer_length(scb));
1738                         ahc_set_transaction_status(scb, CAM_DATA_RUN_ERR);
1739 #endif
1740                 } else {
1741                         ahc_set_transaction_status(scb, CAM_REQ_CMP);
1742                 }
1743         } else if (ahc_get_transaction_status(scb) == CAM_SCSI_STATUS_ERROR) {
1744                 ahc_linux_handle_scsi_status(ahc, cmd->device, scb);
1745         }
1746
1747         if (dev->openings == 1
1748          && ahc_get_transaction_status(scb) == CAM_REQ_CMP
1749          && ahc_get_scsi_status(scb) != SCSI_STATUS_QUEUE_FULL)
1750                 dev->tag_success_count++;
1751         /*
1752          * Some devices deal with temporary internal resource
1753          * shortages by returning queue full.  When the queue
1754          * full occurrs, we throttle back.  Slowly try to get
1755          * back to our previous queue depth.
1756          */
1757         if ((dev->openings + dev->active) < dev->maxtags
1758          && dev->tag_success_count > AHC_TAG_SUCCESS_INTERVAL) {
1759                 dev->tag_success_count = 0;
1760                 dev->openings++;
1761         }
1762
1763         if (dev->active == 0)
1764                 dev->commands_since_idle_or_otag = 0;
1765
1766         if ((scb->flags & SCB_RECOVERY_SCB) != 0) {
1767                 printf("Recovery SCB completes\n");
1768                 if (ahc_get_transaction_status(scb) == CAM_BDR_SENT
1769                  || ahc_get_transaction_status(scb) == CAM_REQ_ABORTED)
1770                         ahc_set_transaction_status(scb, CAM_CMD_TIMEOUT);
1771                 if ((ahc->platform_data->flags & AHC_UP_EH_SEMAPHORE) != 0) {
1772                         ahc->platform_data->flags &= ~AHC_UP_EH_SEMAPHORE;
1773                         up(&ahc->platform_data->eh_sem);
1774                 }
1775         }
1776
1777         ahc_free_scb(ahc, scb);
1778         ahc_linux_queue_cmd_complete(ahc, cmd);
1779 }
1780
1781 static void
1782 ahc_linux_handle_scsi_status(struct ahc_softc *ahc,
1783                              struct scsi_device *sdev, struct scb *scb)
1784 {
1785         struct  ahc_devinfo devinfo;
1786         struct ahc_linux_device *dev = scsi_transport_device_data(sdev);
1787
1788         ahc_compile_devinfo(&devinfo,
1789                             ahc->our_id,
1790                             sdev->sdev_target->id, sdev->lun,
1791                             sdev->sdev_target->channel == 0 ? 'A' : 'B',
1792                             ROLE_INITIATOR);
1793         
1794         /*
1795          * We don't currently trust the mid-layer to
1796          * properly deal with queue full or busy.  So,
1797          * when one occurs, we tell the mid-layer to
1798          * unconditionally requeue the command to us
1799          * so that we can retry it ourselves.  We also
1800          * implement our own throttling mechanism so
1801          * we don't clobber the device with too many
1802          * commands.
1803          */
1804         switch (ahc_get_scsi_status(scb)) {
1805         default:
1806                 break;
1807         case SCSI_STATUS_CHECK_COND:
1808         case SCSI_STATUS_CMD_TERMINATED:
1809         {
1810                 struct scsi_cmnd *cmd;
1811
1812                 /*
1813                  * Copy sense information to the OS's cmd
1814                  * structure if it is available.
1815                  */
1816                 cmd = scb->io_ctx;
1817                 if (scb->flags & SCB_SENSE) {
1818                         u_int sense_size;
1819
1820                         sense_size = MIN(sizeof(struct scsi_sense_data)
1821                                        - ahc_get_sense_residual(scb),
1822                                          sizeof(cmd->sense_buffer));
1823                         memcpy(cmd->sense_buffer,
1824                                ahc_get_sense_buf(ahc, scb), sense_size);
1825                         if (sense_size < sizeof(cmd->sense_buffer))
1826                                 memset(&cmd->sense_buffer[sense_size], 0,
1827                                        sizeof(cmd->sense_buffer) - sense_size);
1828                         cmd->result |= (DRIVER_SENSE << 24);
1829 #ifdef AHC_DEBUG
1830                         if (ahc_debug & AHC_SHOW_SENSE) {
1831                                 int i;
1832
1833                                 printf("Copied %d bytes of sense data:",
1834                                        sense_size);
1835                                 for (i = 0; i < sense_size; i++) {
1836                                         if ((i & 0xF) == 0)
1837                                                 printf("\n");
1838                                         printf("0x%x ", cmd->sense_buffer[i]);
1839                                 }
1840                                 printf("\n");
1841                         }
1842 #endif
1843                 }
1844                 break;
1845         }
1846         case SCSI_STATUS_QUEUE_FULL:
1847         {
1848                 /*
1849                  * By the time the core driver has returned this
1850                  * command, all other commands that were queued
1851                  * to us but not the device have been returned.
1852                  * This ensures that dev->active is equal to
1853                  * the number of commands actually queued to
1854                  * the device.
1855                  */
1856                 dev->tag_success_count = 0;
1857                 if (dev->active != 0) {
1858                         /*
1859                          * Drop our opening count to the number
1860                          * of commands currently outstanding.
1861                          */
1862                         dev->openings = 0;
1863 /*
1864                         ahc_print_path(ahc, scb);
1865                         printf("Dropping tag count to %d\n", dev->active);
1866  */
1867                         if (dev->active == dev->tags_on_last_queuefull) {
1868
1869                                 dev->last_queuefull_same_count++;
1870                                 /*
1871                                  * If we repeatedly see a queue full
1872                                  * at the same queue depth, this
1873                                  * device has a fixed number of tag
1874                                  * slots.  Lock in this tag depth
1875                                  * so we stop seeing queue fulls from
1876                                  * this device.
1877                                  */
1878                                 if (dev->last_queuefull_same_count
1879                                  == AHC_LOCK_TAGS_COUNT) {
1880                                         dev->maxtags = dev->active;
1881                                         ahc_print_path(ahc, scb);
1882                                         printf("Locking max tag count at %d\n",
1883                                                dev->active);
1884                                 }
1885                         } else {
1886                                 dev->tags_on_last_queuefull = dev->active;
1887                                 dev->last_queuefull_same_count = 0;
1888                         }
1889                         ahc_set_transaction_status(scb, CAM_REQUEUE_REQ);
1890                         ahc_set_scsi_status(scb, SCSI_STATUS_OK);
1891                         ahc_platform_set_tags(ahc, &devinfo,
1892                                      (dev->flags & AHC_DEV_Q_BASIC)
1893                                    ? AHC_QUEUE_BASIC : AHC_QUEUE_TAGGED);
1894                         break;
1895                 }
1896                 /*
1897                  * Drop down to a single opening, and treat this
1898                  * as if the target returned BUSY SCSI status.
1899                  */
1900                 dev->openings = 1;
1901                 ahc_set_scsi_status(scb, SCSI_STATUS_BUSY);
1902                 ahc_platform_set_tags(ahc, &devinfo,
1903                              (dev->flags & AHC_DEV_Q_BASIC)
1904                            ? AHC_QUEUE_BASIC : AHC_QUEUE_TAGGED);
1905                 break;
1906         }
1907         }
1908 }
1909
1910 static void
1911 ahc_linux_queue_cmd_complete(struct ahc_softc *ahc, struct scsi_cmnd *cmd)
1912 {
1913         /*
1914          * Map CAM error codes into Linux Error codes.  We
1915          * avoid the conversion so that the DV code has the
1916          * full error information available when making
1917          * state change decisions.
1918          */
1919         {
1920                 u_int new_status;
1921
1922                 switch (ahc_cmd_get_transaction_status(cmd)) {
1923                 case CAM_REQ_INPROG:
1924                 case CAM_REQ_CMP:
1925                 case CAM_SCSI_STATUS_ERROR:
1926                         new_status = DID_OK;
1927                         break;
1928                 case CAM_REQ_ABORTED:
1929                         new_status = DID_ABORT;
1930                         break;
1931                 case CAM_BUSY:
1932                         new_status = DID_BUS_BUSY;
1933                         break;
1934                 case CAM_REQ_INVALID:
1935                 case CAM_PATH_INVALID:
1936                         new_status = DID_BAD_TARGET;
1937                         break;
1938                 case CAM_SEL_TIMEOUT:
1939                         new_status = DID_NO_CONNECT;
1940                         break;
1941                 case CAM_SCSI_BUS_RESET:
1942                 case CAM_BDR_SENT:
1943                         new_status = DID_RESET;
1944                         break;
1945                 case CAM_UNCOR_PARITY:
1946                         new_status = DID_PARITY;
1947                         break;
1948                 case CAM_CMD_TIMEOUT:
1949                         new_status = DID_TIME_OUT;
1950                         break;
1951                 case CAM_UA_ABORT:
1952                 case CAM_REQ_CMP_ERR:
1953                 case CAM_AUTOSENSE_FAIL:
1954                 case CAM_NO_HBA:
1955                 case CAM_DATA_RUN_ERR:
1956                 case CAM_UNEXP_BUSFREE:
1957                 case CAM_SEQUENCE_FAIL:
1958                 case CAM_CCB_LEN_ERR:
1959                 case CAM_PROVIDE_FAIL:
1960                 case CAM_REQ_TERMIO:
1961                 case CAM_UNREC_HBA_ERROR:
1962                 case CAM_REQ_TOO_BIG:
1963                         new_status = DID_ERROR;
1964                         break;
1965                 case CAM_REQUEUE_REQ:
1966                         new_status = DID_REQUEUE;
1967                         break;
1968                 default:
1969                         /* We should never get here */
1970                         new_status = DID_ERROR;
1971                         break;
1972                 }
1973
1974                 ahc_cmd_set_transaction_status(cmd, new_status);
1975         }
1976
1977         cmd->scsi_done(cmd);
1978 }
1979
1980 static void
1981 ahc_linux_sem_timeout(u_long arg)
1982 {
1983         struct  ahc_softc *ahc;
1984         u_long  s;
1985
1986         ahc = (struct ahc_softc *)arg;
1987
1988         ahc_lock(ahc, &s);
1989         if ((ahc->platform_data->flags & AHC_UP_EH_SEMAPHORE) != 0) {
1990                 ahc->platform_data->flags &= ~AHC_UP_EH_SEMAPHORE;
1991                 up(&ahc->platform_data->eh_sem);
1992         }
1993         ahc_unlock(ahc, &s);
1994 }
1995
1996 static void
1997 ahc_linux_freeze_simq(struct ahc_softc *ahc)
1998 {
1999         ahc->platform_data->qfrozen++;
2000         if (ahc->platform_data->qfrozen == 1) {
2001                 scsi_block_requests(ahc->platform_data->host);
2002
2003                 /* XXX What about Twin channels? */
2004                 ahc_platform_abort_scbs(ahc, CAM_TARGET_WILDCARD, ALL_CHANNELS,
2005                                         CAM_LUN_WILDCARD, SCB_LIST_NULL,
2006                                         ROLE_INITIATOR, CAM_REQUEUE_REQ);
2007         }
2008 }
2009
2010 static void
2011 ahc_linux_release_simq(u_long arg)
2012 {
2013         struct ahc_softc *ahc;
2014         u_long s;
2015         int    unblock_reqs;
2016
2017         ahc = (struct ahc_softc *)arg;
2018
2019         unblock_reqs = 0;
2020         ahc_lock(ahc, &s);
2021         if (ahc->platform_data->qfrozen > 0)
2022                 ahc->platform_data->qfrozen--;
2023         if (ahc->platform_data->qfrozen == 0)
2024                 unblock_reqs = 1;
2025         ahc_unlock(ahc, &s);
2026         /*
2027          * There is still a race here.  The mid-layer
2028          * should keep its own freeze count and use
2029          * a bottom half handler to run the queues
2030          * so we can unblock with our own lock held.
2031          */
2032         if (unblock_reqs)
2033                 scsi_unblock_requests(ahc->platform_data->host);
2034 }
2035
2036 static int
2037 ahc_linux_queue_recovery_cmd(struct scsi_cmnd *cmd, scb_flag flag)
2038 {
2039         struct ahc_softc *ahc;
2040         struct ahc_linux_device *dev;
2041         struct scb *pending_scb;
2042         u_int  saved_scbptr;
2043         u_int  active_scb_index;
2044         u_int  last_phase;
2045         u_int  saved_scsiid;
2046         u_int  cdb_byte;
2047         int    retval;
2048         int    was_paused;
2049         int    paused;
2050         int    wait;
2051         int    disconnected;
2052
2053         pending_scb = NULL;
2054         paused = FALSE;
2055         wait = FALSE;
2056         ahc = *(struct ahc_softc **)cmd->device->host->hostdata;
2057
2058         printf("%s:%d:%d:%d: Attempting to queue a%s message\n",
2059                ahc_name(ahc), cmd->device->channel,
2060                cmd->device->id, cmd->device->lun,
2061                flag == SCB_ABORT ? "n ABORT" : " TARGET RESET");
2062
2063         printf("CDB:");
2064         for (cdb_byte = 0; cdb_byte < cmd->cmd_len; cdb_byte++)
2065                 printf(" 0x%x", cmd->cmnd[cdb_byte]);
2066         printf("\n");
2067
2068         spin_lock_irq(&ahc->platform_data->spin_lock);
2069
2070         /*
2071          * First determine if we currently own this command.
2072          * Start by searching the device queue.  If not found
2073          * there, check the pending_scb list.  If not found
2074          * at all, and the system wanted us to just abort the
2075          * command, return success.
2076          */
2077         dev = scsi_transport_device_data(cmd->device);
2078
2079         if (dev == NULL) {
2080                 /*
2081                  * No target device for this command exists,
2082                  * so we must not still own the command.
2083                  */
2084                 printf("%s:%d:%d:%d: Is not an active device\n",
2085                        ahc_name(ahc), cmd->device->channel, cmd->device->id,
2086                        cmd->device->lun);
2087                 retval = SUCCESS;
2088                 goto no_cmd;
2089         }
2090
2091         if ((dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED)) == 0
2092          && ahc_search_untagged_queues(ahc, cmd, cmd->device->id,
2093                                        cmd->device->channel + 'A',
2094                                        cmd->device->lun,
2095                                        CAM_REQ_ABORTED, SEARCH_COMPLETE) != 0) {
2096                 printf("%s:%d:%d:%d: Command found on untagged queue\n",
2097                        ahc_name(ahc), cmd->device->channel, cmd->device->id,
2098                        cmd->device->lun);
2099                 retval = SUCCESS;
2100                 goto done;
2101         }
2102
2103         /*
2104          * See if we can find a matching cmd in the pending list.
2105          */
2106         LIST_FOREACH(pending_scb, &ahc->pending_scbs, pending_links) {
2107                 if (pending_scb->io_ctx == cmd)
2108                         break;
2109         }
2110
2111         if (pending_scb == NULL && flag == SCB_DEVICE_RESET) {
2112
2113                 /* Any SCB for this device will do for a target reset */
2114                 LIST_FOREACH(pending_scb, &ahc->pending_scbs, pending_links) {
2115                         if (ahc_match_scb(ahc, pending_scb, cmd->device->id,
2116                                           cmd->device->channel + 'A',
2117                                           CAM_LUN_WILDCARD,
2118                                           SCB_LIST_NULL, ROLE_INITIATOR) == 0)
2119                                 break;
2120                 }
2121         }
2122
2123         if (pending_scb == NULL) {
2124                 printf("%s:%d:%d:%d: Command not found\n",
2125                        ahc_name(ahc), cmd->device->channel, cmd->device->id,
2126                        cmd->device->lun);
2127                 goto no_cmd;
2128         }
2129
2130         if ((pending_scb->flags & SCB_RECOVERY_SCB) != 0) {
2131                 /*
2132                  * We can't queue two recovery actions using the same SCB
2133                  */
2134                 retval = FAILED;
2135                 goto  done;
2136         }
2137
2138         /*
2139          * Ensure that the card doesn't do anything
2140          * behind our back and that we didn't "just" miss
2141          * an interrupt that would affect this cmd.
2142          */
2143         was_paused = ahc_is_paused(ahc);
2144         ahc_pause_and_flushwork(ahc);
2145         paused = TRUE;
2146
2147         if ((pending_scb->flags & SCB_ACTIVE) == 0) {
2148                 printf("%s:%d:%d:%d: Command already completed\n",
2149                        ahc_name(ahc), cmd->device->channel, cmd->device->id,
2150                        cmd->device->lun);
2151                 goto no_cmd;
2152         }
2153
2154         printf("%s: At time of recovery, card was %spaused\n",
2155                ahc_name(ahc), was_paused ? "" : "not ");
2156         ahc_dump_card_state(ahc);
2157
2158         disconnected = TRUE;
2159         if (flag == SCB_ABORT) {
2160                 if (ahc_search_qinfifo(ahc, cmd->device->id,
2161                                        cmd->device->channel + 'A',
2162                                        cmd->device->lun,
2163                                        pending_scb->hscb->tag,
2164                                        ROLE_INITIATOR, CAM_REQ_ABORTED,
2165                                        SEARCH_COMPLETE) > 0) {
2166                         printf("%s:%d:%d:%d: Cmd aborted from QINFIFO\n",
2167                                ahc_name(ahc), cmd->device->channel,
2168                                         cmd->device->id, cmd->device->lun);
2169                         retval = SUCCESS;
2170                         goto done;
2171                 }
2172         } else if (ahc_search_qinfifo(ahc, cmd->device->id,
2173                                       cmd->device->channel + 'A',
2174                                       cmd->device->lun, pending_scb->hscb->tag,
2175                                       ROLE_INITIATOR, /*status*/0,
2176                                       SEARCH_COUNT) > 0) {
2177                 disconnected = FALSE;
2178         }
2179
2180         if (disconnected && (ahc_inb(ahc, SEQ_FLAGS) & NOT_IDENTIFIED) == 0) {
2181                 struct scb *bus_scb;
2182
2183                 bus_scb = ahc_lookup_scb(ahc, ahc_inb(ahc, SCB_TAG));
2184                 if (bus_scb == pending_scb)
2185                         disconnected = FALSE;
2186                 else if (flag != SCB_ABORT
2187                       && ahc_inb(ahc, SAVED_SCSIID) == pending_scb->hscb->scsiid
2188                       && ahc_inb(ahc, SAVED_LUN) == SCB_GET_LUN(pending_scb))
2189                         disconnected = FALSE;
2190         }
2191
2192         /*
2193          * At this point, pending_scb is the scb associated with the
2194          * passed in command.  That command is currently active on the
2195          * bus, is in the disconnected state, or we're hoping to find
2196          * a command for the same target active on the bus to abuse to
2197          * send a BDR.  Queue the appropriate message based on which of
2198          * these states we are in.
2199          */
2200         last_phase = ahc_inb(ahc, LASTPHASE);
2201         saved_scbptr = ahc_inb(ahc, SCBPTR);
2202         active_scb_index = ahc_inb(ahc, SCB_TAG);
2203         saved_scsiid = ahc_inb(ahc, SAVED_SCSIID);
2204         if (last_phase != P_BUSFREE
2205          && (pending_scb->hscb->tag == active_scb_index
2206           || (flag == SCB_DEVICE_RESET
2207            && SCSIID_TARGET(ahc, saved_scsiid) == cmd->device->id))) {
2208
2209                 /*
2210                  * We're active on the bus, so assert ATN
2211                  * and hope that the target responds.
2212                  */
2213                 pending_scb = ahc_lookup_scb(ahc, active_scb_index);
2214                 pending_scb->flags |= SCB_RECOVERY_SCB|flag;
2215                 ahc_outb(ahc, MSG_OUT, HOST_MSG);
2216                 ahc_outb(ahc, SCSISIGO, last_phase|ATNO);
2217                 printf("%s:%d:%d:%d: Device is active, asserting ATN\n",
2218                        ahc_name(ahc), cmd->device->channel, cmd->device->id,
2219                        cmd->device->lun);
2220                 wait = TRUE;
2221         } else if (disconnected) {
2222
2223                 /*
2224                  * Actually re-queue this SCB in an attempt
2225                  * to select the device before it reconnects.
2226                  * In either case (selection or reselection),
2227                  * we will now issue the approprate message
2228                  * to the timed-out device.
2229                  *
2230                  * Set the MK_MESSAGE control bit indicating
2231                  * that we desire to send a message.  We
2232                  * also set the disconnected flag since
2233                  * in the paging case there is no guarantee
2234                  * that our SCB control byte matches the
2235                  * version on the card.  We don't want the
2236                  * sequencer to abort the command thinking
2237                  * an unsolicited reselection occurred.
2238                  */
2239                 pending_scb->hscb->control |= MK_MESSAGE|DISCONNECTED;
2240                 pending_scb->flags |= SCB_RECOVERY_SCB|flag;
2241
2242                 /*
2243                  * Remove any cached copy of this SCB in the
2244                  * disconnected list in preparation for the
2245                  * queuing of our abort SCB.  We use the
2246                  * same element in the SCB, SCB_NEXT, for
2247                  * both the qinfifo and the disconnected list.
2248                  */
2249                 ahc_search_disc_list(ahc, cmd->device->id,
2250                                      cmd->device->channel + 'A',
2251                                      cmd->device->lun, pending_scb->hscb->tag,
2252                                      /*stop_on_first*/TRUE,
2253                                      /*remove*/TRUE,
2254                                      /*save_state*/FALSE);
2255
2256                 /*
2257                  * In the non-paging case, the sequencer will
2258                  * never re-reference the in-core SCB.
2259                  * To make sure we are notified during
2260                  * reslection, set the MK_MESSAGE flag in
2261                  * the card's copy of the SCB.
2262                  */
2263                 if ((ahc->flags & AHC_PAGESCBS) == 0) {
2264                         ahc_outb(ahc, SCBPTR, pending_scb->hscb->tag);
2265                         ahc_outb(ahc, SCB_CONTROL,
2266                                  ahc_inb(ahc, SCB_CONTROL)|MK_MESSAGE);
2267                 }
2268
2269                 /*
2270                  * Clear out any entries in the QINFIFO first
2271                  * so we are the next SCB for this target
2272                  * to run.
2273                  */
2274                 ahc_search_qinfifo(ahc, cmd->device->id,
2275                                    cmd->device->channel + 'A',
2276                                    cmd->device->lun, SCB_LIST_NULL,
2277                                    ROLE_INITIATOR, CAM_REQUEUE_REQ,
2278                                    SEARCH_COMPLETE);
2279                 ahc_qinfifo_requeue_tail(ahc, pending_scb);
2280                 ahc_outb(ahc, SCBPTR, saved_scbptr);
2281                 ahc_print_path(ahc, pending_scb);
2282                 printf("Device is disconnected, re-queuing SCB\n");
2283                 wait = TRUE;
2284         } else {
2285                 printf("%s:%d:%d:%d: Unable to deliver message\n",
2286                        ahc_name(ahc), cmd->device->channel, cmd->device->id,
2287                        cmd->device->lun);
2288                 retval = FAILED;
2289                 goto done;
2290         }
2291
2292 no_cmd:
2293         /*
2294          * Our assumption is that if we don't have the command, no
2295          * recovery action was required, so we return success.  Again,
2296          * the semantics of the mid-layer recovery engine are not
2297          * well defined, so this may change in time.
2298          */
2299         retval = SUCCESS;
2300 done:
2301         if (paused)
2302                 ahc_unpause(ahc);
2303         if (wait) {
2304                 struct timer_list timer;
2305                 int ret;
2306
2307                 ahc->platform_data->flags |= AHC_UP_EH_SEMAPHORE;
2308                 spin_unlock_irq(&ahc->platform_data->spin_lock);
2309                 init_timer(&timer);
2310                 timer.data = (u_long)ahc;
2311                 timer.expires = jiffies + (5 * HZ);
2312                 timer.function = ahc_linux_sem_timeout;
2313                 add_timer(&timer);
2314                 printf("Recovery code sleeping\n");
2315                 down(&ahc->platform_data->eh_sem);
2316                 printf("Recovery code awake\n");
2317                 ret = del_timer_sync(&timer);
2318                 if (ret == 0) {
2319                         printf("Timer Expired\n");
2320                         retval = FAILED;
2321                 }
2322                 spin_lock_irq(&ahc->platform_data->spin_lock);
2323         }
2324
2325         spin_unlock_irq(&ahc->platform_data->spin_lock);
2326         return (retval);
2327 }
2328
2329 void
2330 ahc_platform_dump_card_state(struct ahc_softc *ahc)
2331 {
2332 }
2333
2334 static void ahc_linux_set_width(struct scsi_target *starget, int width)
2335 {
2336         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2337         struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);
2338         struct ahc_devinfo devinfo;
2339         unsigned long flags;
2340
2341         ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2342                             starget->channel + 'A', ROLE_INITIATOR);
2343         ahc_lock(ahc, &flags);
2344         ahc_set_width(ahc, &devinfo, width, AHC_TRANS_GOAL, FALSE);
2345         ahc_unlock(ahc, &flags);
2346 }
2347
2348 static void ahc_linux_set_period(struct scsi_target *starget, int period)
2349 {
2350         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2351         struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);
2352         struct ahc_tmode_tstate *tstate;
2353         struct ahc_initiator_tinfo *tinfo 
2354                 = ahc_fetch_transinfo(ahc,
2355                                       starget->channel + 'A',
2356                                       shost->this_id, starget->id, &tstate);
2357         struct ahc_devinfo devinfo;
2358         unsigned int ppr_options = tinfo->goal.ppr_options;
2359         unsigned long flags;
2360         unsigned long offset = tinfo->goal.offset;
2361         struct ahc_syncrate *syncrate;
2362
2363         if (offset == 0)
2364                 offset = MAX_OFFSET;
2365
2366         if (period < 9)
2367                 period = 9;     /* 12.5ns is our minimum */
2368         if (period == 9)
2369                 ppr_options |= MSG_EXT_PPR_DT_REQ;
2370
2371         ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2372                             starget->channel + 'A', ROLE_INITIATOR);
2373
2374         /* all PPR requests apart from QAS require wide transfers */
2375         if (ppr_options & ~MSG_EXT_PPR_QAS_REQ) {
2376                 if (spi_width(starget) == 0)
2377                         ppr_options &= MSG_EXT_PPR_QAS_REQ;
2378         }
2379
2380         syncrate = ahc_find_syncrate(ahc, &period, &ppr_options, AHC_SYNCRATE_DT);
2381         ahc_lock(ahc, &flags);
2382         ahc_set_syncrate(ahc, &devinfo, syncrate, period, offset,
2383                          ppr_options, AHC_TRANS_GOAL, FALSE);
2384         ahc_unlock(ahc, &flags);
2385 }
2386
2387 static void ahc_linux_set_offset(struct scsi_target *starget, int offset)
2388 {
2389         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2390         struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);
2391         struct ahc_tmode_tstate *tstate;
2392         struct ahc_initiator_tinfo *tinfo 
2393                 = ahc_fetch_transinfo(ahc,
2394                                       starget->channel + 'A',
2395                                       shost->this_id, starget->id, &tstate);
2396         struct ahc_devinfo devinfo;
2397         unsigned int ppr_options = 0;
2398         unsigned int period = 0;
2399         unsigned long flags;
2400         struct ahc_syncrate *syncrate = NULL;
2401
2402         ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2403                             starget->channel + 'A', ROLE_INITIATOR);
2404         if (offset != 0) {
2405                 syncrate = ahc_find_syncrate(ahc, &period, &ppr_options, AHC_SYNCRATE_DT);
2406                 period = tinfo->goal.period;
2407                 ppr_options = tinfo->goal.ppr_options;
2408         }
2409         ahc_lock(ahc, &flags);
2410         ahc_set_syncrate(ahc, &devinfo, syncrate, period, offset,
2411                          ppr_options, AHC_TRANS_GOAL, FALSE);
2412         ahc_unlock(ahc, &flags);
2413 }
2414
2415 static void ahc_linux_set_dt(struct scsi_target *starget, int dt)
2416 {
2417         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2418         struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);
2419         struct ahc_tmode_tstate *tstate;
2420         struct ahc_initiator_tinfo *tinfo 
2421                 = ahc_fetch_transinfo(ahc,
2422                                       starget->channel + 'A',
2423                                       shost->this_id, starget->id, &tstate);
2424         struct ahc_devinfo devinfo;
2425         unsigned int ppr_options = tinfo->goal.ppr_options
2426                 & ~MSG_EXT_PPR_DT_REQ;
2427         unsigned int period = tinfo->goal.period;
2428         unsigned int width = tinfo->goal.width;
2429         unsigned long flags;
2430         struct ahc_syncrate *syncrate;
2431
2432         if (dt) {
2433                 ppr_options |= MSG_EXT_PPR_DT_REQ;
2434                 if (!width)
2435                         ahc_linux_set_width(starget, 1);
2436         } else if (period == 9)
2437                 period = 10;    /* if resetting DT, period must be >= 25ns */
2438
2439         ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2440                             starget->channel + 'A', ROLE_INITIATOR);
2441         syncrate = ahc_find_syncrate(ahc, &period, &ppr_options,AHC_SYNCRATE_DT);
2442         ahc_lock(ahc, &flags);
2443         ahc_set_syncrate(ahc, &devinfo, syncrate, period, tinfo->goal.offset,
2444                          ppr_options, AHC_TRANS_GOAL, FALSE);
2445         ahc_unlock(ahc, &flags);
2446 }
2447
2448 #if 0
2449 /* FIXME: This code claims to support IU and QAS.  However, the actual
2450  * sequencer code and aic7xxx_core have no support for these parameters and
2451  * will get into a bad state if they're negotiated.  Do not enable this
2452  * unless you know what you're doing */
2453 static void ahc_linux_set_qas(struct scsi_target *starget, int qas)
2454 {
2455         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2456         struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);
2457         struct ahc_tmode_tstate *tstate;
2458         struct ahc_initiator_tinfo *tinfo 
2459                 = ahc_fetch_transinfo(ahc,
2460                                       starget->channel + 'A',
2461                                       shost->this_id, starget->id, &tstate);
2462         struct ahc_devinfo devinfo;
2463         unsigned int ppr_options = tinfo->goal.ppr_options
2464                 & ~MSG_EXT_PPR_QAS_REQ;
2465         unsigned int period = tinfo->goal.period;
2466         unsigned long flags;
2467         struct ahc_syncrate *syncrate;
2468
2469         if (qas)
2470                 ppr_options |= MSG_EXT_PPR_QAS_REQ;
2471
2472         ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2473                             starget->channel + 'A', ROLE_INITIATOR);
2474         syncrate = ahc_find_syncrate(ahc, &period, &ppr_options, AHC_SYNCRATE_DT);
2475         ahc_lock(ahc, &flags);
2476         ahc_set_syncrate(ahc, &devinfo, syncrate, period, tinfo->goal.offset,
2477                          ppr_options, AHC_TRANS_GOAL, FALSE);
2478         ahc_unlock(ahc, &flags);
2479 }
2480
2481 static void ahc_linux_set_iu(struct scsi_target *starget, int iu)
2482 {
2483         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2484         struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);
2485         struct ahc_tmode_tstate *tstate;
2486         struct ahc_initiator_tinfo *tinfo 
2487                 = ahc_fetch_transinfo(ahc,
2488                                       starget->channel + 'A',
2489                                       shost->this_id, starget->id, &tstate);
2490         struct ahc_devinfo devinfo;
2491         unsigned int ppr_options = tinfo->goal.ppr_options
2492                 & ~MSG_EXT_PPR_IU_REQ;
2493         unsigned int period = tinfo->goal.period;
2494         unsigned long flags;
2495         struct ahc_syncrate *syncrate;
2496
2497         if (iu)
2498                 ppr_options |= MSG_EXT_PPR_IU_REQ;
2499
2500         ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2501                             starget->channel + 'A', ROLE_INITIATOR);
2502         syncrate = ahc_find_syncrate(ahc, &period, &ppr_options, AHC_SYNCRATE_DT);
2503         ahc_lock(ahc, &flags);
2504         ahc_set_syncrate(ahc, &devinfo, syncrate, period, tinfo->goal.offset,
2505                          ppr_options, AHC_TRANS_GOAL, FALSE);
2506         ahc_unlock(ahc, &flags);
2507 }
2508 #endif
2509
2510 static struct spi_function_template ahc_linux_transport_functions = {
2511         .set_offset     = ahc_linux_set_offset,
2512         .show_offset    = 1,
2513         .set_period     = ahc_linux_set_period,
2514         .show_period    = 1,
2515         .set_width      = ahc_linux_set_width,
2516         .show_width     = 1,
2517         .set_dt         = ahc_linux_set_dt,
2518         .show_dt        = 1,
2519 #if 0
2520         .set_iu         = ahc_linux_set_iu,
2521         .show_iu        = 1,
2522         .set_qas        = ahc_linux_set_qas,
2523         .show_qas       = 1,
2524 #endif
2525 };
2526
2527
2528
2529 static int __init
2530 ahc_linux_init(void)
2531 {
2532         /*
2533          * If we've been passed any parameters, process them now.
2534          */
2535         if (aic7xxx)
2536                 aic7xxx_setup(aic7xxx);
2537
2538         ahc_linux_transport_template =
2539                 spi_attach_transport(&ahc_linux_transport_functions);
2540         if (!ahc_linux_transport_template)
2541                 return -ENODEV;
2542
2543         scsi_transport_reserve_target(ahc_linux_transport_template,
2544                                       sizeof(struct ahc_linux_target));
2545         scsi_transport_reserve_device(ahc_linux_transport_template,
2546                                       sizeof(struct ahc_linux_device));
2547
2548         ahc_linux_pci_init();
2549         ahc_linux_eisa_init();
2550         return 0;
2551 }
2552
2553 static void
2554 ahc_linux_exit(void)
2555 {
2556         ahc_linux_pci_exit();
2557         ahc_linux_eisa_exit();
2558         spi_release_transport(ahc_linux_transport_template);
2559 }
2560
2561 module_init(ahc_linux_init);
2562 module_exit(ahc_linux_exit);