[SCSI] Fix uninitialised width and speed in sym2
[linux-2.6.git] / drivers / scsi / sym53c8xx_2 / sym_hipd.c
1 /*
2  * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family 
3  * of PCI-SCSI IO processors.
4  *
5  * Copyright (C) 1999-2001  Gerard Roudier <groudier@free.fr>
6  * Copyright (c) 2003-2005  Matthew Wilcox <matthew@wil.cx>
7  *
8  * This driver is derived from the Linux sym53c8xx driver.
9  * Copyright (C) 1998-2000  Gerard Roudier
10  *
11  * The sym53c8xx driver is derived from the ncr53c8xx driver that had been 
12  * a port of the FreeBSD ncr driver to Linux-1.2.13.
13  *
14  * The original ncr driver has been written for 386bsd and FreeBSD by
15  *         Wolfgang Stanglmeier        <wolf@cologne.de>
16  *         Stefan Esser                <se@mi.Uni-Koeln.de>
17  * Copyright (C) 1994  Wolfgang Stanglmeier
18  *
19  * Other major contributions:
20  *
21  * NVRAM detection and reading.
22  * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk>
23  *
24  *-----------------------------------------------------------------------------
25  *
26  * This program is free software; you can redistribute it and/or modify
27  * it under the terms of the GNU General Public License as published by
28  * the Free Software Foundation; either version 2 of the License, or
29  * (at your option) any later version.
30  *
31  * This program is distributed in the hope that it will be useful,
32  * but WITHOUT ANY WARRANTY; without even the implied warranty of
33  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
34  * GNU General Public License for more details.
35  *
36  * You should have received a copy of the GNU General Public License
37  * along with this program; if not, write to the Free Software
38  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
39  */
40
41 #include <linux/slab.h>
42 #include <asm/param.h>          /* for timeouts in units of HZ */
43 #include <scsi/scsi_dbg.h>
44
45 #include "sym_glue.h"
46 #include "sym_nvram.h"
47
48 #if 0
49 #define SYM_DEBUG_GENERIC_SUPPORT
50 #endif
51
52 /*
53  *  Needed function prototypes.
54  */
55 static void sym_int_ma (struct sym_hcb *np);
56 static void sym_int_sir (struct sym_hcb *np);
57 static struct sym_ccb *sym_alloc_ccb(struct sym_hcb *np);
58 static struct sym_ccb *sym_ccb_from_dsa(struct sym_hcb *np, u32 dsa);
59 static void sym_alloc_lcb_tags (struct sym_hcb *np, u_char tn, u_char ln);
60 static void sym_complete_error (struct sym_hcb *np, struct sym_ccb *cp);
61 static void sym_complete_ok (struct sym_hcb *np, struct sym_ccb *cp);
62 static int sym_compute_residual(struct sym_hcb *np, struct sym_ccb *cp);
63
64 /*
65  *  Print a buffer in hexadecimal format with a ".\n" at end.
66  */
67 static void sym_printl_hex(u_char *p, int n)
68 {
69         while (n-- > 0)
70                 printf (" %x", *p++);
71         printf (".\n");
72 }
73
74 static void sym_print_msg(struct sym_ccb *cp, char *label, u_char *msg)
75 {
76         sym_print_addr(cp->cmd, "%s: ", label);
77
78         spi_print_msg(msg);
79         printf("\n");
80 }
81
82 static void sym_print_nego_msg(struct sym_hcb *np, int target, char *label, u_char *msg)
83 {
84         struct sym_tcb *tp = &np->target[target];
85         dev_info(&tp->starget->dev, "%s: ", label);
86
87         spi_print_msg(msg);
88         printf("\n");
89 }
90
91 /*
92  *  Print something that tells about extended errors.
93  */
94 void sym_print_xerr(struct scsi_cmnd *cmd, int x_status)
95 {
96         if (x_status & XE_PARITY_ERR) {
97                 sym_print_addr(cmd, "unrecovered SCSI parity error.\n");
98         }
99         if (x_status & XE_EXTRA_DATA) {
100                 sym_print_addr(cmd, "extraneous data discarded.\n");
101         }
102         if (x_status & XE_BAD_PHASE) {
103                 sym_print_addr(cmd, "illegal scsi phase (4/5).\n");
104         }
105         if (x_status & XE_SODL_UNRUN) {
106                 sym_print_addr(cmd, "ODD transfer in DATA OUT phase.\n");
107         }
108         if (x_status & XE_SWIDE_OVRUN) {
109                 sym_print_addr(cmd, "ODD transfer in DATA IN phase.\n");
110         }
111 }
112
113 /*
114  *  Return a string for SCSI BUS mode.
115  */
116 static char *sym_scsi_bus_mode(int mode)
117 {
118         switch(mode) {
119         case SMODE_HVD: return "HVD";
120         case SMODE_SE:  return "SE";
121         case SMODE_LVD: return "LVD";
122         }
123         return "??";
124 }
125
126 /*
127  *  Soft reset the chip.
128  *
129  *  Raising SRST when the chip is running may cause 
130  *  problems on dual function chips (see below).
131  *  On the other hand, LVD devices need some delay 
132  *  to settle and report actual BUS mode in STEST4.
133  */
134 static void sym_chip_reset (struct sym_hcb *np)
135 {
136         OUTB(np, nc_istat, SRST);
137         INB(np, nc_mbox1);
138         udelay(10);
139         OUTB(np, nc_istat, 0);
140         INB(np, nc_mbox1);
141         udelay(2000);   /* For BUS MODE to settle */
142 }
143
144 /*
145  *  Really soft reset the chip.:)
146  *
147  *  Some 896 and 876 chip revisions may hang-up if we set 
148  *  the SRST (soft reset) bit at the wrong time when SCRIPTS 
149  *  are running.
150  *  So, we need to abort the current operation prior to 
151  *  soft resetting the chip.
152  */
153 static void sym_soft_reset (struct sym_hcb *np)
154 {
155         u_char istat = 0;
156         int i;
157
158         if (!(np->features & FE_ISTAT1) || !(INB(np, nc_istat1) & SCRUN))
159                 goto do_chip_reset;
160
161         OUTB(np, nc_istat, CABRT);
162         for (i = 100000 ; i ; --i) {
163                 istat = INB(np, nc_istat);
164                 if (istat & SIP) {
165                         INW(np, nc_sist);
166                 }
167                 else if (istat & DIP) {
168                         if (INB(np, nc_dstat) & ABRT)
169                                 break;
170                 }
171                 udelay(5);
172         }
173         OUTB(np, nc_istat, 0);
174         if (!i)
175                 printf("%s: unable to abort current chip operation, "
176                        "ISTAT=0x%02x.\n", sym_name(np), istat);
177 do_chip_reset:
178         sym_chip_reset(np);
179 }
180
181 /*
182  *  Start reset process.
183  *
184  *  The interrupt handler will reinitialize the chip.
185  */
186 static void sym_start_reset(struct sym_hcb *np)
187 {
188         sym_reset_scsi_bus(np, 1);
189 }
190  
191 int sym_reset_scsi_bus(struct sym_hcb *np, int enab_int)
192 {
193         u32 term;
194         int retv = 0;
195
196         sym_soft_reset(np);     /* Soft reset the chip */
197         if (enab_int)
198                 OUTW(np, nc_sien, RST);
199         /*
200          *  Enable Tolerant, reset IRQD if present and 
201          *  properly set IRQ mode, prior to resetting the bus.
202          */
203         OUTB(np, nc_stest3, TE);
204         OUTB(np, nc_dcntl, (np->rv_dcntl & IRQM));
205         OUTB(np, nc_scntl1, CRST);
206         INB(np, nc_mbox1);
207         udelay(200);
208
209         if (!SYM_SETUP_SCSI_BUS_CHECK)
210                 goto out;
211         /*
212          *  Check for no terminators or SCSI bus shorts to ground.
213          *  Read SCSI data bus, data parity bits and control signals.
214          *  We are expecting RESET to be TRUE and other signals to be 
215          *  FALSE.
216          */
217         term =  INB(np, nc_sstat0);
218         term =  ((term & 2) << 7) + ((term & 1) << 17); /* rst sdp0 */
219         term |= ((INB(np, nc_sstat2) & 0x01) << 26) |   /* sdp1     */
220                 ((INW(np, nc_sbdl) & 0xff)   << 9)  |   /* d7-0     */
221                 ((INW(np, nc_sbdl) & 0xff00) << 10) |   /* d15-8    */
222                 INB(np, nc_sbcl);       /* req ack bsy sel atn msg cd io    */
223
224         if (!np->maxwide)
225                 term &= 0x3ffff;
226
227         if (term != (2<<7)) {
228                 printf("%s: suspicious SCSI data while resetting the BUS.\n",
229                         sym_name(np));
230                 printf("%s: %sdp0,d7-0,rst,req,ack,bsy,sel,atn,msg,c/d,i/o = "
231                         "0x%lx, expecting 0x%lx\n",
232                         sym_name(np),
233                         (np->features & FE_WIDE) ? "dp1,d15-8," : "",
234                         (u_long)term, (u_long)(2<<7));
235                 if (SYM_SETUP_SCSI_BUS_CHECK == 1)
236                         retv = 1;
237         }
238 out:
239         OUTB(np, nc_scntl1, 0);
240         return retv;
241 }
242
243 /*
244  *  Select SCSI clock frequency
245  */
246 static void sym_selectclock(struct sym_hcb *np, u_char scntl3)
247 {
248         /*
249          *  If multiplier not present or not selected, leave here.
250          */
251         if (np->multiplier <= 1) {
252                 OUTB(np, nc_scntl3, scntl3);
253                 return;
254         }
255
256         if (sym_verbose >= 2)
257                 printf ("%s: enabling clock multiplier\n", sym_name(np));
258
259         OUTB(np, nc_stest1, DBLEN);        /* Enable clock multiplier */
260         /*
261          *  Wait for the LCKFRQ bit to be set if supported by the chip.
262          *  Otherwise wait 50 micro-seconds (at least).
263          */
264         if (np->features & FE_LCKFRQ) {
265                 int i = 20;
266                 while (!(INB(np, nc_stest4) & LCKFRQ) && --i > 0)
267                         udelay(20);
268                 if (!i)
269                         printf("%s: the chip cannot lock the frequency\n",
270                                 sym_name(np));
271         } else {
272                 INB(np, nc_mbox1);
273                 udelay(50+10);
274         }
275         OUTB(np, nc_stest3, HSC);               /* Halt the scsi clock  */
276         OUTB(np, nc_scntl3, scntl3);
277         OUTB(np, nc_stest1, (DBLEN|DBLSEL));/* Select clock multiplier  */
278         OUTB(np, nc_stest3, 0x00);              /* Restart scsi clock   */
279 }
280
281
282 /*
283  *  Determine the chip's clock frequency.
284  *
285  *  This is essential for the negotiation of the synchronous 
286  *  transfer rate.
287  *
288  *  Note: we have to return the correct value.
289  *  THERE IS NO SAFE DEFAULT VALUE.
290  *
291  *  Most NCR/SYMBIOS boards are delivered with a 40 Mhz clock.
292  *  53C860 and 53C875 rev. 1 support fast20 transfers but 
293  *  do not have a clock doubler and so are provided with a 
294  *  80 MHz clock. All other fast20 boards incorporate a doubler 
295  *  and so should be delivered with a 40 MHz clock.
296  *  The recent fast40 chips (895/896/895A/1010) use a 40 Mhz base 
297  *  clock and provide a clock quadrupler (160 Mhz).
298  */
299
300 /*
301  *  calculate SCSI clock frequency (in KHz)
302  */
303 static unsigned getfreq (struct sym_hcb *np, int gen)
304 {
305         unsigned int ms = 0;
306         unsigned int f;
307
308         /*
309          * Measure GEN timer delay in order 
310          * to calculate SCSI clock frequency
311          *
312          * This code will never execute too
313          * many loop iterations (if DELAY is 
314          * reasonably correct). It could get
315          * too low a delay (too high a freq.)
316          * if the CPU is slow executing the 
317          * loop for some reason (an NMI, for
318          * example). For this reason we will
319          * if multiple measurements are to be 
320          * performed trust the higher delay 
321          * (lower frequency returned).
322          */
323         OUTW(np, nc_sien, 0);   /* mask all scsi interrupts */
324         INW(np, nc_sist);       /* clear pending scsi interrupt */
325         OUTB(np, nc_dien, 0);   /* mask all dma interrupts */
326         INW(np, nc_sist);       /* another one, just to be sure :) */
327         /*
328          * The C1010-33 core does not report GEN in SIST,
329          * if this interrupt is masked in SIEN.
330          * I don't know yet if the C1010-66 behaves the same way.
331          */
332         if (np->features & FE_C10) {
333                 OUTW(np, nc_sien, GEN);
334                 OUTB(np, nc_istat1, SIRQD);
335         }
336         OUTB(np, nc_scntl3, 4);    /* set pre-scaler to divide by 3 */
337         OUTB(np, nc_stime1, 0);    /* disable general purpose timer */
338         OUTB(np, nc_stime1, gen);  /* set to nominal delay of 1<<gen * 125us */
339         while (!(INW(np, nc_sist) & GEN) && ms++ < 100000)
340                 udelay(1000/4);    /* count in 1/4 of ms */
341         OUTB(np, nc_stime1, 0);    /* disable general purpose timer */
342         /*
343          * Undo C1010-33 specific settings.
344          */
345         if (np->features & FE_C10) {
346                 OUTW(np, nc_sien, 0);
347                 OUTB(np, nc_istat1, 0);
348         }
349         /*
350          * set prescaler to divide by whatever 0 means
351          * 0 ought to choose divide by 2, but appears
352          * to set divide by 3.5 mode in my 53c810 ...
353          */
354         OUTB(np, nc_scntl3, 0);
355
356         /*
357          * adjust for prescaler, and convert into KHz 
358          */
359         f = ms ? ((1 << gen) * (4340*4)) / ms : 0;
360
361         /*
362          * The C1010-33 result is biased by a factor 
363          * of 2/3 compared to earlier chips.
364          */
365         if (np->features & FE_C10)
366                 f = (f * 2) / 3;
367
368         if (sym_verbose >= 2)
369                 printf ("%s: Delay (GEN=%d): %u msec, %u KHz\n",
370                         sym_name(np), gen, ms/4, f);
371
372         return f;
373 }
374
375 static unsigned sym_getfreq (struct sym_hcb *np)
376 {
377         u_int f1, f2;
378         int gen = 8;
379
380         getfreq (np, gen);      /* throw away first result */
381         f1 = getfreq (np, gen);
382         f2 = getfreq (np, gen);
383         if (f1 > f2) f1 = f2;           /* trust lower result   */
384         return f1;
385 }
386
387 /*
388  *  Get/probe chip SCSI clock frequency
389  */
390 static void sym_getclock (struct sym_hcb *np, int mult)
391 {
392         unsigned char scntl3 = np->sv_scntl3;
393         unsigned char stest1 = np->sv_stest1;
394         unsigned f1;
395
396         np->multiplier = 1;
397         f1 = 40000;
398         /*
399          *  True with 875/895/896/895A with clock multiplier selected
400          */
401         if (mult > 1 && (stest1 & (DBLEN+DBLSEL)) == DBLEN+DBLSEL) {
402                 if (sym_verbose >= 2)
403                         printf ("%s: clock multiplier found\n", sym_name(np));
404                 np->multiplier = mult;
405         }
406
407         /*
408          *  If multiplier not found or scntl3 not 7,5,3,
409          *  reset chip and get frequency from general purpose timer.
410          *  Otherwise trust scntl3 BIOS setting.
411          */
412         if (np->multiplier != mult || (scntl3 & 7) < 3 || !(scntl3 & 1)) {
413                 OUTB(np, nc_stest1, 0);         /* make sure doubler is OFF */
414                 f1 = sym_getfreq (np);
415
416                 if (sym_verbose)
417                         printf ("%s: chip clock is %uKHz\n", sym_name(np), f1);
418
419                 if      (f1 <   45000)          f1 =  40000;
420                 else if (f1 <   55000)          f1 =  50000;
421                 else                            f1 =  80000;
422
423                 if (f1 < 80000 && mult > 1) {
424                         if (sym_verbose >= 2)
425                                 printf ("%s: clock multiplier assumed\n",
426                                         sym_name(np));
427                         np->multiplier  = mult;
428                 }
429         } else {
430                 if      ((scntl3 & 7) == 3)     f1 =  40000;
431                 else if ((scntl3 & 7) == 5)     f1 =  80000;
432                 else                            f1 = 160000;
433
434                 f1 /= np->multiplier;
435         }
436
437         /*
438          *  Compute controller synchronous parameters.
439          */
440         f1              *= np->multiplier;
441         np->clock_khz   = f1;
442 }
443
444 /*
445  *  Get/probe PCI clock frequency
446  */
447 static int sym_getpciclock (struct sym_hcb *np)
448 {
449         int f = 0;
450
451         /*
452          *  For now, we only need to know about the actual 
453          *  PCI BUS clock frequency for C1010-66 chips.
454          */
455 #if 1
456         if (np->features & FE_66MHZ) {
457 #else
458         if (1) {
459 #endif
460                 OUTB(np, nc_stest1, SCLK); /* Use the PCI clock as SCSI clock */
461                 f = sym_getfreq(np);
462                 OUTB(np, nc_stest1, 0);
463         }
464         np->pciclk_khz = f;
465
466         return f;
467 }
468
469 /*
470  *  SYMBIOS chip clock divisor table.
471  *
472  *  Divisors are multiplied by 10,000,000 in order to make 
473  *  calculations more simple.
474  */
475 #define _5M 5000000
476 static u32 div_10M[] = {2*_5M, 3*_5M, 4*_5M, 6*_5M, 8*_5M, 12*_5M, 16*_5M};
477
478 /*
479  *  Get clock factor and sync divisor for a given 
480  *  synchronous factor period.
481  */
482 static int 
483 sym_getsync(struct sym_hcb *np, u_char dt, u_char sfac, u_char *divp, u_char *fakp)
484 {
485         u32     clk = np->clock_khz;    /* SCSI clock frequency in kHz  */
486         int     div = np->clock_divn;   /* Number of divisors supported */
487         u32     fak;                    /* Sync factor in sxfer         */
488         u32     per;                    /* Period in tenths of ns       */
489         u32     kpc;                    /* (per * clk)                  */
490         int     ret;
491
492         /*
493          *  Compute the synchronous period in tenths of nano-seconds
494          */
495         if (dt && sfac <= 9)    per = 125;
496         else if (sfac <= 10)    per = 250;
497         else if (sfac == 11)    per = 303;
498         else if (sfac == 12)    per = 500;
499         else                    per = 40 * sfac;
500         ret = per;
501
502         kpc = per * clk;
503         if (dt)
504                 kpc <<= 1;
505
506         /*
507          *  For earliest C10 revision 0, we cannot use extra 
508          *  clocks for the setting of the SCSI clocking.
509          *  Note that this limits the lowest sync data transfer 
510          *  to 5 Mega-transfers per second and may result in
511          *  using higher clock divisors.
512          */
513 #if 1
514         if ((np->features & (FE_C10|FE_U3EN)) == FE_C10) {
515                 /*
516                  *  Look for the lowest clock divisor that allows an 
517                  *  output speed not faster than the period.
518                  */
519                 while (div > 0) {
520                         --div;
521                         if (kpc > (div_10M[div] << 2)) {
522                                 ++div;
523                                 break;
524                         }
525                 }
526                 fak = 0;                        /* No extra clocks */
527                 if (div == np->clock_divn) {    /* Are we too fast ? */
528                         ret = -1;
529                 }
530                 *divp = div;
531                 *fakp = fak;
532                 return ret;
533         }
534 #endif
535
536         /*
537          *  Look for the greatest clock divisor that allows an 
538          *  input speed faster than the period.
539          */
540         while (div-- > 0)
541                 if (kpc >= (div_10M[div] << 2)) break;
542
543         /*
544          *  Calculate the lowest clock factor that allows an output 
545          *  speed not faster than the period, and the max output speed.
546          *  If fak >= 1 we will set both XCLKH_ST and XCLKH_DT.
547          *  If fak >= 2 we will also set XCLKS_ST and XCLKS_DT.
548          */
549         if (dt) {
550                 fak = (kpc - 1) / (div_10M[div] << 1) + 1 - 2;
551                 /* ret = ((2+fak)*div_10M[div])/np->clock_khz; */
552         } else {
553                 fak = (kpc - 1) / div_10M[div] + 1 - 4;
554                 /* ret = ((4+fak)*div_10M[div])/np->clock_khz; */
555         }
556
557         /*
558          *  Check against our hardware limits, or bugs :).
559          */
560         if (fak > 2) {
561                 fak = 2;
562                 ret = -1;
563         }
564
565         /*
566          *  Compute and return sync parameters.
567          */
568         *divp = div;
569         *fakp = fak;
570
571         return ret;
572 }
573
574 /*
575  *  SYMBIOS chips allow burst lengths of 2, 4, 8, 16, 32, 64,
576  *  128 transfers. All chips support at least 16 transfers 
577  *  bursts. The 825A, 875 and 895 chips support bursts of up 
578  *  to 128 transfers and the 895A and 896 support bursts of up
579  *  to 64 transfers. All other chips support up to 16 
580  *  transfers bursts.
581  *
582  *  For PCI 32 bit data transfers each transfer is a DWORD.
583  *  It is a QUADWORD (8 bytes) for PCI 64 bit data transfers.
584  *
585  *  We use log base 2 (burst length) as internal code, with 
586  *  value 0 meaning "burst disabled".
587  */
588
589 /*
590  *  Burst length from burst code.
591  */
592 #define burst_length(bc) (!(bc))? 0 : 1 << (bc)
593
594 /*
595  *  Burst code from io register bits.
596  */
597 #define burst_code(dmode, ctest4, ctest5) \
598         (ctest4) & 0x80? 0 : (((dmode) & 0xc0) >> 6) + ((ctest5) & 0x04) + 1
599
600 /*
601  *  Set initial io register bits from burst code.
602  */
603 static __inline void sym_init_burst(struct sym_hcb *np, u_char bc)
604 {
605         np->rv_ctest4   &= ~0x80;
606         np->rv_dmode    &= ~(0x3 << 6);
607         np->rv_ctest5   &= ~0x4;
608
609         if (!bc) {
610                 np->rv_ctest4   |= 0x80;
611         }
612         else {
613                 --bc;
614                 np->rv_dmode    |= ((bc & 0x3) << 6);
615                 np->rv_ctest5   |= (bc & 0x4);
616         }
617 }
618
619 /*
620  *  Save initial settings of some IO registers.
621  *  Assumed to have been set by BIOS.
622  *  We cannot reset the chip prior to reading the 
623  *  IO registers, since informations will be lost.
624  *  Since the SCRIPTS processor may be running, this 
625  *  is not safe on paper, but it seems to work quite 
626  *  well. :)
627  */
628 static void sym_save_initial_setting (struct sym_hcb *np)
629 {
630         np->sv_scntl0   = INB(np, nc_scntl0) & 0x0a;
631         np->sv_scntl3   = INB(np, nc_scntl3) & 0x07;
632         np->sv_dmode    = INB(np, nc_dmode)  & 0xce;
633         np->sv_dcntl    = INB(np, nc_dcntl)  & 0xa8;
634         np->sv_ctest3   = INB(np, nc_ctest3) & 0x01;
635         np->sv_ctest4   = INB(np, nc_ctest4) & 0x80;
636         np->sv_gpcntl   = INB(np, nc_gpcntl);
637         np->sv_stest1   = INB(np, nc_stest1);
638         np->sv_stest2   = INB(np, nc_stest2) & 0x20;
639         np->sv_stest4   = INB(np, nc_stest4);
640         if (np->features & FE_C10) {    /* Always large DMA fifo + ultra3 */
641                 np->sv_scntl4   = INB(np, nc_scntl4);
642                 np->sv_ctest5   = INB(np, nc_ctest5) & 0x04;
643         }
644         else
645                 np->sv_ctest5   = INB(np, nc_ctest5) & 0x24;
646 }
647
648 /*
649  *  Prepare io register values used by sym_start_up() 
650  *  according to selected and supported features.
651  */
652 static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, struct sym_nvram *nvram)
653 {
654         u_char  burst_max;
655         u32     period;
656         int i;
657
658         /*
659          *  Wide ?
660          */
661         np->maxwide     = (np->features & FE_WIDE)? 1 : 0;
662
663         /*
664          *  Guess the frequency of the chip's clock.
665          */
666         if      (np->features & (FE_ULTRA3 | FE_ULTRA2))
667                 np->clock_khz = 160000;
668         else if (np->features & FE_ULTRA)
669                 np->clock_khz = 80000;
670         else
671                 np->clock_khz = 40000;
672
673         /*
674          *  Get the clock multiplier factor.
675          */
676         if      (np->features & FE_QUAD)
677                 np->multiplier  = 4;
678         else if (np->features & FE_DBLR)
679                 np->multiplier  = 2;
680         else
681                 np->multiplier  = 1;
682
683         /*
684          *  Measure SCSI clock frequency for chips 
685          *  it may vary from assumed one.
686          */
687         if (np->features & FE_VARCLK)
688                 sym_getclock(np, np->multiplier);
689
690         /*
691          * Divisor to be used for async (timer pre-scaler).
692          */
693         i = np->clock_divn - 1;
694         while (--i >= 0) {
695                 if (10ul * SYM_CONF_MIN_ASYNC * np->clock_khz > div_10M[i]) {
696                         ++i;
697                         break;
698                 }
699         }
700         np->rv_scntl3 = i+1;
701
702         /*
703          * The C1010 uses hardwired divisors for async.
704          * So, we just throw away, the async. divisor.:-)
705          */
706         if (np->features & FE_C10)
707                 np->rv_scntl3 = 0;
708
709         /*
710          * Minimum synchronous period factor supported by the chip.
711          * Btw, 'period' is in tenths of nanoseconds.
712          */
713         period = (4 * div_10M[0] + np->clock_khz - 1) / np->clock_khz;
714
715         if      (period <= 250)         np->minsync = 10;
716         else if (period <= 303)         np->minsync = 11;
717         else if (period <= 500)         np->minsync = 12;
718         else                            np->minsync = (period + 40 - 1) / 40;
719
720         /*
721          * Check against chip SCSI standard support (SCSI-2,ULTRA,ULTRA2).
722          */
723         if      (np->minsync < 25 &&
724                  !(np->features & (FE_ULTRA|FE_ULTRA2|FE_ULTRA3)))
725                 np->minsync = 25;
726         else if (np->minsync < 12 &&
727                  !(np->features & (FE_ULTRA2|FE_ULTRA3)))
728                 np->minsync = 12;
729
730         /*
731          * Maximum synchronous period factor supported by the chip.
732          */
733         period = (11 * div_10M[np->clock_divn - 1]) / (4 * np->clock_khz);
734         np->maxsync = period > 2540 ? 254 : period / 10;
735
736         /*
737          * If chip is a C1010, guess the sync limits in DT mode.
738          */
739         if ((np->features & (FE_C10|FE_ULTRA3)) == (FE_C10|FE_ULTRA3)) {
740                 if (np->clock_khz == 160000) {
741                         np->minsync_dt = 9;
742                         np->maxsync_dt = 50;
743                         np->maxoffs_dt = nvram->type ? 62 : 31;
744                 }
745         }
746         
747         /*
748          *  64 bit addressing  (895A/896/1010) ?
749          */
750         if (np->features & FE_DAC) {
751 #if   SYM_CONF_DMA_ADDRESSING_MODE == 0
752                 np->rv_ccntl1   |= (DDAC);
753 #elif SYM_CONF_DMA_ADDRESSING_MODE == 1
754                 if (!np->use_dac)
755                         np->rv_ccntl1   |= (DDAC);
756                 else
757                         np->rv_ccntl1   |= (XTIMOD | EXTIBMV);
758 #elif SYM_CONF_DMA_ADDRESSING_MODE == 2
759                 if (!np->use_dac)
760                         np->rv_ccntl1   |= (DDAC);
761                 else
762                         np->rv_ccntl1   |= (0 | EXTIBMV);
763 #endif
764         }
765
766         /*
767          *  Phase mismatch handled by SCRIPTS (895A/896/1010) ?
768          */
769         if (np->features & FE_NOPM)
770                 np->rv_ccntl0   |= (ENPMJ);
771
772         /*
773          *  C1010-33 Errata: Part Number:609-039638 (rev. 1) is fixed.
774          *  In dual channel mode, contention occurs if internal cycles
775          *  are used. Disable internal cycles.
776          */
777         if (np->device_id == PCI_DEVICE_ID_LSI_53C1010_33 &&
778             np->revision_id < 0x1)
779                 np->rv_ccntl0   |=  DILS;
780
781         /*
782          *  Select burst length (dwords)
783          */
784         burst_max       = SYM_SETUP_BURST_ORDER;
785         if (burst_max == 255)
786                 burst_max = burst_code(np->sv_dmode, np->sv_ctest4,
787                                        np->sv_ctest5);
788         if (burst_max > 7)
789                 burst_max = 7;
790         if (burst_max > np->maxburst)
791                 burst_max = np->maxburst;
792
793         /*
794          *  DEL 352 - 53C810 Rev x11 - Part Number 609-0392140 - ITEM 2.
795          *  This chip and the 860 Rev 1 may wrongly use PCI cache line 
796          *  based transactions on LOAD/STORE instructions. So we have 
797          *  to prevent these chips from using such PCI transactions in 
798          *  this driver. The generic ncr driver that does not use 
799          *  LOAD/STORE instructions does not need this work-around.
800          */
801         if ((np->device_id == PCI_DEVICE_ID_NCR_53C810 &&
802              np->revision_id >= 0x10 && np->revision_id <= 0x11) ||
803             (np->device_id == PCI_DEVICE_ID_NCR_53C860 &&
804              np->revision_id <= 0x1))
805                 np->features &= ~(FE_WRIE|FE_ERL|FE_ERMP);
806
807         /*
808          *  Select all supported special features.
809          *  If we are using on-board RAM for scripts, prefetch (PFEN) 
810          *  does not help, but burst op fetch (BOF) does.
811          *  Disabling PFEN makes sure BOF will be used.
812          */
813         if (np->features & FE_ERL)
814                 np->rv_dmode    |= ERL;         /* Enable Read Line */
815         if (np->features & FE_BOF)
816                 np->rv_dmode    |= BOF;         /* Burst Opcode Fetch */
817         if (np->features & FE_ERMP)
818                 np->rv_dmode    |= ERMP;        /* Enable Read Multiple */
819 #if 1
820         if ((np->features & FE_PFEN) && !np->ram_ba)
821 #else
822         if (np->features & FE_PFEN)
823 #endif
824                 np->rv_dcntl    |= PFEN;        /* Prefetch Enable */
825         if (np->features & FE_CLSE)
826                 np->rv_dcntl    |= CLSE;        /* Cache Line Size Enable */
827         if (np->features & FE_WRIE)
828                 np->rv_ctest3   |= WRIE;        /* Write and Invalidate */
829         if (np->features & FE_DFS)
830                 np->rv_ctest5   |= DFS;         /* Dma Fifo Size */
831
832         /*
833          *  Select some other
834          */
835         np->rv_ctest4   |= MPEE; /* Master parity checking */
836         np->rv_scntl0   |= 0x0a; /*  full arb., ena parity, par->ATN  */
837
838         /*
839          *  Get parity checking, host ID and verbose mode from NVRAM
840          */
841         np->myaddr = 255;
842         sym_nvram_setup_host(shost, np, nvram);
843
844         /*
845          *  Get SCSI addr of host adapter (set by bios?).
846          */
847         if (np->myaddr == 255) {
848                 np->myaddr = INB(np, nc_scid) & 0x07;
849                 if (!np->myaddr)
850                         np->myaddr = SYM_SETUP_HOST_ID;
851         }
852
853         /*
854          *  Prepare initial io register bits for burst length
855          */
856         sym_init_burst(np, burst_max);
857
858         /*
859          *  Set SCSI BUS mode.
860          *  - LVD capable chips (895/895A/896/1010) report the 
861          *    current BUS mode through the STEST4 IO register.
862          *  - For previous generation chips (825/825A/875), 
863          *    user has to tell us how to check against HVD, 
864          *    since a 100% safe algorithm is not possible.
865          */
866         np->scsi_mode = SMODE_SE;
867         if (np->features & (FE_ULTRA2|FE_ULTRA3))
868                 np->scsi_mode = (np->sv_stest4 & SMODE);
869         else if (np->features & FE_DIFF) {
870                 if (SYM_SETUP_SCSI_DIFF == 1) {
871                         if (np->sv_scntl3) {
872                                 if (np->sv_stest2 & 0x20)
873                                         np->scsi_mode = SMODE_HVD;
874                         }
875                         else if (nvram->type == SYM_SYMBIOS_NVRAM) {
876                                 if (!(INB(np, nc_gpreg) & 0x08))
877                                         np->scsi_mode = SMODE_HVD;
878                         }
879                 }
880                 else if (SYM_SETUP_SCSI_DIFF == 2)
881                         np->scsi_mode = SMODE_HVD;
882         }
883         if (np->scsi_mode == SMODE_HVD)
884                 np->rv_stest2 |= 0x20;
885
886         /*
887          *  Set LED support from SCRIPTS.
888          *  Ignore this feature for boards known to use a 
889          *  specific GPIO wiring and for the 895A, 896 
890          *  and 1010 that drive the LED directly.
891          */
892         if ((SYM_SETUP_SCSI_LED || 
893              (nvram->type == SYM_SYMBIOS_NVRAM ||
894               (nvram->type == SYM_TEKRAM_NVRAM &&
895                np->device_id == PCI_DEVICE_ID_NCR_53C895))) &&
896             !(np->features & FE_LEDC) && !(np->sv_gpcntl & 0x01))
897                 np->features |= FE_LED0;
898
899         /*
900          *  Set irq mode.
901          */
902         switch(SYM_SETUP_IRQ_MODE & 3) {
903         case 2:
904                 np->rv_dcntl    |= IRQM;
905                 break;
906         case 1:
907                 np->rv_dcntl    |= (np->sv_dcntl & IRQM);
908                 break;
909         default:
910                 break;
911         }
912
913         /*
914          *  Configure targets according to driver setup.
915          *  If NVRAM present get targets setup from NVRAM.
916          */
917         for (i = 0 ; i < SYM_CONF_MAX_TARGET ; i++) {
918                 struct sym_tcb *tp = &np->target[i];
919
920                 tp->usrflags |= (SYM_DISC_ENABLED | SYM_TAGS_ENABLED);
921                 tp->usrtags = SYM_SETUP_MAX_TAG;
922                 tp->usr_width = np->maxwide;
923                 tp->usr_period = 9;
924
925                 sym_nvram_setup_target(tp, i, nvram);
926
927                 if (!tp->usrtags)
928                         tp->usrflags &= ~SYM_TAGS_ENABLED;
929         }
930
931         /*
932          *  Let user know about the settings.
933          */
934         printf("%s: %s, ID %d, Fast-%d, %s, %s\n", sym_name(np),
935                 sym_nvram_type(nvram), np->myaddr,
936                 (np->features & FE_ULTRA3) ? 80 : 
937                 (np->features & FE_ULTRA2) ? 40 : 
938                 (np->features & FE_ULTRA)  ? 20 : 10,
939                 sym_scsi_bus_mode(np->scsi_mode),
940                 (np->rv_scntl0 & 0xa)   ? "parity checking" : "NO parity");
941         /*
942          *  Tell him more on demand.
943          */
944         if (sym_verbose) {
945                 printf("%s: %s IRQ line driver%s\n",
946                         sym_name(np),
947                         np->rv_dcntl & IRQM ? "totem pole" : "open drain",
948                         np->ram_ba ? ", using on-chip SRAM" : "");
949                 printf("%s: using %s firmware.\n", sym_name(np), np->fw_name);
950                 if (np->features & FE_NOPM)
951                         printf("%s: handling phase mismatch from SCRIPTS.\n", 
952                                sym_name(np));
953         }
954         /*
955          *  And still more.
956          */
957         if (sym_verbose >= 2) {
958                 printf ("%s: initial SCNTL3/DMODE/DCNTL/CTEST3/4/5 = "
959                         "(hex) %02x/%02x/%02x/%02x/%02x/%02x\n",
960                         sym_name(np), np->sv_scntl3, np->sv_dmode, np->sv_dcntl,
961                         np->sv_ctest3, np->sv_ctest4, np->sv_ctest5);
962
963                 printf ("%s: final   SCNTL3/DMODE/DCNTL/CTEST3/4/5 = "
964                         "(hex) %02x/%02x/%02x/%02x/%02x/%02x\n",
965                         sym_name(np), np->rv_scntl3, np->rv_dmode, np->rv_dcntl,
966                         np->rv_ctest3, np->rv_ctest4, np->rv_ctest5);
967         }
968
969         return 0;
970 }
971
972 /*
973  *  Test the pci bus snoop logic :-(
974  *
975  *  Has to be called with interrupts disabled.
976  */
977 #ifndef CONFIG_SCSI_SYM53C8XX_IOMAPPED
978 static int sym_regtest (struct sym_hcb *np)
979 {
980         register volatile u32 data;
981         /*
982          *  chip registers may NOT be cached.
983          *  write 0xffffffff to a read only register area,
984          *  and try to read it back.
985          */
986         data = 0xffffffff;
987         OUTL(np, nc_dstat, data);
988         data = INL(np, nc_dstat);
989 #if 1
990         if (data == 0xffffffff) {
991 #else
992         if ((data & 0xe2f0fffd) != 0x02000080) {
993 #endif
994                 printf ("CACHE TEST FAILED: reg dstat-sstat2 readback %x.\n",
995                         (unsigned) data);
996                 return (0x10);
997         }
998         return (0);
999 }
1000 #endif
1001
1002 static int sym_snooptest (struct sym_hcb *np)
1003 {
1004         u32     sym_rd, sym_wr, sym_bk, host_rd, host_wr, pc, dstat;
1005         int     i, err=0;
1006 #ifndef CONFIG_SCSI_SYM53C8XX_IOMAPPED
1007         err |= sym_regtest (np);
1008         if (err) return (err);
1009 #endif
1010 restart_test:
1011         /*
1012          *  Enable Master Parity Checking as we intend 
1013          *  to enable it for normal operations.
1014          */
1015         OUTB(np, nc_ctest4, (np->rv_ctest4 & MPEE));
1016         /*
1017          *  init
1018          */
1019         pc  = SCRIPTZ_BA(np, snooptest);
1020         host_wr = 1;
1021         sym_wr  = 2;
1022         /*
1023          *  Set memory and register.
1024          */
1025         np->scratch = cpu_to_scr(host_wr);
1026         OUTL(np, nc_temp, sym_wr);
1027         /*
1028          *  Start script (exchange values)
1029          */
1030         OUTL(np, nc_dsa, np->hcb_ba);
1031         OUTL_DSP(np, pc);
1032         /*
1033          *  Wait 'til done (with timeout)
1034          */
1035         for (i=0; i<SYM_SNOOP_TIMEOUT; i++)
1036                 if (INB(np, nc_istat) & (INTF|SIP|DIP))
1037                         break;
1038         if (i>=SYM_SNOOP_TIMEOUT) {
1039                 printf ("CACHE TEST FAILED: timeout.\n");
1040                 return (0x20);
1041         }
1042         /*
1043          *  Check for fatal DMA errors.
1044          */
1045         dstat = INB(np, nc_dstat);
1046 #if 1   /* Band aiding for broken hardwares that fail PCI parity */
1047         if ((dstat & MDPE) && (np->rv_ctest4 & MPEE)) {
1048                 printf ("%s: PCI DATA PARITY ERROR DETECTED - "
1049                         "DISABLING MASTER DATA PARITY CHECKING.\n",
1050                         sym_name(np));
1051                 np->rv_ctest4 &= ~MPEE;
1052                 goto restart_test;
1053         }
1054 #endif
1055         if (dstat & (MDPE|BF|IID)) {
1056                 printf ("CACHE TEST FAILED: DMA error (dstat=0x%02x).", dstat);
1057                 return (0x80);
1058         }
1059         /*
1060          *  Save termination position.
1061          */
1062         pc = INL(np, nc_dsp);
1063         /*
1064          *  Read memory and register.
1065          */
1066         host_rd = scr_to_cpu(np->scratch);
1067         sym_rd  = INL(np, nc_scratcha);
1068         sym_bk  = INL(np, nc_temp);
1069         /*
1070          *  Check termination position.
1071          */
1072         if (pc != SCRIPTZ_BA(np, snoopend)+8) {
1073                 printf ("CACHE TEST FAILED: script execution failed.\n");
1074                 printf ("start=%08lx, pc=%08lx, end=%08lx\n", 
1075                         (u_long) SCRIPTZ_BA(np, snooptest), (u_long) pc,
1076                         (u_long) SCRIPTZ_BA(np, snoopend) +8);
1077                 return (0x40);
1078         }
1079         /*
1080          *  Show results.
1081          */
1082         if (host_wr != sym_rd) {
1083                 printf ("CACHE TEST FAILED: host wrote %d, chip read %d.\n",
1084                         (int) host_wr, (int) sym_rd);
1085                 err |= 1;
1086         }
1087         if (host_rd != sym_wr) {
1088                 printf ("CACHE TEST FAILED: chip wrote %d, host read %d.\n",
1089                         (int) sym_wr, (int) host_rd);
1090                 err |= 2;
1091         }
1092         if (sym_bk != sym_wr) {
1093                 printf ("CACHE TEST FAILED: chip wrote %d, read back %d.\n",
1094                         (int) sym_wr, (int) sym_bk);
1095                 err |= 4;
1096         }
1097
1098         return (err);
1099 }
1100
1101 /*
1102  *  log message for real hard errors
1103  *
1104  *  sym0 targ 0?: ERROR (ds:si) (so-si-sd) (sx/s3/s4) @ name (dsp:dbc).
1105  *            reg: r0 r1 r2 r3 r4 r5 r6 ..... rf.
1106  *
1107  *  exception register:
1108  *      ds:     dstat
1109  *      si:     sist
1110  *
1111  *  SCSI bus lines:
1112  *      so:     control lines as driven by chip.
1113  *      si:     control lines as seen by chip.
1114  *      sd:     scsi data lines as seen by chip.
1115  *
1116  *  wide/fastmode:
1117  *      sx:     sxfer  (see the manual)
1118  *      s3:     scntl3 (see the manual)
1119  *      s4:     scntl4 (see the manual)
1120  *
1121  *  current script command:
1122  *      dsp:    script address (relative to start of script).
1123  *      dbc:    first word of script command.
1124  *
1125  *  First 24 register of the chip:
1126  *      r0..rf
1127  */
1128 static void sym_log_hard_error(struct sym_hcb *np, u_short sist, u_char dstat)
1129 {
1130         u32     dsp;
1131         int     script_ofs;
1132         int     script_size;
1133         char    *script_name;
1134         u_char  *script_base;
1135         int     i;
1136
1137         dsp     = INL(np, nc_dsp);
1138
1139         if      (dsp > np->scripta_ba &&
1140                  dsp <= np->scripta_ba + np->scripta_sz) {
1141                 script_ofs      = dsp - np->scripta_ba;
1142                 script_size     = np->scripta_sz;
1143                 script_base     = (u_char *) np->scripta0;
1144                 script_name     = "scripta";
1145         }
1146         else if (np->scriptb_ba < dsp && 
1147                  dsp <= np->scriptb_ba + np->scriptb_sz) {
1148                 script_ofs      = dsp - np->scriptb_ba;
1149                 script_size     = np->scriptb_sz;
1150                 script_base     = (u_char *) np->scriptb0;
1151                 script_name     = "scriptb";
1152         } else {
1153                 script_ofs      = dsp;
1154                 script_size     = 0;
1155                 script_base     = NULL;
1156                 script_name     = "mem";
1157         }
1158
1159         printf ("%s:%d: ERROR (%x:%x) (%x-%x-%x) (%x/%x/%x) @ (%s %x:%08x).\n",
1160                 sym_name(np), (unsigned)INB(np, nc_sdid)&0x0f, dstat, sist,
1161                 (unsigned)INB(np, nc_socl), (unsigned)INB(np, nc_sbcl),
1162                 (unsigned)INB(np, nc_sbdl), (unsigned)INB(np, nc_sxfer),
1163                 (unsigned)INB(np, nc_scntl3),
1164                 (np->features & FE_C10) ?  (unsigned)INB(np, nc_scntl4) : 0,
1165                 script_name, script_ofs,   (unsigned)INL(np, nc_dbc));
1166
1167         if (((script_ofs & 3) == 0) &&
1168             (unsigned)script_ofs < script_size) {
1169                 printf ("%s: script cmd = %08x\n", sym_name(np),
1170                         scr_to_cpu((int) *(u32 *)(script_base + script_ofs)));
1171         }
1172
1173         printf ("%s: regdump:", sym_name(np));
1174         for (i=0; i<24;i++)
1175             printf (" %02x", (unsigned)INB_OFF(np, i));
1176         printf (".\n");
1177
1178         /*
1179          *  PCI BUS error.
1180          */
1181         if (dstat & (MDPE|BF))
1182                 sym_log_bus_error(np);
1183 }
1184
1185 static struct sym_chip sym_dev_table[] = {
1186  {PCI_DEVICE_ID_NCR_53C810, 0x0f, "810", 4, 8, 4, 64,
1187  FE_ERL}
1188  ,
1189 #ifdef SYM_DEBUG_GENERIC_SUPPORT
1190  {PCI_DEVICE_ID_NCR_53C810, 0xff, "810a", 4,  8, 4, 1,
1191  FE_BOF}
1192  ,
1193 #else
1194  {PCI_DEVICE_ID_NCR_53C810, 0xff, "810a", 4,  8, 4, 1,
1195  FE_CACHE_SET|FE_LDSTR|FE_PFEN|FE_BOF}
1196  ,
1197 #endif
1198  {PCI_DEVICE_ID_NCR_53C815, 0xff, "815", 4,  8, 4, 64,
1199  FE_BOF|FE_ERL}
1200  ,
1201  {PCI_DEVICE_ID_NCR_53C825, 0x0f, "825", 6,  8, 4, 64,
1202  FE_WIDE|FE_BOF|FE_ERL|FE_DIFF}
1203  ,
1204  {PCI_DEVICE_ID_NCR_53C825, 0xff, "825a", 6,  8, 4, 2,
1205  FE_WIDE|FE_CACHE0_SET|FE_BOF|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM|FE_DIFF}
1206  ,
1207  {PCI_DEVICE_ID_NCR_53C860, 0xff, "860", 4,  8, 5, 1,
1208  FE_ULTRA|FE_CACHE_SET|FE_BOF|FE_LDSTR|FE_PFEN}
1209  ,
1210  {PCI_DEVICE_ID_NCR_53C875, 0x01, "875", 6, 16, 5, 2,
1211  FE_WIDE|FE_ULTRA|FE_CACHE0_SET|FE_BOF|FE_DFS|FE_LDSTR|FE_PFEN|
1212  FE_RAM|FE_DIFF|FE_VARCLK}
1213  ,
1214  {PCI_DEVICE_ID_NCR_53C875, 0xff, "875", 6, 16, 5, 2,
1215  FE_WIDE|FE_ULTRA|FE_DBLR|FE_CACHE0_SET|FE_BOF|FE_DFS|FE_LDSTR|FE_PFEN|
1216  FE_RAM|FE_DIFF|FE_VARCLK}
1217  ,
1218  {PCI_DEVICE_ID_NCR_53C875J, 0xff, "875J", 6, 16, 5, 2,
1219  FE_WIDE|FE_ULTRA|FE_DBLR|FE_CACHE0_SET|FE_BOF|FE_DFS|FE_LDSTR|FE_PFEN|
1220  FE_RAM|FE_DIFF|FE_VARCLK}
1221  ,
1222  {PCI_DEVICE_ID_NCR_53C885, 0xff, "885", 6, 16, 5, 2,
1223  FE_WIDE|FE_ULTRA|FE_DBLR|FE_CACHE0_SET|FE_BOF|FE_DFS|FE_LDSTR|FE_PFEN|
1224  FE_RAM|FE_DIFF|FE_VARCLK}
1225  ,
1226 #ifdef SYM_DEBUG_GENERIC_SUPPORT
1227  {PCI_DEVICE_ID_NCR_53C895, 0xff, "895", 6, 31, 7, 2,
1228  FE_WIDE|FE_ULTRA2|FE_QUAD|FE_CACHE_SET|FE_BOF|FE_DFS|
1229  FE_RAM|FE_LCKFRQ}
1230  ,
1231 #else
1232  {PCI_DEVICE_ID_NCR_53C895, 0xff, "895", 6, 31, 7, 2,
1233  FE_WIDE|FE_ULTRA2|FE_QUAD|FE_CACHE_SET|FE_BOF|FE_DFS|FE_LDSTR|FE_PFEN|
1234  FE_RAM|FE_LCKFRQ}
1235  ,
1236 #endif
1237  {PCI_DEVICE_ID_NCR_53C896, 0xff, "896", 6, 31, 7, 4,
1238  FE_WIDE|FE_ULTRA2|FE_QUAD|FE_CACHE_SET|FE_BOF|FE_DFS|FE_LDSTR|FE_PFEN|
1239  FE_RAM|FE_RAM8K|FE_64BIT|FE_DAC|FE_IO256|FE_NOPM|FE_LEDC|FE_LCKFRQ}
1240  ,
1241  {PCI_DEVICE_ID_LSI_53C895A, 0xff, "895a", 6, 31, 7, 4,
1242  FE_WIDE|FE_ULTRA2|FE_QUAD|FE_CACHE_SET|FE_BOF|FE_DFS|FE_LDSTR|FE_PFEN|
1243  FE_RAM|FE_RAM8K|FE_DAC|FE_IO256|FE_NOPM|FE_LEDC|FE_LCKFRQ}
1244  ,
1245  {PCI_DEVICE_ID_LSI_53C875A, 0xff, "875a", 6, 31, 7, 4,
1246  FE_WIDE|FE_ULTRA|FE_QUAD|FE_CACHE_SET|FE_BOF|FE_DFS|FE_LDSTR|FE_PFEN|
1247  FE_RAM|FE_DAC|FE_IO256|FE_NOPM|FE_LEDC|FE_LCKFRQ}
1248  ,
1249  {PCI_DEVICE_ID_LSI_53C1010_33, 0x00, "1010-33", 6, 31, 7, 8,
1250  FE_WIDE|FE_ULTRA3|FE_QUAD|FE_CACHE_SET|FE_BOF|FE_DFBC|FE_LDSTR|FE_PFEN|
1251  FE_RAM|FE_RAM8K|FE_64BIT|FE_DAC|FE_IO256|FE_NOPM|FE_LEDC|FE_CRC|
1252  FE_C10}
1253  ,
1254  {PCI_DEVICE_ID_LSI_53C1010_33, 0xff, "1010-33", 6, 31, 7, 8,
1255  FE_WIDE|FE_ULTRA3|FE_QUAD|FE_CACHE_SET|FE_BOF|FE_DFBC|FE_LDSTR|FE_PFEN|
1256  FE_RAM|FE_RAM8K|FE_64BIT|FE_DAC|FE_IO256|FE_NOPM|FE_LEDC|FE_CRC|
1257  FE_C10|FE_U3EN}
1258  ,
1259  {PCI_DEVICE_ID_LSI_53C1010_66, 0xff, "1010-66", 6, 31, 7, 8,
1260  FE_WIDE|FE_ULTRA3|FE_QUAD|FE_CACHE_SET|FE_BOF|FE_DFBC|FE_LDSTR|FE_PFEN|
1261  FE_RAM|FE_RAM8K|FE_64BIT|FE_DAC|FE_IO256|FE_NOPM|FE_LEDC|FE_66MHZ|FE_CRC|
1262  FE_C10|FE_U3EN}
1263  ,
1264  {PCI_DEVICE_ID_LSI_53C1510, 0xff, "1510d", 6, 31, 7, 4,
1265  FE_WIDE|FE_ULTRA2|FE_QUAD|FE_CACHE_SET|FE_BOF|FE_DFS|FE_LDSTR|FE_PFEN|
1266  FE_RAM|FE_IO256|FE_LEDC}
1267 };
1268
1269 #define sym_num_devs \
1270         (sizeof(sym_dev_table) / sizeof(sym_dev_table[0]))
1271
1272 /*
1273  *  Look up the chip table.
1274  *
1275  *  Return a pointer to the chip entry if found, 
1276  *  zero otherwise.
1277  */
1278 struct sym_chip *
1279 sym_lookup_chip_table (u_short device_id, u_char revision)
1280 {
1281         struct  sym_chip *chip;
1282         int     i;
1283
1284         for (i = 0; i < sym_num_devs; i++) {
1285                 chip = &sym_dev_table[i];
1286                 if (device_id != chip->device_id)
1287                         continue;
1288                 if (revision > chip->revision_id)
1289                         continue;
1290                 return chip;
1291         }
1292
1293         return NULL;
1294 }
1295
1296 #if SYM_CONF_DMA_ADDRESSING_MODE == 2
1297 /*
1298  *  Lookup the 64 bit DMA segments map.
1299  *  This is only used if the direct mapping 
1300  *  has been unsuccessful.
1301  */
1302 int sym_lookup_dmap(struct sym_hcb *np, u32 h, int s)
1303 {
1304         int i;
1305
1306         if (!np->use_dac)
1307                 goto weird;
1308
1309         /* Look up existing mappings */
1310         for (i = SYM_DMAP_SIZE-1; i > 0; i--) {
1311                 if (h == np->dmap_bah[i])
1312                         return i;
1313         }
1314         /* If direct mapping is free, get it */
1315         if (!np->dmap_bah[s])
1316                 goto new;
1317         /* Collision -> lookup free mappings */
1318         for (s = SYM_DMAP_SIZE-1; s > 0; s--) {
1319                 if (!np->dmap_bah[s])
1320                         goto new;
1321         }
1322 weird:
1323         panic("sym: ran out of 64 bit DMA segment registers");
1324         return -1;
1325 new:
1326         np->dmap_bah[s] = h;
1327         np->dmap_dirty = 1;
1328         return s;
1329 }
1330
1331 /*
1332  *  Update IO registers scratch C..R so they will be 
1333  *  in sync. with queued CCB expectations.
1334  */
1335 static void sym_update_dmap_regs(struct sym_hcb *np)
1336 {
1337         int o, i;
1338
1339         if (!np->dmap_dirty)
1340                 return;
1341         o = offsetof(struct sym_reg, nc_scrx[0]);
1342         for (i = 0; i < SYM_DMAP_SIZE; i++) {
1343                 OUTL_OFF(np, o, np->dmap_bah[i]);
1344                 o += 4;
1345         }
1346         np->dmap_dirty = 0;
1347 }
1348 #endif
1349
1350 /* Enforce all the fiddly SPI rules and the chip limitations */
1351 static void sym_check_goals(struct sym_hcb *np, struct scsi_target *starget,
1352                 struct sym_trans *goal)
1353 {
1354         if (!spi_support_wide(starget))
1355                 goal->width = 0;
1356
1357         if (!spi_support_sync(starget)) {
1358                 goal->iu = 0;
1359                 goal->dt = 0;
1360                 goal->qas = 0;
1361                 goal->offset = 0;
1362                 return;
1363         }
1364
1365         if (spi_support_dt(starget)) {
1366                 if (spi_support_dt_only(starget))
1367                         goal->dt = 1;
1368
1369                 if (goal->offset == 0)
1370                         goal->dt = 0;
1371         } else {
1372                 goal->dt = 0;
1373         }
1374
1375         /* Some targets fail to properly negotiate DT in SE mode */
1376         if ((np->scsi_mode != SMODE_LVD) || !(np->features & FE_U3EN))
1377                 goal->dt = 0;
1378
1379         if (goal->dt) {
1380                 /* all DT transfers must be wide */
1381                 goal->width = 1;
1382                 if (goal->offset > np->maxoffs_dt)
1383                         goal->offset = np->maxoffs_dt;
1384                 if (goal->period < np->minsync_dt)
1385                         goal->period = np->minsync_dt;
1386                 if (goal->period > np->maxsync_dt)
1387                         goal->period = np->maxsync_dt;
1388         } else {
1389                 goal->iu = goal->qas = 0;
1390                 if (goal->offset > np->maxoffs)
1391                         goal->offset = np->maxoffs;
1392                 if (goal->period < np->minsync)
1393                         goal->period = np->minsync;
1394                 if (goal->period > np->maxsync)
1395                         goal->period = np->maxsync;
1396         }
1397 }
1398
1399 /*
1400  *  Prepare the next negotiation message if needed.
1401  *
1402  *  Fill in the part of message buffer that contains the 
1403  *  negotiation and the nego_status field of the CCB.
1404  *  Returns the size of the message in bytes.
1405  */
1406 static int sym_prepare_nego(struct sym_hcb *np, struct sym_ccb *cp, u_char *msgptr)
1407 {
1408         struct sym_tcb *tp = &np->target[cp->target];
1409         struct scsi_target *starget = tp->starget;
1410         struct sym_trans *goal = &tp->tgoal;
1411         int msglen = 0;
1412         int nego;
1413
1414         sym_check_goals(np, starget, goal);
1415
1416         /*
1417          * Many devices implement PPR in a buggy way, so only use it if we
1418          * really want to.
1419          */
1420         if (goal->offset &&
1421             (goal->iu || goal->dt || goal->qas || (goal->period < 0xa))) {
1422                 nego = NS_PPR;
1423         } else if (spi_width(starget) != goal->width) {
1424                 nego = NS_WIDE;
1425         } else if (spi_period(starget) != goal->period ||
1426                    spi_offset(starget) != goal->offset) {
1427                 nego = NS_SYNC;
1428         } else {
1429                 goal->check_nego = 0;
1430                 nego = 0;
1431         }
1432
1433         switch (nego) {
1434         case NS_SYNC:
1435                 msgptr[msglen++] = M_EXTENDED;
1436                 msgptr[msglen++] = 3;
1437                 msgptr[msglen++] = M_X_SYNC_REQ;
1438                 msgptr[msglen++] = goal->period;
1439                 msgptr[msglen++] = goal->offset;
1440                 break;
1441         case NS_WIDE:
1442                 msgptr[msglen++] = M_EXTENDED;
1443                 msgptr[msglen++] = 2;
1444                 msgptr[msglen++] = M_X_WIDE_REQ;
1445                 msgptr[msglen++] = goal->width;
1446                 break;
1447         case NS_PPR:
1448                 msgptr[msglen++] = M_EXTENDED;
1449                 msgptr[msglen++] = 6;
1450                 msgptr[msglen++] = M_X_PPR_REQ;
1451                 msgptr[msglen++] = goal->period;
1452                 msgptr[msglen++] = 0;
1453                 msgptr[msglen++] = goal->offset;
1454                 msgptr[msglen++] = goal->width;
1455                 msgptr[msglen++] = (goal->iu ? PPR_OPT_IU : 0) |
1456                                         (goal->dt ? PPR_OPT_DT : 0) |
1457                                         (goal->qas ? PPR_OPT_QAS : 0);
1458                 break;
1459         }
1460
1461         cp->nego_status = nego;
1462
1463         if (nego) {
1464                 tp->nego_cp = cp; /* Keep track a nego will be performed */
1465                 if (DEBUG_FLAGS & DEBUG_NEGO) {
1466                         sym_print_nego_msg(np, cp->target, 
1467                                           nego == NS_SYNC ? "sync msgout" :
1468                                           nego == NS_WIDE ? "wide msgout" :
1469                                           "ppr msgout", msgptr);
1470                 }
1471         }
1472
1473         return msglen;
1474 }
1475
1476 /*
1477  *  Insert a job into the start queue.
1478  */
1479 static void sym_put_start_queue(struct sym_hcb *np, struct sym_ccb *cp)
1480 {
1481         u_short qidx;
1482
1483 #ifdef SYM_CONF_IARB_SUPPORT
1484         /*
1485          *  If the previously queued CCB is not yet done, 
1486          *  set the IARB hint. The SCRIPTS will go with IARB 
1487          *  for this job when starting the previous one.
1488          *  We leave devices a chance to win arbitration by 
1489          *  not using more than 'iarb_max' consecutive 
1490          *  immediate arbitrations.
1491          */
1492         if (np->last_cp && np->iarb_count < np->iarb_max) {
1493                 np->last_cp->host_flags |= HF_HINT_IARB;
1494                 ++np->iarb_count;
1495         }
1496         else
1497                 np->iarb_count = 0;
1498         np->last_cp = cp;
1499 #endif
1500
1501 #if   SYM_CONF_DMA_ADDRESSING_MODE == 2
1502         /*
1503          *  Make SCRIPTS aware of the 64 bit DMA 
1504          *  segment registers not being up-to-date.
1505          */
1506         if (np->dmap_dirty)
1507                 cp->host_xflags |= HX_DMAP_DIRTY;
1508 #endif
1509
1510         /*
1511          *  Insert first the idle task and then our job.
1512          *  The MBs should ensure proper ordering.
1513          */
1514         qidx = np->squeueput + 2;
1515         if (qidx >= MAX_QUEUE*2) qidx = 0;
1516
1517         np->squeue [qidx]          = cpu_to_scr(np->idletask_ba);
1518         MEMORY_WRITE_BARRIER();
1519         np->squeue [np->squeueput] = cpu_to_scr(cp->ccb_ba);
1520
1521         np->squeueput = qidx;
1522
1523         if (DEBUG_FLAGS & DEBUG_QUEUE)
1524                 printf ("%s: queuepos=%d.\n", sym_name (np), np->squeueput);
1525
1526         /*
1527          *  Script processor may be waiting for reselect.
1528          *  Wake it up.
1529          */
1530         MEMORY_WRITE_BARRIER();
1531         OUTB(np, nc_istat, SIGP|np->istat_sem);
1532 }
1533
1534 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
1535 /*
1536  *  Start next ready-to-start CCBs.
1537  */
1538 void sym_start_next_ccbs(struct sym_hcb *np, struct sym_lcb *lp, int maxn)
1539 {
1540         SYM_QUEHEAD *qp;
1541         struct sym_ccb *cp;
1542
1543         /* 
1544          *  Paranoia, as usual. :-)
1545          */
1546         assert(!lp->started_tags || !lp->started_no_tag);
1547
1548         /*
1549          *  Try to start as many commands as asked by caller.
1550          *  Prevent from having both tagged and untagged 
1551          *  commands queued to the device at the same time.
1552          */
1553         while (maxn--) {
1554                 qp = sym_remque_head(&lp->waiting_ccbq);
1555                 if (!qp)
1556                         break;
1557                 cp = sym_que_entry(qp, struct sym_ccb, link2_ccbq);
1558                 if (cp->tag != NO_TAG) {
1559                         if (lp->started_no_tag ||
1560                             lp->started_tags >= lp->started_max) {
1561                                 sym_insque_head(qp, &lp->waiting_ccbq);
1562                                 break;
1563                         }
1564                         lp->itlq_tbl[cp->tag] = cpu_to_scr(cp->ccb_ba);
1565                         lp->head.resel_sa =
1566                                 cpu_to_scr(SCRIPTA_BA(np, resel_tag));
1567                         ++lp->started_tags;
1568                 } else {
1569                         if (lp->started_no_tag || lp->started_tags) {
1570                                 sym_insque_head(qp, &lp->waiting_ccbq);
1571                                 break;
1572                         }
1573                         lp->head.itl_task_sa = cpu_to_scr(cp->ccb_ba);
1574                         lp->head.resel_sa =
1575                               cpu_to_scr(SCRIPTA_BA(np, resel_no_tag));
1576                         ++lp->started_no_tag;
1577                 }
1578                 cp->started = 1;
1579                 sym_insque_tail(qp, &lp->started_ccbq);
1580                 sym_put_start_queue(np, cp);
1581         }
1582 }
1583 #endif /* SYM_OPT_HANDLE_DEVICE_QUEUEING */
1584
1585 /*
1586  *  The chip may have completed jobs. Look at the DONE QUEUE.
1587  *
1588  *  On paper, memory read barriers may be needed here to 
1589  *  prevent out of order LOADs by the CPU from having 
1590  *  prefetched stale data prior to DMA having occurred.
1591  */
1592 static int sym_wakeup_done (struct sym_hcb *np)
1593 {
1594         struct sym_ccb *cp;
1595         int i, n;
1596         u32 dsa;
1597
1598         n = 0;
1599         i = np->dqueueget;
1600
1601         /* MEMORY_READ_BARRIER(); */
1602         while (1) {
1603                 dsa = scr_to_cpu(np->dqueue[i]);
1604                 if (!dsa)
1605                         break;
1606                 np->dqueue[i] = 0;
1607                 if ((i = i+2) >= MAX_QUEUE*2)
1608                         i = 0;
1609
1610                 cp = sym_ccb_from_dsa(np, dsa);
1611                 if (cp) {
1612                         MEMORY_READ_BARRIER();
1613                         sym_complete_ok (np, cp);
1614                         ++n;
1615                 }
1616                 else
1617                         printf ("%s: bad DSA (%x) in done queue.\n",
1618                                 sym_name(np), (u_int) dsa);
1619         }
1620         np->dqueueget = i;
1621
1622         return n;
1623 }
1624
1625 /*
1626  *  Complete all CCBs queued to the COMP queue.
1627  *
1628  *  These CCBs are assumed:
1629  *  - Not to be referenced either by devices or 
1630  *    SCRIPTS-related queues and datas.
1631  *  - To have to be completed with an error condition 
1632  *    or requeued.
1633  *
1634  *  The device queue freeze count is incremented 
1635  *  for each CCB that does not prevent this.
1636  *  This function is called when all CCBs involved 
1637  *  in error handling/recovery have been reaped.
1638  */
1639 static void sym_flush_comp_queue(struct sym_hcb *np, int cam_status)
1640 {
1641         SYM_QUEHEAD *qp;
1642         struct sym_ccb *cp;
1643
1644         while ((qp = sym_remque_head(&np->comp_ccbq)) != 0) {
1645                 struct scsi_cmnd *cmd;
1646                 cp = sym_que_entry(qp, struct sym_ccb, link_ccbq);
1647                 sym_insque_tail(&cp->link_ccbq, &np->busy_ccbq);
1648                 /* Leave quiet CCBs waiting for resources */
1649                 if (cp->host_status == HS_WAIT)
1650                         continue;
1651                 cmd = cp->cmd;
1652                 if (cam_status)
1653                         sym_set_cam_status(cmd, cam_status);
1654 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
1655                 if (sym_get_cam_status(cmd) == DID_SOFT_ERROR) {
1656                         struct sym_tcb *tp = &np->target[cp->target];
1657                         struct sym_lcb *lp = sym_lp(tp, cp->lun);
1658                         if (lp) {
1659                                 sym_remque(&cp->link2_ccbq);
1660                                 sym_insque_tail(&cp->link2_ccbq,
1661                                                 &lp->waiting_ccbq);
1662                                 if (cp->started) {
1663                                         if (cp->tag != NO_TAG)
1664                                                 --lp->started_tags;
1665                                         else
1666                                                 --lp->started_no_tag;
1667                                 }
1668                         }
1669                         cp->started = 0;
1670                         continue;
1671                 }
1672 #endif
1673                 sym_free_ccb(np, cp);
1674                 sym_xpt_done(np, cmd);
1675         }
1676 }
1677
1678 /*
1679  *  Complete all active CCBs with error.
1680  *  Used on CHIP/SCSI RESET.
1681  */
1682 static void sym_flush_busy_queue (struct sym_hcb *np, int cam_status)
1683 {
1684         /*
1685          *  Move all active CCBs to the COMP queue 
1686          *  and flush this queue.
1687          */
1688         sym_que_splice(&np->busy_ccbq, &np->comp_ccbq);
1689         sym_que_init(&np->busy_ccbq);
1690         sym_flush_comp_queue(np, cam_status);
1691 }
1692
1693 /*
1694  *  Start chip.
1695  *
1696  *  'reason' means:
1697  *     0: initialisation.
1698  *     1: SCSI BUS RESET delivered or received.
1699  *     2: SCSI BUS MODE changed.
1700  */
1701 void sym_start_up (struct sym_hcb *np, int reason)
1702 {
1703         int     i;
1704         u32     phys;
1705
1706         /*
1707          *  Reset chip if asked, otherwise just clear fifos.
1708          */
1709         if (reason == 1)
1710                 sym_soft_reset(np);
1711         else {
1712                 OUTB(np, nc_stest3, TE|CSF);
1713                 OUTONB(np, nc_ctest3, CLF);
1714         }
1715  
1716         /*
1717          *  Clear Start Queue
1718          */
1719         phys = np->squeue_ba;
1720         for (i = 0; i < MAX_QUEUE*2; i += 2) {
1721                 np->squeue[i]   = cpu_to_scr(np->idletask_ba);
1722                 np->squeue[i+1] = cpu_to_scr(phys + (i+2)*4);
1723         }
1724         np->squeue[MAX_QUEUE*2-1] = cpu_to_scr(phys);
1725
1726         /*
1727          *  Start at first entry.
1728          */
1729         np->squeueput = 0;
1730
1731         /*
1732          *  Clear Done Queue
1733          */
1734         phys = np->dqueue_ba;
1735         for (i = 0; i < MAX_QUEUE*2; i += 2) {
1736                 np->dqueue[i]   = 0;
1737                 np->dqueue[i+1] = cpu_to_scr(phys + (i+2)*4);
1738         }
1739         np->dqueue[MAX_QUEUE*2-1] = cpu_to_scr(phys);
1740
1741         /*
1742          *  Start at first entry.
1743          */
1744         np->dqueueget = 0;
1745
1746         /*
1747          *  Install patches in scripts.
1748          *  This also let point to first position the start 
1749          *  and done queue pointers used from SCRIPTS.
1750          */
1751         np->fw_patch(np);
1752
1753         /*
1754          *  Wakeup all pending jobs.
1755          */
1756         sym_flush_busy_queue(np, DID_RESET);
1757
1758         /*
1759          *  Init chip.
1760          */
1761         OUTB(np, nc_istat,  0x00);                      /*  Remove Reset, abort */
1762         INB(np, nc_mbox1);
1763         udelay(2000); /* The 895 needs time for the bus mode to settle */
1764
1765         OUTB(np, nc_scntl0, np->rv_scntl0 | 0xc0);
1766                                         /*  full arb., ena parity, par->ATN  */
1767         OUTB(np, nc_scntl1, 0x00);              /*  odd parity, and remove CRST!! */
1768
1769         sym_selectclock(np, np->rv_scntl3);     /* Select SCSI clock */
1770
1771         OUTB(np, nc_scid  , RRE|np->myaddr);    /* Adapter SCSI address */
1772         OUTW(np, nc_respid, 1ul<<np->myaddr);   /* Id to respond to */
1773         OUTB(np, nc_istat , SIGP        );              /*  Signal Process */
1774         OUTB(np, nc_dmode , np->rv_dmode);              /* Burst length, dma mode */
1775         OUTB(np, nc_ctest5, np->rv_ctest5);     /* Large fifo + large burst */
1776
1777         OUTB(np, nc_dcntl , NOCOM|np->rv_dcntl);        /* Protect SFBR */
1778         OUTB(np, nc_ctest3, np->rv_ctest3);     /* Write and invalidate */
1779         OUTB(np, nc_ctest4, np->rv_ctest4);     /* Master parity checking */
1780
1781         /* Extended Sreq/Sack filtering not supported on the C10 */
1782         if (np->features & FE_C10)
1783                 OUTB(np, nc_stest2, np->rv_stest2);
1784         else
1785                 OUTB(np, nc_stest2, EXT|np->rv_stest2);
1786
1787         OUTB(np, nc_stest3, TE);                        /* TolerANT enable */
1788         OUTB(np, nc_stime0, 0x0c);                      /* HTH disabled  STO 0.25 sec */
1789
1790         /*
1791          *  For now, disable AIP generation on C1010-66.
1792          */
1793         if (np->device_id == PCI_DEVICE_ID_LSI_53C1010_66)
1794                 OUTB(np, nc_aipcntl1, DISAIP);
1795
1796         /*
1797          *  C10101 rev. 0 errata.
1798          *  Errant SGE's when in narrow. Write bits 4 & 5 of
1799          *  STEST1 register to disable SGE. We probably should do 
1800          *  that from SCRIPTS for each selection/reselection, but 
1801          *  I just don't want. :)
1802          */
1803         if (np->device_id == PCI_DEVICE_ID_LSI_53C1010_33 &&
1804             np->revision_id < 1)
1805                 OUTB(np, nc_stest1, INB(np, nc_stest1) | 0x30);
1806
1807         /*
1808          *  DEL 441 - 53C876 Rev 5 - Part Number 609-0392787/2788 - ITEM 2.
1809          *  Disable overlapped arbitration for some dual function devices, 
1810          *  regardless revision id (kind of post-chip-design feature. ;-))
1811          */
1812         if (np->device_id == PCI_DEVICE_ID_NCR_53C875)
1813                 OUTB(np, nc_ctest0, (1<<5));
1814         else if (np->device_id == PCI_DEVICE_ID_NCR_53C896)
1815                 np->rv_ccntl0 |= DPR;
1816
1817         /*
1818          *  Write CCNTL0/CCNTL1 for chips capable of 64 bit addressing 
1819          *  and/or hardware phase mismatch, since only such chips 
1820          *  seem to support those IO registers.
1821          */
1822         if (np->features & (FE_DAC|FE_NOPM)) {
1823                 OUTB(np, nc_ccntl0, np->rv_ccntl0);
1824                 OUTB(np, nc_ccntl1, np->rv_ccntl1);
1825         }
1826
1827 #if     SYM_CONF_DMA_ADDRESSING_MODE == 2
1828         /*
1829          *  Set up scratch C and DRS IO registers to map the 32 bit 
1830          *  DMA address range our data structures are located in.
1831          */
1832         if (np->use_dac) {
1833                 np->dmap_bah[0] = 0;    /* ??? */
1834                 OUTL(np, nc_scrx[0], np->dmap_bah[0]);
1835                 OUTL(np, nc_drs, np->dmap_bah[0]);
1836         }
1837 #endif
1838
1839         /*
1840          *  If phase mismatch handled by scripts (895A/896/1010),
1841          *  set PM jump addresses.
1842          */
1843         if (np->features & FE_NOPM) {
1844                 OUTL(np, nc_pmjad1, SCRIPTB_BA(np, pm_handle));
1845                 OUTL(np, nc_pmjad2, SCRIPTB_BA(np, pm_handle));
1846         }
1847
1848         /*
1849          *    Enable GPIO0 pin for writing if LED support from SCRIPTS.
1850          *    Also set GPIO5 and clear GPIO6 if hardware LED control.
1851          */
1852         if (np->features & FE_LED0)
1853                 OUTB(np, nc_gpcntl, INB(np, nc_gpcntl) & ~0x01);
1854         else if (np->features & FE_LEDC)
1855                 OUTB(np, nc_gpcntl, (INB(np, nc_gpcntl) & ~0x41) | 0x20);
1856
1857         /*
1858          *      enable ints
1859          */
1860         OUTW(np, nc_sien , STO|HTH|MA|SGE|UDC|RST|PAR);
1861         OUTB(np, nc_dien , MDPE|BF|SSI|SIR|IID);
1862
1863         /*
1864          *  For 895/6 enable SBMC interrupt and save current SCSI bus mode.
1865          *  Try to eat the spurious SBMC interrupt that may occur when 
1866          *  we reset the chip but not the SCSI BUS (at initialization).
1867          */
1868         if (np->features & (FE_ULTRA2|FE_ULTRA3)) {
1869                 OUTONW(np, nc_sien, SBMC);
1870                 if (reason == 0) {
1871                         INB(np, nc_mbox1);
1872                         mdelay(100);
1873                         INW(np, nc_sist);
1874                 }
1875                 np->scsi_mode = INB(np, nc_stest4) & SMODE;
1876         }
1877
1878         /*
1879          *  Fill in target structure.
1880          *  Reinitialize usrsync.
1881          *  Reinitialize usrwide.
1882          *  Prepare sync negotiation according to actual SCSI bus mode.
1883          */
1884         for (i=0;i<SYM_CONF_MAX_TARGET;i++) {
1885                 struct sym_tcb *tp = &np->target[i];
1886
1887                 tp->to_reset  = 0;
1888                 tp->head.sval = 0;
1889                 tp->head.wval = np->rv_scntl3;
1890                 tp->head.uval = 0;
1891         }
1892
1893         /*
1894          *  Download SCSI SCRIPTS to on-chip RAM if present,
1895          *  and start script processor.
1896          *  We do the download preferently from the CPU.
1897          *  For platforms that may not support PCI memory mapping,
1898          *  we use simple SCRIPTS that performs MEMORY MOVEs.
1899          */
1900         phys = SCRIPTA_BA(np, init);
1901         if (np->ram_ba) {
1902                 if (sym_verbose >= 2)
1903                         printf("%s: Downloading SCSI SCRIPTS.\n", sym_name(np));
1904                 memcpy_toio(np->s.ramaddr, np->scripta0, np->scripta_sz);
1905                 if (np->ram_ws == 8192) {
1906                         memcpy_toio(np->s.ramaddr + 4096, np->scriptb0, np->scriptb_sz);
1907                         phys = scr_to_cpu(np->scr_ram_seg);
1908                         OUTL(np, nc_mmws, phys);
1909                         OUTL(np, nc_mmrs, phys);
1910                         OUTL(np, nc_sfs,  phys);
1911                         phys = SCRIPTB_BA(np, start64);
1912                 }
1913         }
1914
1915         np->istat_sem = 0;
1916
1917         OUTL(np, nc_dsa, np->hcb_ba);
1918         OUTL_DSP(np, phys);
1919
1920         /*
1921          *  Notify the XPT about the RESET condition.
1922          */
1923         if (reason != 0)
1924                 sym_xpt_async_bus_reset(np);
1925 }
1926
1927 /*
1928  *  Switch trans mode for current job and its target.
1929  */
1930 static void sym_settrans(struct sym_hcb *np, int target, u_char opts, u_char ofs,
1931                          u_char per, u_char wide, u_char div, u_char fak)
1932 {
1933         SYM_QUEHEAD *qp;
1934         u_char sval, wval, uval;
1935         struct sym_tcb *tp = &np->target[target];
1936
1937         assert(target == (INB(np, nc_sdid) & 0x0f));
1938
1939         sval = tp->head.sval;
1940         wval = tp->head.wval;
1941         uval = tp->head.uval;
1942
1943 #if 0
1944         printf("XXXX sval=%x wval=%x uval=%x (%x)\n", 
1945                 sval, wval, uval, np->rv_scntl3);
1946 #endif
1947         /*
1948          *  Set the offset.
1949          */
1950         if (!(np->features & FE_C10))
1951                 sval = (sval & ~0x1f) | ofs;
1952         else
1953                 sval = (sval & ~0x3f) | ofs;
1954
1955         /*
1956          *  Set the sync divisor and extra clock factor.
1957          */
1958         if (ofs != 0) {
1959                 wval = (wval & ~0x70) | ((div+1) << 4);
1960                 if (!(np->features & FE_C10))
1961                         sval = (sval & ~0xe0) | (fak << 5);
1962                 else {
1963                         uval = uval & ~(XCLKH_ST|XCLKH_DT|XCLKS_ST|XCLKS_DT);
1964                         if (fak >= 1) uval |= (XCLKH_ST|XCLKH_DT);
1965                         if (fak >= 2) uval |= (XCLKS_ST|XCLKS_DT);
1966                 }
1967         }
1968
1969         /*
1970          *  Set the bus width.
1971          */
1972         wval = wval & ~EWS;
1973         if (wide != 0)
1974                 wval |= EWS;
1975
1976         /*
1977          *  Set misc. ultra enable bits.
1978          */
1979         if (np->features & FE_C10) {
1980                 uval = uval & ~(U3EN|AIPCKEN);
1981                 if (opts)       {
1982                         assert(np->features & FE_U3EN);
1983                         uval |= U3EN;
1984                 }
1985         } else {
1986                 wval = wval & ~ULTRA;
1987                 if (per <= 12)  wval |= ULTRA;
1988         }
1989
1990         /*
1991          *   Stop there if sync parameters are unchanged.
1992          */
1993         if (tp->head.sval == sval && 
1994             tp->head.wval == wval &&
1995             tp->head.uval == uval)
1996                 return;
1997         tp->head.sval = sval;
1998         tp->head.wval = wval;
1999         tp->head.uval = uval;
2000
2001         /*
2002          *  Disable extended Sreq/Sack filtering if per < 50.
2003          *  Not supported on the C1010.
2004          */
2005         if (per < 50 && !(np->features & FE_C10))
2006                 OUTOFFB(np, nc_stest2, EXT);
2007
2008         /*
2009          *  set actual value and sync_status
2010          */
2011         OUTB(np, nc_sxfer,  tp->head.sval);
2012         OUTB(np, nc_scntl3, tp->head.wval);
2013
2014         if (np->features & FE_C10) {
2015                 OUTB(np, nc_scntl4, tp->head.uval);
2016         }
2017
2018         /*
2019          *  patch ALL busy ccbs of this target.
2020          */
2021         FOR_EACH_QUEUED_ELEMENT(&np->busy_ccbq, qp) {
2022                 struct sym_ccb *cp;
2023                 cp = sym_que_entry(qp, struct sym_ccb, link_ccbq);
2024                 if (cp->target != target)
2025                         continue;
2026                 cp->phys.select.sel_scntl3 = tp->head.wval;
2027                 cp->phys.select.sel_sxfer  = tp->head.sval;
2028                 if (np->features & FE_C10) {
2029                         cp->phys.select.sel_scntl4 = tp->head.uval;
2030                 }
2031         }
2032 }
2033
2034 /*
2035  *  We received a WDTR.
2036  *  Let everything be aware of the changes.
2037  */
2038 static void sym_setwide(struct sym_hcb *np, int target, u_char wide)
2039 {
2040         struct sym_tcb *tp = &np->target[target];
2041         struct scsi_target *starget = tp->starget;
2042
2043         if (spi_width(starget) == wide)
2044                 return;
2045
2046         sym_settrans(np, target, 0, 0, 0, wide, 0, 0);
2047
2048         tp->tgoal.width = wide;
2049         spi_offset(starget) = 0;
2050         spi_period(starget) = 0;
2051         spi_width(starget) = wide;
2052         spi_iu(starget) = 0;
2053         spi_dt(starget) = 0;
2054         spi_qas(starget) = 0;
2055
2056         if (sym_verbose >= 3)
2057                 spi_display_xfer_agreement(starget);
2058 }
2059
2060 /*
2061  *  We received a SDTR.
2062  *  Let everything be aware of the changes.
2063  */
2064 static void
2065 sym_setsync(struct sym_hcb *np, int target,
2066             u_char ofs, u_char per, u_char div, u_char fak)
2067 {
2068         struct sym_tcb *tp = &np->target[target];
2069         struct scsi_target *starget = tp->starget;
2070         u_char wide = (tp->head.wval & EWS) ? BUS_16_BIT : BUS_8_BIT;
2071
2072         sym_settrans(np, target, 0, ofs, per, wide, div, fak);
2073
2074         spi_period(starget) = per;
2075         spi_offset(starget) = ofs;
2076         spi_iu(starget) = spi_dt(starget) = spi_qas(starget) = 0;
2077
2078         if (!tp->tgoal.dt && !tp->tgoal.iu && !tp->tgoal.qas) {
2079                 tp->tgoal.period = per;
2080                 tp->tgoal.offset = ofs;
2081                 tp->tgoal.check_nego = 0;
2082         }
2083
2084         spi_display_xfer_agreement(starget);
2085 }
2086
2087 /*
2088  *  We received a PPR.
2089  *  Let everything be aware of the changes.
2090  */
2091 static void 
2092 sym_setpprot(struct sym_hcb *np, int target, u_char opts, u_char ofs,
2093              u_char per, u_char wide, u_char div, u_char fak)
2094 {
2095         struct sym_tcb *tp = &np->target[target];
2096         struct scsi_target *starget = tp->starget;
2097
2098         sym_settrans(np, target, opts, ofs, per, wide, div, fak);
2099
2100         spi_width(starget) = tp->tgoal.width = wide;
2101         spi_period(starget) = tp->tgoal.period = per;
2102         spi_offset(starget) = tp->tgoal.offset = ofs;
2103         spi_iu(starget) = tp->tgoal.iu = !!(opts & PPR_OPT_IU);
2104         spi_dt(starget) = tp->tgoal.dt = !!(opts & PPR_OPT_DT);
2105         spi_qas(starget) = tp->tgoal.qas = !!(opts & PPR_OPT_QAS);
2106         tp->tgoal.check_nego = 0;
2107
2108         spi_display_xfer_agreement(starget);
2109 }
2110
2111 /*
2112  *  generic recovery from scsi interrupt
2113  *
2114  *  The doc says that when the chip gets an SCSI interrupt,
2115  *  it tries to stop in an orderly fashion, by completing 
2116  *  an instruction fetch that had started or by flushing 
2117  *  the DMA fifo for a write to memory that was executing.
2118  *  Such a fashion is not enough to know if the instruction 
2119  *  that was just before the current DSP value has been 
2120  *  executed or not.
2121  *
2122  *  There are some small SCRIPTS sections that deal with 
2123  *  the start queue and the done queue that may break any 
2124  *  assomption from the C code if we are interrupted 
2125  *  inside, so we reset if this happens. Btw, since these 
2126  *  SCRIPTS sections are executed while the SCRIPTS hasn't 
2127  *  started SCSI operations, it is very unlikely to happen.
2128  *
2129  *  All the driver data structures are supposed to be 
2130  *  allocated from the same 4 GB memory window, so there 
2131  *  is a 1 to 1 relationship between DSA and driver data 
2132  *  structures. Since we are careful :) to invalidate the 
2133  *  DSA when we complete a command or when the SCRIPTS 
2134  *  pushes a DSA into a queue, we can trust it when it 
2135  *  points to a CCB.
2136  */
2137 static void sym_recover_scsi_int (struct sym_hcb *np, u_char hsts)
2138 {
2139         u32     dsp     = INL(np, nc_dsp);
2140         u32     dsa     = INL(np, nc_dsa);
2141         struct sym_ccb *cp      = sym_ccb_from_dsa(np, dsa);
2142
2143         /*
2144          *  If we haven't been interrupted inside the SCRIPTS 
2145          *  critical pathes, we can safely restart the SCRIPTS 
2146          *  and trust the DSA value if it matches a CCB.
2147          */
2148         if ((!(dsp > SCRIPTA_BA(np, getjob_begin) &&
2149                dsp < SCRIPTA_BA(np, getjob_end) + 1)) &&
2150             (!(dsp > SCRIPTA_BA(np, ungetjob) &&
2151                dsp < SCRIPTA_BA(np, reselect) + 1)) &&
2152             (!(dsp > SCRIPTB_BA(np, sel_for_abort) &&
2153                dsp < SCRIPTB_BA(np, sel_for_abort_1) + 1)) &&
2154             (!(dsp > SCRIPTA_BA(np, done) &&
2155                dsp < SCRIPTA_BA(np, done_end) + 1))) {
2156                 OUTB(np, nc_ctest3, np->rv_ctest3 | CLF); /* clear dma fifo  */
2157                 OUTB(np, nc_stest3, TE|CSF);            /* clear scsi fifo */
2158                 /*
2159                  *  If we have a CCB, let the SCRIPTS call us back for 
2160                  *  the handling of the error with SCRATCHA filled with 
2161                  *  STARTPOS. This way, we will be able to freeze the 
2162                  *  device queue and requeue awaiting IOs.
2163                  */
2164                 if (cp) {
2165                         cp->host_status = hsts;
2166                         OUTL_DSP(np, SCRIPTA_BA(np, complete_error));
2167                 }
2168                 /*
2169                  *  Otherwise just restart the SCRIPTS.
2170                  */
2171                 else {
2172                         OUTL(np, nc_dsa, 0xffffff);
2173                         OUTL_DSP(np, SCRIPTA_BA(np, start));
2174                 }
2175         }
2176         else
2177                 goto reset_all;
2178
2179         return;
2180
2181 reset_all:
2182         sym_start_reset(np);
2183 }
2184
2185 /*
2186  *  chip exception handler for selection timeout
2187  */
2188 static void sym_int_sto (struct sym_hcb *np)
2189 {
2190         u32 dsp = INL(np, nc_dsp);
2191
2192         if (DEBUG_FLAGS & DEBUG_TINY) printf ("T");
2193
2194         if (dsp == SCRIPTA_BA(np, wf_sel_done) + 8)
2195                 sym_recover_scsi_int(np, HS_SEL_TIMEOUT);
2196         else
2197                 sym_start_reset(np);
2198 }
2199
2200 /*
2201  *  chip exception handler for unexpected disconnect
2202  */
2203 static void sym_int_udc (struct sym_hcb *np)
2204 {
2205         printf ("%s: unexpected disconnect\n", sym_name(np));
2206         sym_recover_scsi_int(np, HS_UNEXPECTED);
2207 }
2208
2209 /*
2210  *  chip exception handler for SCSI bus mode change
2211  *
2212  *  spi2-r12 11.2.3 says a transceiver mode change must 
2213  *  generate a reset event and a device that detects a reset 
2214  *  event shall initiate a hard reset. It says also that a
2215  *  device that detects a mode change shall set data transfer 
2216  *  mode to eight bit asynchronous, etc...
2217  *  So, just reinitializing all except chip should be enough.
2218  */
2219 static void sym_int_sbmc (struct sym_hcb *np)
2220 {
2221         u_char scsi_mode = INB(np, nc_stest4) & SMODE;
2222
2223         /*
2224          *  Notify user.
2225          */
2226         printf("%s: SCSI BUS mode change from %s to %s.\n", sym_name(np),
2227                 sym_scsi_bus_mode(np->scsi_mode), sym_scsi_bus_mode(scsi_mode));
2228
2229         /*
2230          *  Should suspend command processing for a few seconds and 
2231          *  reinitialize all except the chip.
2232          */
2233         sym_start_up (np, 2);
2234 }
2235
2236 /*
2237  *  chip exception handler for SCSI parity error.
2238  *
2239  *  When the chip detects a SCSI parity error and is 
2240  *  currently executing a (CH)MOV instruction, it does 
2241  *  not interrupt immediately, but tries to finish the 
2242  *  transfer of the current scatter entry before 
2243  *  interrupting. The following situations may occur:
2244  *
2245  *  - The complete scatter entry has been transferred 
2246  *    without the device having changed phase.
2247  *    The chip will then interrupt with the DSP pointing 
2248  *    to the instruction that follows the MOV.
2249  *
2250  *  - A phase mismatch occurs before the MOV finished 
2251  *    and phase errors are to be handled by the C code.
2252  *    The chip will then interrupt with both PAR and MA 
2253  *    conditions set.
2254  *
2255  *  - A phase mismatch occurs before the MOV finished and 
2256  *    phase errors are to be handled by SCRIPTS.
2257  *    The chip will load the DSP with the phase mismatch 
2258  *    JUMP address and interrupt the host processor.
2259  */
2260 static void sym_int_par (struct sym_hcb *np, u_short sist)
2261 {
2262         u_char  hsts    = INB(np, HS_PRT);
2263         u32     dsp     = INL(np, nc_dsp);
2264         u32     dbc     = INL(np, nc_dbc);
2265         u32     dsa     = INL(np, nc_dsa);
2266         u_char  sbcl    = INB(np, nc_sbcl);
2267         u_char  cmd     = dbc >> 24;
2268         int phase       = cmd & 7;
2269         struct sym_ccb *cp      = sym_ccb_from_dsa(np, dsa);
2270
2271         printf("%s: SCSI parity error detected: SCR1=%d DBC=%x SBCL=%x\n",
2272                 sym_name(np), hsts, dbc, sbcl);
2273
2274         /*
2275          *  Check that the chip is connected to the SCSI BUS.
2276          */
2277         if (!(INB(np, nc_scntl1) & ISCON)) {
2278                 sym_recover_scsi_int(np, HS_UNEXPECTED);
2279                 return;
2280         }
2281
2282         /*
2283          *  If the nexus is not clearly identified, reset the bus.
2284          *  We will try to do better later.
2285          */
2286         if (!cp)
2287                 goto reset_all;
2288
2289         /*
2290          *  Check instruction was a MOV, direction was INPUT and 
2291          *  ATN is asserted.
2292          */
2293         if ((cmd & 0xc0) || !(phase & 1) || !(sbcl & 0x8))
2294                 goto reset_all;
2295
2296         /*
2297          *  Keep track of the parity error.
2298          */
2299         OUTONB(np, HF_PRT, HF_EXT_ERR);
2300         cp->xerr_status |= XE_PARITY_ERR;
2301
2302         /*
2303          *  Prepare the message to send to the device.
2304          */
2305         np->msgout[0] = (phase == 7) ? M_PARITY : M_ID_ERROR;
2306
2307         /*
2308          *  If the old phase was DATA IN phase, we have to deal with
2309          *  the 3 situations described above.
2310          *  For other input phases (MSG IN and STATUS), the device 
2311          *  must resend the whole thing that failed parity checking 
2312          *  or signal error. So, jumping to dispatcher should be OK.
2313          */
2314         if (phase == 1 || phase == 5) {
2315                 /* Phase mismatch handled by SCRIPTS */
2316                 if (dsp == SCRIPTB_BA(np, pm_handle))
2317                         OUTL_DSP(np, dsp);
2318                 /* Phase mismatch handled by the C code */
2319                 else if (sist & MA)
2320                         sym_int_ma (np);
2321                 /* No phase mismatch occurred */
2322                 else {
2323                         sym_set_script_dp (np, cp, dsp);
2324                         OUTL_DSP(np, SCRIPTA_BA(np, dispatch));
2325                 }
2326         }
2327         else if (phase == 7)    /* We definitely cannot handle parity errors */
2328 #if 1                           /* in message-in phase due to the relection  */
2329                 goto reset_all; /* path and various message anticipations.   */
2330 #else
2331                 OUTL_DSP(np, SCRIPTA_BA(np, clrack));
2332 #endif
2333         else
2334                 OUTL_DSP(np, SCRIPTA_BA(np, dispatch));
2335         return;
2336
2337 reset_all:
2338         sym_start_reset(np);
2339         return;
2340 }
2341
2342 /*
2343  *  chip exception handler for phase errors.
2344  *
2345  *  We have to construct a new transfer descriptor,
2346  *  to transfer the rest of the current block.
2347  */
2348 static void sym_int_ma (struct sym_hcb *np)
2349 {
2350         u32     dbc;
2351         u32     rest;
2352         u32     dsp;
2353         u32     dsa;
2354         u32     nxtdsp;
2355         u32     *vdsp;
2356         u32     oadr, olen;
2357         u32     *tblp;
2358         u32     newcmd;
2359         u_int   delta;
2360         u_char  cmd;
2361         u_char  hflags, hflags0;
2362         struct  sym_pmc *pm;
2363         struct sym_ccb *cp;
2364
2365         dsp     = INL(np, nc_dsp);
2366         dbc     = INL(np, nc_dbc);
2367         dsa     = INL(np, nc_dsa);
2368
2369         cmd     = dbc >> 24;
2370         rest    = dbc & 0xffffff;
2371         delta   = 0;
2372
2373         /*
2374          *  locate matching cp if any.
2375          */
2376         cp = sym_ccb_from_dsa(np, dsa);
2377
2378         /*
2379          *  Donnot take into account dma fifo and various buffers in 
2380          *  INPUT phase since the chip flushes everything before 
2381          *  raising the MA interrupt for interrupted INPUT phases.
2382          *  For DATA IN phase, we will check for the SWIDE later.
2383          */
2384         if ((cmd & 7) != 1 && (cmd & 7) != 5) {
2385                 u_char ss0, ss2;
2386
2387                 if (np->features & FE_DFBC)
2388                         delta = INW(np, nc_dfbc);
2389                 else {
2390                         u32 dfifo;
2391
2392                         /*
2393                          * Read DFIFO, CTEST[4-6] using 1 PCI bus ownership.
2394                          */
2395                         dfifo = INL(np, nc_dfifo);
2396
2397                         /*
2398                          *  Calculate remaining bytes in DMA fifo.
2399                          *  (CTEST5 = dfifo >> 16)
2400                          */
2401                         if (dfifo & (DFS << 16))
2402                                 delta = ((((dfifo >> 8) & 0x300) |
2403                                           (dfifo & 0xff)) - rest) & 0x3ff;
2404                         else
2405                                 delta = ((dfifo & 0xff) - rest) & 0x7f;
2406                 }
2407
2408                 /*
2409                  *  The data in the dma fifo has not been transfered to
2410                  *  the target -> add the amount to the rest
2411                  *  and clear the data.
2412                  *  Check the sstat2 register in case of wide transfer.
2413                  */
2414                 rest += delta;
2415                 ss0  = INB(np, nc_sstat0);
2416                 if (ss0 & OLF) rest++;
2417                 if (!(np->features & FE_C10))
2418                         if (ss0 & ORF) rest++;
2419                 if (cp && (cp->phys.select.sel_scntl3 & EWS)) {
2420                         ss2 = INB(np, nc_sstat2);
2421                         if (ss2 & OLF1) rest++;
2422                         if (!(np->features & FE_C10))
2423                                 if (ss2 & ORF1) rest++;
2424                 }
2425
2426                 /*
2427                  *  Clear fifos.
2428                  */
2429                 OUTB(np, nc_ctest3, np->rv_ctest3 | CLF);       /* dma fifo  */
2430                 OUTB(np, nc_stest3, TE|CSF);            /* scsi fifo */
2431         }
2432
2433         /*
2434          *  log the information
2435          */
2436         if (DEBUG_FLAGS & (DEBUG_TINY|DEBUG_PHASE))
2437                 printf ("P%x%x RL=%d D=%d ", cmd&7, INB(np, nc_sbcl)&7,
2438                         (unsigned) rest, (unsigned) delta);
2439
2440         /*
2441          *  try to find the interrupted script command,
2442          *  and the address at which to continue.
2443          */
2444         vdsp    = NULL;
2445         nxtdsp  = 0;
2446         if      (dsp >  np->scripta_ba &&
2447                  dsp <= np->scripta_ba + np->scripta_sz) {
2448                 vdsp = (u32 *)((char*)np->scripta0 + (dsp-np->scripta_ba-8));
2449                 nxtdsp = dsp;
2450         }
2451         else if (dsp >  np->scriptb_ba &&
2452                  dsp <= np->scriptb_ba + np->scriptb_sz) {
2453                 vdsp = (u32 *)((char*)np->scriptb0 + (dsp-np->scriptb_ba-8));
2454                 nxtdsp = dsp;
2455         }
2456
2457         /*
2458          *  log the information
2459          */
2460         if (DEBUG_FLAGS & DEBUG_PHASE) {
2461                 printf ("\nCP=%p DSP=%x NXT=%x VDSP=%p CMD=%x ",
2462                         cp, (unsigned)dsp, (unsigned)nxtdsp, vdsp, cmd);
2463         }
2464
2465         if (!vdsp) {
2466                 printf ("%s: interrupted SCRIPT address not found.\n", 
2467                         sym_name (np));
2468                 goto reset_all;
2469         }
2470
2471         if (!cp) {
2472                 printf ("%s: SCSI phase error fixup: CCB already dequeued.\n", 
2473                         sym_name (np));
2474                 goto reset_all;
2475         }
2476
2477         /*
2478          *  get old startaddress and old length.
2479          */
2480         oadr = scr_to_cpu(vdsp[1]);
2481
2482         if (cmd & 0x10) {       /* Table indirect */
2483                 tblp = (u32 *) ((char*) &cp->phys + oadr);
2484                 olen = scr_to_cpu(tblp[0]);
2485                 oadr = scr_to_cpu(tblp[1]);
2486         } else {
2487                 tblp = (u32 *) 0;
2488                 olen = scr_to_cpu(vdsp[0]) & 0xffffff;
2489         }
2490
2491         if (DEBUG_FLAGS & DEBUG_PHASE) {
2492                 printf ("OCMD=%x\nTBLP=%p OLEN=%x OADR=%x\n",
2493                         (unsigned) (scr_to_cpu(vdsp[0]) >> 24),
2494                         tblp,
2495                         (unsigned) olen,
2496                         (unsigned) oadr);
2497         }
2498
2499         /*
2500          *  check cmd against assumed interrupted script command.
2501          *  If dt data phase, the MOVE instruction hasn't bit 4 of 
2502          *  the phase.
2503          */
2504         if (((cmd & 2) ? cmd : (cmd & ~4)) != (scr_to_cpu(vdsp[0]) >> 24)) {
2505                 sym_print_addr(cp->cmd,
2506                         "internal error: cmd=%02x != %02x=(vdsp[0] >> 24)\n",
2507                         cmd, scr_to_cpu(vdsp[0]) >> 24);
2508
2509                 goto reset_all;
2510         }
2511
2512         /*
2513          *  if old phase not dataphase, leave here.
2514          */
2515         if (cmd & 2) {
2516                 sym_print_addr(cp->cmd,
2517                         "phase change %x-%x %d@%08x resid=%d.\n",
2518                         cmd&7, INB(np, nc_sbcl)&7, (unsigned)olen,
2519                         (unsigned)oadr, (unsigned)rest);
2520                 goto unexpected_phase;
2521         }
2522
2523         /*
2524          *  Choose the correct PM save area.
2525          *
2526          *  Look at the PM_SAVE SCRIPT if you want to understand 
2527          *  this stuff. The equivalent code is implemented in 
2528          *  SCRIPTS for the 895A, 896 and 1010 that are able to 
2529          *  handle PM from the SCRIPTS processor.
2530          */
2531         hflags0 = INB(np, HF_PRT);
2532         hflags = hflags0;
2533
2534         if (hflags & (HF_IN_PM0 | HF_IN_PM1 | HF_DP_SAVED)) {
2535                 if (hflags & HF_IN_PM0)
2536                         nxtdsp = scr_to_cpu(cp->phys.pm0.ret);
2537                 else if (hflags & HF_IN_PM1)
2538                         nxtdsp = scr_to_cpu(cp->phys.pm1.ret);
2539
2540                 if (hflags & HF_DP_SAVED)
2541                         hflags ^= HF_ACT_PM;
2542         }
2543
2544         if (!(hflags & HF_ACT_PM)) {
2545                 pm = &cp->phys.pm0;
2546                 newcmd = SCRIPTA_BA(np, pm0_data);
2547         }
2548         else {
2549                 pm = &cp->phys.pm1;
2550                 newcmd = SCRIPTA_BA(np, pm1_data);
2551         }
2552
2553         hflags &= ~(HF_IN_PM0 | HF_IN_PM1 | HF_DP_SAVED);
2554         if (hflags != hflags0)
2555                 OUTB(np, HF_PRT, hflags);
2556
2557         /*
2558          *  fillin the phase mismatch context
2559          */
2560         pm->sg.addr = cpu_to_scr(oadr + olen - rest);
2561         pm->sg.size = cpu_to_scr(rest);
2562         pm->ret     = cpu_to_scr(nxtdsp);
2563
2564         /*
2565          *  If we have a SWIDE,
2566          *  - prepare the address to write the SWIDE from SCRIPTS,
2567          *  - compute the SCRIPTS address to restart from,
2568          *  - move current data pointer context by one byte.
2569          */
2570         nxtdsp = SCRIPTA_BA(np, dispatch);
2571         if ((cmd & 7) == 1 && cp && (cp->phys.select.sel_scntl3 & EWS) &&
2572             (INB(np, nc_scntl2) & WSR)) {
2573                 u32 tmp;
2574
2575                 /*
2576                  *  Set up the table indirect for the MOVE
2577                  *  of the residual byte and adjust the data 
2578                  *  pointer context.
2579                  */
2580                 tmp = scr_to_cpu(pm->sg.addr);
2581                 cp->phys.wresid.addr = cpu_to_scr(tmp);
2582                 pm->sg.addr = cpu_to_scr(tmp + 1);
2583                 tmp = scr_to_cpu(pm->sg.size);
2584                 cp->phys.wresid.size = cpu_to_scr((tmp&0xff000000) | 1);
2585                 pm->sg.size = cpu_to_scr(tmp - 1);
2586
2587                 /*
2588                  *  If only the residual byte is to be moved, 
2589                  *  no PM context is needed.
2590                  */
2591                 if ((tmp&0xffffff) == 1)
2592                         newcmd = pm->ret;
2593
2594                 /*
2595                  *  Prepare the address of SCRIPTS that will 
2596                  *  move the residual byte to memory.
2597                  */
2598                 nxtdsp = SCRIPTB_BA(np, wsr_ma_helper);
2599         }
2600
2601         if (DEBUG_FLAGS & DEBUG_PHASE) {
2602                 sym_print_addr(cp->cmd, "PM %x %x %x / %x %x %x.\n",
2603                         hflags0, hflags, newcmd,
2604                         (unsigned)scr_to_cpu(pm->sg.addr),
2605                         (unsigned)scr_to_cpu(pm->sg.size),
2606                         (unsigned)scr_to_cpu(pm->ret));
2607         }
2608
2609         /*
2610          *  Restart the SCRIPTS processor.
2611          */
2612         sym_set_script_dp (np, cp, newcmd);
2613         OUTL_DSP(np, nxtdsp);
2614         return;
2615
2616         /*
2617          *  Unexpected phase changes that occurs when the current phase 
2618          *  is not a DATA IN or DATA OUT phase are due to error conditions.
2619          *  Such event may only happen when the SCRIPTS is using a 
2620          *  multibyte SCSI MOVE.
2621          *
2622          *  Phase change                Some possible cause
2623          *
2624          *  COMMAND  --> MSG IN SCSI parity error detected by target.
2625          *  COMMAND  --> STATUS Bad command or refused by target.
2626          *  MSG OUT  --> MSG IN     Message rejected by target.
2627          *  MSG OUT  --> COMMAND    Bogus target that discards extended
2628          *                      negotiation messages.
2629          *
2630          *  The code below does not care of the new phase and so 
2631          *  trusts the target. Why to annoy it ?
2632          *  If the interrupted phase is COMMAND phase, we restart at
2633          *  dispatcher.
2634          *  If a target does not get all the messages after selection, 
2635          *  the code assumes blindly that the target discards extended 
2636          *  messages and clears the negotiation status.
2637          *  If the target does not want all our response to negotiation,
2638          *  we force a SIR_NEGO_PROTO interrupt (it is a hack that avoids 
2639          *  bloat for such a should_not_happen situation).
2640          *  In all other situation, we reset the BUS.
2641          *  Are these assumptions reasonnable ? (Wait and see ...)
2642          */
2643 unexpected_phase:
2644         dsp -= 8;
2645         nxtdsp = 0;
2646
2647         switch (cmd & 7) {
2648         case 2: /* COMMAND phase */
2649                 nxtdsp = SCRIPTA_BA(np, dispatch);
2650                 break;
2651 #if 0
2652         case 3: /* STATUS  phase */
2653                 nxtdsp = SCRIPTA_BA(np, dispatch);
2654                 break;
2655 #endif
2656         case 6: /* MSG OUT phase */
2657                 /*
2658                  *  If the device may want to use untagged when we want 
2659                  *  tagged, we prepare an IDENTIFY without disc. granted, 
2660                  *  since we will not be able to handle reselect.
2661                  *  Otherwise, we just don't care.
2662                  */
2663                 if      (dsp == SCRIPTA_BA(np, send_ident)) {
2664                         if (cp->tag != NO_TAG && olen - rest <= 3) {
2665                                 cp->host_status = HS_BUSY;
2666                                 np->msgout[0] = IDENTIFY(0, cp->lun);
2667                                 nxtdsp = SCRIPTB_BA(np, ident_break_atn);
2668                         }
2669                         else
2670                                 nxtdsp = SCRIPTB_BA(np, ident_break);
2671                 }
2672                 else if (dsp == SCRIPTB_BA(np, send_wdtr) ||
2673                          dsp == SCRIPTB_BA(np, send_sdtr) ||
2674                          dsp == SCRIPTB_BA(np, send_ppr)) {
2675                         nxtdsp = SCRIPTB_BA(np, nego_bad_phase);
2676                         if (dsp == SCRIPTB_BA(np, send_ppr)) {
2677                                 struct scsi_device *dev = cp->cmd->device;
2678                                 dev->ppr = 0;
2679                         }
2680                 }
2681                 break;
2682 #if 0
2683         case 7: /* MSG IN  phase */
2684                 nxtdsp = SCRIPTA_BA(np, clrack);
2685                 break;
2686 #endif
2687         }
2688
2689         if (nxtdsp) {
2690                 OUTL_DSP(np, nxtdsp);
2691                 return;
2692         }
2693
2694 reset_all:
2695         sym_start_reset(np);
2696 }
2697
2698 /*
2699  *  chip interrupt handler
2700  *
2701  *  In normal situations, interrupt conditions occur one at 
2702  *  a time. But when something bad happens on the SCSI BUS, 
2703  *  the chip may raise several interrupt flags before 
2704  *  stopping and interrupting the CPU. The additionnal 
2705  *  interrupt flags are stacked in some extra registers 
2706  *  after the SIP and/or DIP flag has been raised in the 
2707  *  ISTAT. After the CPU has read the interrupt condition 
2708  *  flag from SIST or DSTAT, the chip unstacks the other 
2709  *  interrupt flags and sets the corresponding bits in 
2710  *  SIST or DSTAT. Since the chip starts stacking once the 
2711  *  SIP or DIP flag is set, there is a small window of time 
2712  *  where the stacking does not occur.
2713  *
2714  *  Typically, multiple interrupt conditions may happen in 
2715  *  the following situations:
2716  *
2717  *  - SCSI parity error + Phase mismatch  (PAR|MA)
2718  *    When an parity error is detected in input phase 
2719  *    and the device switches to msg-in phase inside a 
2720  *    block MOV.
2721  *  - SCSI parity error + Unexpected disconnect (PAR|UDC)
2722  *    When a stupid device does not want to handle the 
2723  *    recovery of an SCSI parity error.
2724  *  - Some combinations of STO, PAR, UDC, ...
2725  *    When using non compliant SCSI stuff, when user is 
2726  *    doing non compliant hot tampering on the BUS, when 
2727  *    something really bad happens to a device, etc ...
2728  *
2729  *  The heuristic suggested by SYMBIOS to handle 
2730  *  multiple interrupts is to try unstacking all 
2731  *  interrupts conditions and to handle them on some 
2732  *  priority based on error severity.
2733  *  This will work when the unstacking has been 
2734  *  successful, but we cannot be 100 % sure of that, 
2735  *  since the CPU may have been faster to unstack than 
2736  *  the chip is able to stack. Hmmm ... But it seems that 
2737  *  such a situation is very unlikely to happen.
2738  *
2739  *  If this happen, for example STO caught by the CPU 
2740  *  then UDC happenning before the CPU have restarted 
2741  *  the SCRIPTS, the driver may wrongly complete the 
2742  *  same command on UDC, since the SCRIPTS didn't restart 
2743  *  and the DSA still points to the same command.
2744  *  We avoid this situation by setting the DSA to an 
2745  *  invalid value when the CCB is completed and before 
2746  *  restarting the SCRIPTS.
2747  *
2748  *  Another issue is that we need some section of our 
2749  *  recovery procedures to be somehow uninterruptible but 
2750  *  the SCRIPTS processor does not provides such a 
2751  *  feature. For this reason, we handle recovery preferently 
2752  *  from the C code and check against some SCRIPTS critical 
2753  *  sections from the C code.
2754  *
2755  *  Hopefully, the interrupt handling of the driver is now 
2756  *  able to resist to weird BUS error conditions, but donnot 
2757  *  ask me for any guarantee that it will never fail. :-)
2758  *  Use at your own decision and risk.
2759  */
2760
2761 void sym_interrupt (struct sym_hcb *np)
2762 {
2763         u_char  istat, istatc;
2764         u_char  dstat;
2765         u_short sist;
2766
2767         /*
2768          *  interrupt on the fly ?
2769          *  (SCRIPTS may still be running)
2770          *
2771          *  A `dummy read' is needed to ensure that the 
2772          *  clear of the INTF flag reaches the device 
2773          *  and that posted writes are flushed to memory
2774          *  before the scanning of the DONE queue.
2775          *  Note that SCRIPTS also (dummy) read to memory 
2776          *  prior to deliver the INTF interrupt condition.
2777          */
2778         istat = INB(np, nc_istat);
2779         if (istat & INTF) {
2780                 OUTB(np, nc_istat, (istat & SIGP) | INTF | np->istat_sem);
2781                 istat = INB(np, nc_istat);              /* DUMMY READ */
2782                 if (DEBUG_FLAGS & DEBUG_TINY) printf ("F ");
2783                 sym_wakeup_done(np);
2784         }
2785
2786         if (!(istat & (SIP|DIP)))
2787                 return;
2788
2789 #if 0   /* We should never get this one */
2790         if (istat & CABRT)
2791                 OUTB(np, nc_istat, CABRT);
2792 #endif
2793
2794         /*
2795          *  PAR and MA interrupts may occur at the same time,
2796          *  and we need to know of both in order to handle 
2797          *  this situation properly. We try to unstack SCSI 
2798          *  interrupts for that reason. BTW, I dislike a LOT 
2799          *  such a loop inside the interrupt routine.
2800          *  Even if DMA interrupt stacking is very unlikely to 
2801          *  happen, we also try unstacking these ones, since 
2802          *  this has no performance impact.
2803          */
2804         sist    = 0;
2805         dstat   = 0;
2806         istatc  = istat;
2807         do {
2808                 if (istatc & SIP)
2809                         sist  |= INW(np, nc_sist);
2810                 if (istatc & DIP)
2811                         dstat |= INB(np, nc_dstat);
2812                 istatc = INB(np, nc_istat);
2813                 istat |= istatc;
2814         } while (istatc & (SIP|DIP));
2815
2816         if (DEBUG_FLAGS & DEBUG_TINY)
2817                 printf ("<%d|%x:%x|%x:%x>",
2818                         (int)INB(np, nc_scr0),
2819                         dstat,sist,
2820                         (unsigned)INL(np, nc_dsp),
2821                         (unsigned)INL(np, nc_dbc));
2822         /*
2823          *  On paper, a memory read barrier may be needed here to 
2824          *  prevent out of order LOADs by the CPU from having 
2825          *  prefetched stale data prior to DMA having occurred.
2826          *  And since we are paranoid ... :)
2827          */
2828         MEMORY_READ_BARRIER();
2829
2830         /*
2831          *  First, interrupts we want to service cleanly.
2832          *
2833          *  Phase mismatch (MA) is the most frequent interrupt 
2834          *  for chip earlier than the 896 and so we have to service 
2835          *  it as quickly as possible.
2836          *  A SCSI parity error (PAR) may be combined with a phase 
2837          *  mismatch condition (MA).
2838          *  Programmed interrupts (SIR) are used to call the C code 
2839          *  from SCRIPTS.
2840          *  The single step interrupt (SSI) is not used in this 
2841          *  driver.
2842          */
2843         if (!(sist  & (STO|GEN|HTH|SGE|UDC|SBMC|RST)) &&
2844             !(dstat & (MDPE|BF|ABRT|IID))) {
2845                 if      (sist & PAR)    sym_int_par (np, sist);
2846                 else if (sist & MA)     sym_int_ma (np);
2847                 else if (dstat & SIR)   sym_int_sir (np);
2848                 else if (dstat & SSI)   OUTONB_STD();
2849                 else                    goto unknown_int;
2850                 return;
2851         }
2852
2853         /*
2854          *  Now, interrupts that donnot happen in normal 
2855          *  situations and that we may need to recover from.
2856          *
2857          *  On SCSI RESET (RST), we reset everything.
2858          *  On SCSI BUS MODE CHANGE (SBMC), we complete all 
2859          *  active CCBs with RESET status, prepare all devices 
2860          *  for negotiating again and restart the SCRIPTS.
2861          *  On STO and UDC, we complete the CCB with the corres- 
2862          *  ponding status and restart the SCRIPTS.
2863          */
2864         if (sist & RST) {
2865                 printf("%s: SCSI BUS reset detected.\n", sym_name(np));
2866                 sym_start_up (np, 1);
2867                 return;
2868         }
2869
2870         OUTB(np, nc_ctest3, np->rv_ctest3 | CLF);       /* clear dma fifo  */
2871         OUTB(np, nc_stest3, TE|CSF);            /* clear scsi fifo */
2872
2873         if (!(sist  & (GEN|HTH|SGE)) &&
2874             !(dstat & (MDPE|BF|ABRT|IID))) {
2875                 if      (sist & SBMC)   sym_int_sbmc (np);
2876                 else if (sist & STO)    sym_int_sto (np);
2877                 else if (sist & UDC)    sym_int_udc (np);
2878                 else                    goto unknown_int;
2879                 return;
2880         }
2881
2882         /*
2883          *  Now, interrupts we are not able to recover cleanly.
2884          *
2885          *  Log message for hard errors.
2886          *  Reset everything.
2887          */
2888
2889         sym_log_hard_error(np, sist, dstat);
2890
2891         if ((sist & (GEN|HTH|SGE)) ||
2892                 (dstat & (MDPE|BF|ABRT|IID))) {
2893                 sym_start_reset(np);
2894                 return;
2895         }
2896
2897 unknown_int:
2898         /*
2899          *  We just miss the cause of the interrupt. :(
2900          *  Print a message. The timeout will do the real work.
2901          */
2902         printf( "%s: unknown interrupt(s) ignored, "
2903                 "ISTAT=0x%x DSTAT=0x%x SIST=0x%x\n",
2904                 sym_name(np), istat, dstat, sist);
2905 }
2906
2907 /*
2908  *  Dequeue from the START queue all CCBs that match 
2909  *  a given target/lun/task condition (-1 means all),
2910  *  and move them from the BUSY queue to the COMP queue 
2911  *  with DID_SOFT_ERROR status condition.
2912  *  This function is used during error handling/recovery.
2913  *  It is called with SCRIPTS not running.
2914  */
2915 static int 
2916 sym_dequeue_from_squeue(struct sym_hcb *np, int i, int target, int lun, int task)
2917 {
2918         int j;
2919         struct sym_ccb *cp;
2920
2921         /*
2922          *  Make sure the starting index is within range.
2923          */
2924         assert((i >= 0) && (i < 2*MAX_QUEUE));
2925
2926         /*
2927          *  Walk until end of START queue and dequeue every job 
2928          *  that matches the target/lun/task condition.
2929          */
2930         j = i;
2931         while (i != np->squeueput) {
2932                 cp = sym_ccb_from_dsa(np, scr_to_cpu(np->squeue[i]));
2933                 assert(cp);
2934 #ifdef SYM_CONF_IARB_SUPPORT
2935                 /* Forget hints for IARB, they may be no longer relevant */
2936                 cp->host_flags &= ~HF_HINT_IARB;
2937 #endif
2938                 if ((target == -1 || cp->target == target) &&
2939                     (lun    == -1 || cp->lun    == lun)    &&
2940                     (task   == -1 || cp->tag    == task)) {
2941                         sym_set_cam_status(cp->cmd, DID_SOFT_ERROR);
2942                         sym_remque(&cp->link_ccbq);
2943                         sym_insque_tail(&cp->link_ccbq, &np->comp_ccbq);
2944                 }
2945                 else {
2946                         if (i != j)
2947                                 np->squeue[j] = np->squeue[i];
2948                         if ((j += 2) >= MAX_QUEUE*2) j = 0;
2949                 }
2950                 if ((i += 2) >= MAX_QUEUE*2) i = 0;
2951         }
2952         if (i != j)             /* Copy back the idle task if needed */
2953                 np->squeue[j] = np->squeue[i];
2954         np->squeueput = j;      /* Update our current start queue pointer */
2955
2956         return (i - j) / 2;
2957 }
2958
2959 /*
2960  *  chip handler for bad SCSI status condition
2961  *
2962  *  In case of bad SCSI status, we unqueue all the tasks 
2963  *  currently queued to the controller but not yet started 
2964  *  and then restart the SCRIPTS processor immediately.
2965  *
2966  *  QUEUE FULL and BUSY conditions are handled the same way.
2967  *  Basically all the not yet started tasks are requeued in 
2968  *  device queue and the queue is frozen until a completion.
2969  *
2970  *  For CHECK CONDITION and COMMAND TERMINATED status, we use 
2971  *  the CCB of the failed command to prepare a REQUEST SENSE 
2972  *  SCSI command and queue it to the controller queue.
2973  *
2974  *  SCRATCHA is assumed to have been loaded with STARTPOS 
2975  *  before the SCRIPTS called the C code.
2976  */
2977 static void sym_sir_bad_scsi_status(struct sym_hcb *np, int num, struct sym_ccb *cp)
2978 {
2979         u32             startp;
2980         u_char          s_status = cp->ssss_status;
2981         u_char          h_flags  = cp->host_flags;
2982         int             msglen;
2983         int             i;
2984
2985         /*
2986          *  Compute the index of the next job to start from SCRIPTS.
2987          */
2988         i = (INL(np, nc_scratcha) - np->squeue_ba) / 4;
2989
2990         /*
2991          *  The last CCB queued used for IARB hint may be 
2992          *  no longer relevant. Forget it.
2993          */
2994 #ifdef SYM_CONF_IARB_SUPPORT
2995         if (np->last_cp)
2996                 np->last_cp = 0;
2997 #endif
2998
2999         /*
3000          *  Now deal with the SCSI status.
3001          */
3002         switch(s_status) {
3003         case S_BUSY:
3004         case S_QUEUE_FULL:
3005                 if (sym_verbose >= 2) {
3006                         sym_print_addr(cp->cmd, "%s\n",
3007                                 s_status == S_BUSY ? "BUSY" : "QUEUE FULL\n");
3008                 }
3009         default:        /* S_INT, S_INT_COND_MET, S_CONFLICT */
3010                 sym_complete_error (np, cp);
3011                 break;
3012         case S_TERMINATED:
3013         case S_CHECK_COND:
3014                 /*
3015                  *  If we get an SCSI error when requesting sense, give up.
3016                  */
3017                 if (h_flags & HF_SENSE) {
3018                         sym_complete_error (np, cp);
3019                         break;
3020                 }
3021
3022                 /*
3023                  *  Dequeue all queued CCBs for that device not yet started,
3024                  *  and restart the SCRIPTS processor immediately.
3025                  */
3026                 sym_dequeue_from_squeue(np, i, cp->target, cp->lun, -1);
3027                 OUTL_DSP(np, SCRIPTA_BA(np, start));
3028
3029                 /*
3030                  *  Save some info of the actual IO.
3031                  *  Compute the data residual.
3032                  */
3033                 cp->sv_scsi_status = cp->ssss_status;
3034                 cp->sv_xerr_status = cp->xerr_status;
3035                 cp->sv_resid = sym_compute_residual(np, cp);
3036
3037                 /*
3038                  *  Prepare all needed data structures for 
3039                  *  requesting sense data.
3040                  */
3041
3042                 cp->scsi_smsg2[0] = IDENTIFY(0, cp->lun);
3043                 msglen = 1;
3044
3045                 /*
3046                  *  If we are currently using anything different from 
3047                  *  async. 8 bit data transfers with that target,
3048                  *  start a negotiation, since the device may want 
3049                  *  to report us a UNIT ATTENTION condition due to 
3050                  *  a cause we currently ignore, and we donnot want 
3051                  *  to be stuck with WIDE and/or SYNC data transfer.
3052                  *
3053                  *  cp->nego_status is filled by sym_prepare_nego().
3054                  */
3055                 cp->nego_status = 0;
3056                 msglen += sym_prepare_nego(np, cp, &cp->scsi_smsg2[msglen]);
3057                 /*
3058                  *  Message table indirect structure.
3059                  */
3060                 cp->phys.smsg.addr      = CCB_BA(cp, scsi_smsg2);
3061                 cp->phys.smsg.size      = cpu_to_scr(msglen);
3062
3063                 /*
3064                  *  sense command
3065                  */
3066                 cp->phys.cmd.addr       = CCB_BA(cp, sensecmd);
3067                 cp->phys.cmd.size       = cpu_to_scr(6);
3068
3069                 /*
3070                  *  patch requested size into sense command
3071                  */
3072                 cp->sensecmd[0]         = REQUEST_SENSE;
3073                 cp->sensecmd[1]         = 0;
3074                 if (cp->cmd->device->scsi_level <= SCSI_2 && cp->lun <= 7)
3075                         cp->sensecmd[1] = cp->lun << 5;
3076                 cp->sensecmd[4]         = SYM_SNS_BBUF_LEN;
3077                 cp->data_len            = SYM_SNS_BBUF_LEN;
3078
3079                 /*
3080                  *  sense data
3081                  */
3082                 memset(cp->sns_bbuf, 0, SYM_SNS_BBUF_LEN);
3083                 cp->phys.sense.addr     = CCB_BA(cp, sns_bbuf);
3084                 cp->phys.sense.size     = cpu_to_scr(SYM_SNS_BBUF_LEN);
3085
3086                 /*
3087                  *  requeue the command.
3088                  */
3089                 startp = SCRIPTB_BA(np, sdata_in);
3090
3091                 cp->phys.head.savep     = cpu_to_scr(startp);
3092                 cp->phys.head.lastp     = cpu_to_scr(startp);
3093                 cp->startp              = cpu_to_scr(startp);
3094                 cp->goalp               = cpu_to_scr(startp + 16);
3095
3096                 cp->host_xflags = 0;
3097                 cp->host_status = cp->nego_status ? HS_NEGOTIATE : HS_BUSY;
3098                 cp->ssss_status = S_ILLEGAL;
3099                 cp->host_flags  = (HF_SENSE|HF_DATA_IN);
3100                 cp->xerr_status = 0;
3101                 cp->extra_bytes = 0;
3102
3103                 cp->phys.head.go.start = cpu_to_scr(SCRIPTA_BA(np, select));
3104
3105                 /*
3106                  *  Requeue the command.
3107                  */
3108                 sym_put_start_queue(np, cp);
3109
3110                 /*
3111                  *  Give back to upper layer everything we have dequeued.
3112                  */
3113                 sym_flush_comp_queue(np, 0);
3114                 break;
3115         }
3116 }
3117
3118 /*
3119  *  After a device has accepted some management message 
3120  *  as BUS DEVICE RESET, ABORT TASK, etc ..., or when 
3121  *  a device signals a UNIT ATTENTION condition, some 
3122  *  tasks are thrown away by the device. We are required 
3123  *  to reflect that on our tasks list since the device 
3124  *  will never complete these tasks.
3125  *
3126  *  This function move from the BUSY queue to the COMP 
3127  *  queue all disconnected CCBs for a given target that 
3128  *  match the following criteria:
3129  *  - lun=-1  means any logical UNIT otherwise a given one.
3130  *  - task=-1 means any task, otherwise a given one.
3131  */
3132 int sym_clear_tasks(struct sym_hcb *np, int cam_status, int target, int lun, int task)
3133 {
3134         SYM_QUEHEAD qtmp, *qp;
3135         int i = 0;
3136         struct sym_ccb *cp;
3137
3138         /*
3139          *  Move the entire BUSY queue to our temporary queue.
3140          */
3141         sym_que_init(&qtmp);
3142         sym_que_splice(&np->busy_ccbq, &qtmp);
3143         sym_que_init(&np->busy_ccbq);
3144
3145         /*
3146          *  Put all CCBs that matches our criteria into 
3147          *  the COMP queue and put back other ones into 
3148          *  the BUSY queue.
3149          */
3150         while ((qp = sym_remque_head(&qtmp)) != 0) {
3151                 struct scsi_cmnd *cmd;
3152                 cp = sym_que_entry(qp, struct sym_ccb, link_ccbq);
3153                 cmd = cp->cmd;
3154                 if (cp->host_status != HS_DISCONNECT ||
3155                     cp->target != target             ||
3156                     (lun  != -1 && cp->lun != lun)   ||
3157                     (task != -1 && 
3158                         (cp->tag != NO_TAG && cp->scsi_smsg[2] != task))) {
3159                         sym_insque_tail(&cp->link_ccbq, &np->busy_ccbq);
3160                         continue;
3161                 }
3162                 sym_insque_tail(&cp->link_ccbq, &np->comp_ccbq);
3163
3164                 /* Preserve the software timeout condition */
3165                 if (sym_get_cam_status(cmd) != DID_TIME_OUT)
3166                         sym_set_cam_status(cmd, cam_status);
3167                 ++i;
3168 #if 0