?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge with Linux 2.5.74.
[linux-2.6/linux-mips.git] / drivers / scsi / ncr53c8xx.c
blob90a7183e350ff11832858ece70183b20ad25d90d
1 /******************************************************************************
2 ** Device driver for the PCI-SCSI NCR538XX controller family.
3 **
4 ** Copyright (C) 1994 Wolfgang Stanglmeier
5 **
6 ** This program is free software; you can redistribute it and/or modify
7 ** it under the terms of the GNU General Public License as published by
8 ** the Free Software Foundation; either version 2 of the License, or
9 ** (at your option) any later version.
10 **
11 ** This program is distributed in the hope that it will be useful,
12 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 ** GNU General Public License for more details.
15 **
16 ** You should have received a copy of the GNU General Public License
17 ** along with this program; if not, write to the Free Software
18 ** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 **
20 **-----------------------------------------------------------------------------
21 **
22 ** This driver has been ported to Linux from the FreeBSD NCR53C8XX driver
23 ** and is currently maintained by
24 **
25 ** Gerard Roudier <groudier@free.fr>
26 **
27 ** Being given that this driver originates from the FreeBSD version, and
28 ** in order to keep synergy on both, any suggested enhancements and corrections
29 ** received on Linux are automatically a potential candidate for the FreeBSD
30 ** version.
31 **
32 ** The original driver has been written for 386bsd and FreeBSD by
33 ** Wolfgang Stanglmeier <wolf@cologne.de>
34 ** Stefan Esser <se@mi.Uni-Koeln.de>
35 **
36 ** And has been ported to NetBSD by
37 ** Charles M. Hannum <mycroft@gnu.ai.mit.edu>
38 **
39 **-----------------------------------------------------------------------------
40 **
41 ** Brief history
42 **
43 ** December 10 1995 by Gerard Roudier:
44 ** Initial port to Linux.
45 **
46 ** June 23 1996 by Gerard Roudier:
47 ** Support for 64 bits architectures (Alpha).
48 **
49 ** November 30 1996 by Gerard Roudier:
50 ** Support for Fast-20 scsi.
51 ** Support for large DMA fifo and 128 dwords bursting.
52 **
53 ** February 27 1997 by Gerard Roudier:
54 ** Support for Fast-40 scsi.
55 ** Support for on-Board RAM.
56 **
57 ** May 3 1997 by Gerard Roudier:
58 ** Full support for scsi scripts instructions pre-fetching.
59 **
60 ** May 19 1997 by Richard Waltham <dormouse@farsrobt.demon.co.uk>:
61 ** Support for NvRAM detection and reading.
62 **
63 ** August 18 1997 by Cort <cort@cs.nmt.edu>:
64 ** Support for Power/PC (Big Endian).
65 **
66 ** June 20 1998 by Gerard Roudier
67 ** Support for up to 64 tags per lun.
68 ** O(1) everywhere (C and SCRIPTS) for normal cases.
69 ** Low PCI traffic for command handling when on-chip RAM is present.
70 ** Aggressive SCSI SCRIPTS optimizations.
71 **
72 *******************************************************************************
73 */
74
75 /*
76 ** Supported SCSI-II features:
77 ** Synchronous negotiation
78 ** Wide negotiation (depends on the NCR Chip)
79 ** Enable disconnection
80 ** Tagged command queuing
81 ** Parity checking
82 ** Etc...
83 **
84 ** Supported NCR/SYMBIOS chips:
85 ** 53C720 (Wide, Fast SCSI-2, intfly problems)
86 ** 53C810 (8 bits, Fast SCSI-2, no rom BIOS)
87 ** 53C815 (8 bits, Fast SCSI-2, on board rom BIOS)
88 ** 53C820 (Wide, Fast SCSI-2, no rom BIOS)
89 ** 53C825 (Wide, Fast SCSI-2, on board rom BIOS)
90 ** 53C860 (8 bits, Fast 20, no rom BIOS)
91 ** 53C875 (Wide, Fast 20, on board rom BIOS)
92 ** 53C895 (Wide, Fast 40, on board rom BIOS)
93 ** 53C895A (Wide, Fast 40, on board rom BIOS)
94 ** 53C896 (Wide, Fast 40, on board rom BIOS)
95 ** 53C897 (Wide, Fast 40, on board rom BIOS)
96 ** 53C1510D (Wide, Fast 40, on board rom BIOS)
97 **
98 ** Other features:
99 ** Memory mapped IO (linux-1.3.X and above only)
100 ** Module
101 ** Shared IRQ (since linux-1.3.72)
102 */
103
104 /*
105 ** Name and version of the driver
106 */
107 #define SCSI_NCR_DRIVER_NAME "ncr53c8xx-3.4.3b-20010512"
108
109 #define SCSI_NCR_DEBUG_FLAGS (0)
110
111 /*==========================================================
112 **
113 ** Include files
114 **
115 **==========================================================
116 */
117
118 #include <linux/version.h>
119
120 #include <linux/module.h>
121 #include <asm/dma.h>
122 #include <asm/io.h>
123 #include <asm/system.h>
124 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,17)
125 #include <linux/spinlock.h>
126 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,93)
127 #include <asm/spinlock.h>
128 #endif
129 #include <linux/delay.h>
130 #include <linux/signal.h>
131 #include <linux/sched.h>
132 #include <linux/errno.h>
133 #include <linux/pci.h>
134 #include <linux/dma-mapping.h>
135 #include <linux/interrupt.h>
136 #include <linux/string.h>
137 #include <linux/mm.h>
138 #include <linux/ioport.h>
139 #include <linux/time.h>
140 #include <linux/timer.h>
141 #include <linux/stat.h>
142
143 #include <linux/blk.h>
144
145 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,35)
146 #include <linux/init.h>
147 #endif
148
149 #ifndef __init
150 #define __init
151 #endif
152 #ifndef __initdata
153 #define __initdata
154 #endif
155
156 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,1,92)
157 #include <linux/bios32.h>
158 #endif
159
160 #include "scsi.h"
161 #include "hosts.h"
162
163 #include <linux/types.h>
164
165 /*
166 ** Define BITS_PER_LONG for earlier linux versions.
167 */
168 #ifndef BITS_PER_LONG
169 #if (~0UL) == 0xffffffffUL
170 #define BITS_PER_LONG 32
171 #else
172 #define BITS_PER_LONG 64
173 #endif
174 #endif
175
176 #include "ncr53c8xx.h"
177
178 /*
179 ** Donnot compile integrity checking code for Linux-2.3.0
180 ** and above since SCSI data structures are not ready yet.
181 */
182 /* #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0) */
183 #if 0
184 #define SCSI_NCR_INTEGRITY_CHECKING
185 #endif
186
187 #define NAME53C "ncr53c"
188 #define NAME53C8XX "ncr53c8xx"
189 #define DRIVER_SMP_LOCK ncr53c8xx_lock
190
191 #include "sym53c8xx_comm.h"
192
193 int ncr53c8xx_slave_configure(Scsi_Device *device);
194 int ncr53c8xx_bus_reset(Scsi_Cmnd *cmd);
195 int ncr53c8xx_queue_command (Scsi_Cmnd *cmd, void (* done)(Scsi_Cmnd *));
196 const char *ncr53c8xx_info (struct Scsi_Host *host);
197
198
199 /*==========================================================
200 **
201 ** The CCB done queue uses an array of CCB virtual
202 ** addresses. Empty entries are flagged using the bogus
203 ** virtual address 0xffffffff.
204 **
205 ** Since PCI ensures that only aligned DWORDs are accessed
206 ** atomically, 64 bit little-endian architecture requires
207 ** to test the high order DWORD of the entry to determine
208 ** if it is empty or valid.
209 **
210 ** BTW, I will make things differently as soon as I will
211 ** have a better idea, but this is simple and should work.
212 **
213 **==========================================================
214 */
215
216 #define SCSI_NCR_CCB_DONE_SUPPORT
217 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
218
219 #define MAX_DONE 24
220 #define CCB_DONE_EMPTY 0xffffffffUL
221
222 /* All 32 bit architectures */
223 #if BITS_PER_LONG == 32
224 #define CCB_DONE_VALID(cp) (((u_long) cp) != CCB_DONE_EMPTY)
225
226 /* All > 32 bit (64 bit) architectures regardless endian-ness */
227 #else
228 #define CCB_DONE_VALID(cp) \
229 ((((u_long) cp) & 0xffffffff00000000ul) && \
230 (((u_long) cp) & 0xfffffffful) != CCB_DONE_EMPTY)
231 #endif
232
233 #endif /* SCSI_NCR_CCB_DONE_SUPPORT */
234
235 /*==========================================================
236 **
237 ** Configuration and Debugging
238 **
239 **==========================================================
240 */
241
242 /*
243 ** SCSI address of this device.
244 ** The boot routines should have set it.
245 ** If not, use this.
246 */
247
248 #ifndef SCSI_NCR_MYADDR
249 #define SCSI_NCR_MYADDR (7)
250 #endif
251
252 /*
253 ** The maximum number of tags per logic unit.
254 ** Used only for disk devices that support tags.
255 */
256
257 #ifndef SCSI_NCR_MAX_TAGS
258 #define SCSI_NCR_MAX_TAGS (8)
259 #endif
260
261 /*
262 ** TAGS are actually limited to 64 tags/lun.
263 ** We need to deal with power of 2, for alignment constraints.
264 */
265 #if SCSI_NCR_MAX_TAGS > 64
266 #define MAX_TAGS (64)
267 #else
268 #define MAX_TAGS SCSI_NCR_MAX_TAGS
269 #endif
270
271 #define NO_TAG (255)
272
273 /*
274 ** Choose appropriate type for tag bitmap.
275 */
276 #if MAX_TAGS > 32
277 typedef u_int64 tagmap_t;
278 #else
279 typedef u_int32 tagmap_t;
280 #endif
281
282 /*
283 ** Number of targets supported by the driver.
284 ** n permits target numbers 0..n-1.
285 ** Default is 16, meaning targets #0..#15.
286 ** #7 .. is myself.
287 */
288
289 #ifdef SCSI_NCR_MAX_TARGET
290 #define MAX_TARGET (SCSI_NCR_MAX_TARGET)
291 #else
292 #define MAX_TARGET (16)
293 #endif
294
295 /*
296 ** Number of logic units supported by the driver.
297 ** n enables logic unit numbers 0..n-1.
298 ** The common SCSI devices require only
299 ** one lun, so take 1 as the default.
300 */
301
302 #ifdef SCSI_NCR_MAX_LUN
303 #define MAX_LUN SCSI_NCR_MAX_LUN
304 #else
305 #define MAX_LUN (1)
306 #endif
307
308 /*
309 ** Asynchronous pre-scaler (ns). Shall be 40
310 */
311
312 #ifndef SCSI_NCR_MIN_ASYNC
313 #define SCSI_NCR_MIN_ASYNC (40)
314 #endif
315
316 /*
317 ** The maximum number of jobs scheduled for starting.
318 ** There should be one slot per target, and one slot
319 ** for each tag of each target in use.
320 ** The calculation below is actually quite silly ...
321 */
322
323 #ifdef SCSI_NCR_CAN_QUEUE
324 #define MAX_START (SCSI_NCR_CAN_QUEUE + 4)
325 #else
326 #define MAX_START (MAX_TARGET + 7 * MAX_TAGS)
327 #endif
328
329 /*
330 ** We limit the max number of pending IO to 250.
331 ** since we donnot want to allocate more than 1
332 ** PAGE for 'scripth'.
333 */
334 #if MAX_START > 250
335 #undef MAX_START
336 #define MAX_START 250
337 #endif
338
339 /*
340 ** The maximum number of segments a transfer is split into.
341 ** We support up to 127 segments for both read and write.
342 ** The data scripts are broken into 2 sub-scripts.
343 ** 80 (MAX_SCATTERL) segments are moved from a sub-script
344 ** in on-chip RAM. This makes data transfers shorter than
345 ** 80k (assuming 1k fs) as fast as possible.
346 */
347
348 #define MAX_SCATTER (SCSI_NCR_MAX_SCATTER)
349
350 #if (MAX_SCATTER > 80)
351 #define MAX_SCATTERL 80
352 #define MAX_SCATTERH (MAX_SCATTER - MAX_SCATTERL)
353 #else
354 #define MAX_SCATTERL (MAX_SCATTER-1)
355 #define MAX_SCATTERH 1
356 #endif
357
358 /*
359 ** other
360 */
361
362 #define NCR_SNOOP_TIMEOUT (1000000)
363
364 /*
365 ** Head of list of NCR boards
366 **
367 ** For kernel version < 1.3.70, host is retrieved by its irq level.
368 ** For later kernels, the internal host control block address
369 ** (struct ncb) is used as device id parameter of the irq stuff.
370 */
371
372 static struct Scsi_Host *first_host = NULL;
373 static Scsi_Host_Template *the_template = NULL;
374
375 /*
376 ** Other definitions
377 */
378
379 #define ScsiResult(host_code, scsi_code) (((host_code) << 16) + ((scsi_code) & 0x7f))
380
381 static void ncr53c8xx_timeout(unsigned long np);
382 static int ncr53c8xx_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
383 int length, int func);
384
385 #define initverbose (driver_setup.verbose)
386 #define bootverbose (np->verbose)
387
388 #ifdef SCSI_NCR_NVRAM_SUPPORT
389 static u_char Tekram_sync[16] __initdata =
390 {25,31,37,43, 50,62,75,125, 12,15,18,21, 6,7,9,10};
391 #endif /* SCSI_NCR_NVRAM_SUPPORT */
392
393 /*==========================================================
394 **
395 ** Command control block states.
396 **
397 **==========================================================
398 */
399
400 #define HS_IDLE (0)
401 #define HS_BUSY (1)
402 #define HS_NEGOTIATE (2) /* sync/wide data transfer*/
403 #define HS_DISCONNECT (3) /* Disconnected by target */
404
405 #define HS_DONEMASK (0x80)
406 #define HS_COMPLETE (4|HS_DONEMASK)
407 #define HS_SEL_TIMEOUT (5|HS_DONEMASK) /* Selection timeout */
408 #define HS_RESET (6|HS_DONEMASK) /* SCSI reset */
409 #define HS_ABORTED (7|HS_DONEMASK) /* Transfer aborted */
410 #define HS_TIMEOUT (8|HS_DONEMASK) /* Software timeout */
411 #define HS_FAIL (9|HS_DONEMASK) /* SCSI or PCI bus errors */
412 #define HS_UNEXPECTED (10|HS_DONEMASK)/* Unexpected disconnect */
413
414 /*
415 ** Invalid host status values used by the SCRIPTS processor
416 ** when the nexus is not fully identified.
417 ** Shall never appear in a CCB.
418 */
419
420 #define HS_INVALMASK (0x40)
421 #define HS_SELECTING (0|HS_INVALMASK)
422 #define HS_IN_RESELECT (1|HS_INVALMASK)
423 #define HS_STARTING (2|HS_INVALMASK)
424
425 /*
426 ** Flags set by the SCRIPT processor for commands
427 ** that have been skipped.
428 */
429 #define HS_SKIPMASK (0x20)
430
431 /*==========================================================
432 **
433 ** Software Interrupt Codes
434 **
435 **==========================================================
436 */
437
438 #define SIR_BAD_STATUS (1)
439 #define SIR_XXXXXXXXXX (2)
440 #define SIR_NEGO_SYNC (3)
441 #define SIR_NEGO_WIDE (4)
442 #define SIR_NEGO_FAILED (5)
443 #define SIR_NEGO_PROTO (6)
444 #define SIR_REJECT_RECEIVED (7)
445 #define SIR_REJECT_SENT (8)
446 #define SIR_IGN_RESIDUE (9)
447 #define SIR_MISSING_SAVE (10)
448 #define SIR_RESEL_NO_MSG_IN (11)
449 #define SIR_RESEL_NO_IDENTIFY (12)
450 #define SIR_RESEL_BAD_LUN (13)
451 #define SIR_RESEL_BAD_TARGET (14)
452 #define SIR_RESEL_BAD_I_T_L (15)
453 #define SIR_RESEL_BAD_I_T_L_Q (16)
454 #define SIR_DONE_OVERFLOW (17)
455 #define SIR_INTFLY (18)
456 #define SIR_MAX (18)
457
458 /*==========================================================
459 **
460 ** Extended error codes.
461 ** xerr_status field of struct ccb.
462 **
463 **==========================================================
464 */
465
466 #define XE_OK (0)
467 #define XE_EXTRA_DATA (1) /* unexpected data phase */
468 #define XE_BAD_PHASE (2) /* illegal phase (4/5) */
469
470 /*==========================================================
471 **
472 ** Negotiation status.
473 ** nego_status field of struct ccb.
474 **
475 **==========================================================
476 */
477
478 #define NS_NOCHANGE (0)
479 #define NS_SYNC (1)
480 #define NS_WIDE (2)
481 #define NS_PPR (4)
482
483 /*==========================================================
484 **
485 ** "Special features" of targets.
486 ** quirks field of struct tcb.
487 ** actualquirks field of struct ccb.
488 **
489 **==========================================================
490 */
491
492 #define QUIRK_AUTOSAVE (0x01)
493 #define QUIRK_NOMSG (0x02)
494 #define QUIRK_NOSYNC (0x10)
495 #define QUIRK_NOWIDE16 (0x20)
496
497 /*==========================================================
498 **
499 ** Capability bits in Inquire response byte 7.
500 **
501 **==========================================================
502 */
503
504 #define INQ7_QUEUE (0x02)
505 #define INQ7_SYNC (0x10)
506 #define INQ7_WIDE16 (0x20)
507
508 /*==========================================================
509 **
510 ** Misc.
511 **
512 **==========================================================
513 */
514
515 #define CCB_MAGIC (0xf2691ad2)
516
517 /*==========================================================
518 **
519 ** Declaration of structs.
520 **
521 **==========================================================
522 */
523
524 struct tcb;
525 struct lcb;
526 struct ccb;
527 struct ncb;
528 struct script;
529
530 typedef struct ncb * ncb_p;
531 typedef struct tcb * tcb_p;
532 typedef struct lcb * lcb_p;
533 typedef struct ccb * ccb_p;
534
535 struct link {
536 ncrcmd l_cmd;
537 ncrcmd l_paddr;
538 };
539
540 struct usrcmd {
541 u_long target;
542 u_long lun;
543 u_long data;
544 u_long cmd;
545 };
546
547 #define UC_SETSYNC 10
548 #define UC_SETTAGS 11
549 #define UC_SETDEBUG 12
550 #define UC_SETORDER 13
551 #define UC_SETWIDE 14
552 #define UC_SETFLAG 15
553 #define UC_SETVERBOSE 17
554
555 #define UF_TRACE (0x01)
556 #define UF_NODISC (0x02)
557 #define UF_NOSCAN (0x04)
558
559 /*========================================================================
560 **
561 ** Declaration of structs: target control block
562 **
563 **========================================================================
564 */
565 struct tcb {
566 /*----------------------------------------------------------------
567 ** During reselection the ncr jumps to this point with SFBR
568 ** set to the encoded target number with bit 7 set.
569 ** if it's not this target, jump to the next.
570 **
571 ** JUMP IF (SFBR != #target#), @(next tcb)
572 **----------------------------------------------------------------
573 */
574 struct link jump_tcb;
575
576 /*----------------------------------------------------------------
577 ** Load the actual values for the sxfer and the scntl3
578 ** register (sync/wide mode).
579 **
580 ** SCR_COPY (1), @(sval field of this tcb), @(sxfer register)
581 ** SCR_COPY (1), @(wval field of this tcb), @(scntl3 register)
582 **----------------------------------------------------------------
583 */
584 ncrcmd getscr[6];
585
586 /*----------------------------------------------------------------
587 ** Get the IDENTIFY message and load the LUN to SFBR.
588 **
589 ** CALL, <RESEL_LUN>
590 **----------------------------------------------------------------
591 */
592 struct link call_lun;
593
594 /*----------------------------------------------------------------
595 ** Now look for the right lun.
596 **
597 ** For i = 0 to 3
598 ** SCR_JUMP ^ IFTRUE(MASK(i, 3)), @(first lcb mod. i)
599 **
600 ** Recent chips will prefetch the 4 JUMPS using only 1 burst.
601 ** It is kind of hashcoding.
602 **----------------------------------------------------------------
603 */
604 struct link jump_lcb[4]; /* JUMPs for reselection */
605 lcb_p lp[MAX_LUN]; /* The lcb's of this tcb */
606 u_char inq_done; /* Target capabilities received */
607 u_char inq_byte7; /* Contains these capabilities */
608
609 /*----------------------------------------------------------------
610 ** Pointer to the ccb used for negotiation.
611 ** Prevent from starting a negotiation for all queued commands
612 ** when tagged command queuing is enabled.
613 **----------------------------------------------------------------
614 */
615 ccb_p nego_cp;
616
617 /*----------------------------------------------------------------
618 ** statistical data
619 **----------------------------------------------------------------
620 */
621 u_long transfers;
622 u_long bytes;
623
624 /*----------------------------------------------------------------
625 ** negotiation of wide and synch transfer and device quirks.
626 **----------------------------------------------------------------
627 */
628 #ifdef SCSI_NCR_BIG_ENDIAN
629 /*0*/ u_short period;
630 /*2*/ u_char sval;
631 /*3*/ u_char minsync;
632 /*0*/ u_char wval;
633 /*1*/ u_char widedone;
634 /*2*/ u_char quirks;
635 /*3*/ u_char maxoffs;
636 #else
637 /*0*/ u_char minsync;
638 /*1*/ u_char sval;
639 /*2*/ u_short period;
640 /*0*/ u_char maxoffs;
641 /*1*/ u_char quirks;
642 /*2*/ u_char widedone;
643 /*3*/ u_char wval;
644 #endif
645
646 #ifdef SCSI_NCR_INTEGRITY_CHECKING
647 u_char ic_min_sync;
648 u_char ic_max_width;
649 u_char ic_maximums_set;
650 u_char ic_done;
651 #endif
652
653 /*----------------------------------------------------------------
654 ** User settable limits and options.
655 ** These limits are read from the NVRAM if present.
656 **----------------------------------------------------------------
657 */
658 u_char usrsync;
659 u_char usrwide;
660 u_char usrtags;
661 u_char usrflag;
662 };
663
664 /*========================================================================
665 **
666 ** Declaration of structs: lun control block
667 **
668 **========================================================================
669 */
670 struct lcb {
671 /*----------------------------------------------------------------
672 ** During reselection the ncr jumps to this point
673 ** with SFBR set to the "Identify" message.
674 ** if it's not this lun, jump to the next.
675 **
676 ** JUMP IF (SFBR != #lun#), @(next lcb of this target)
677 **
678 ** It is this lun. Load TEMP with the nexus jumps table
679 ** address and jump to RESEL_TAG (or RESEL_NOTAG).
680 **
681 ** SCR_COPY (4), p_jump_ccb, TEMP,
682 ** SCR_JUMP, <RESEL_TAG>
683 **----------------------------------------------------------------
684 */
685 struct link jump_lcb;
686 ncrcmd load_jump_ccb[3];
687 struct link jump_tag;
688 ncrcmd p_jump_ccb; /* Jump table bus address */
689
690 /*----------------------------------------------------------------
691 ** Jump table used by the script processor to directly jump
692 ** to the CCB corresponding to the reselected nexus.
693 ** Address is allocated on 256 bytes boundary in order to
694 ** allow 8 bit calculation of the tag jump entry for up to
695 ** 64 possible tags.
696 **----------------------------------------------------------------
697 */
698 u_int32 jump_ccb_0; /* Default table if no tags */
699 u_int32 *jump_ccb; /* Virtual address */
700
701 /*----------------------------------------------------------------
702 ** CCB queue management.
703 **----------------------------------------------------------------
704 */
705 XPT_QUEHEAD free_ccbq; /* Queue of available CCBs */
706 XPT_QUEHEAD busy_ccbq; /* Queue of busy CCBs */
707 XPT_QUEHEAD wait_ccbq; /* Queue of waiting for IO CCBs */
708 XPT_QUEHEAD skip_ccbq; /* Queue of skipped CCBs */
709 u_char actccbs; /* Number of allocated CCBs */
710 u_char busyccbs; /* CCBs busy for this lun */
711 u_char queuedccbs; /* CCBs queued to the controller*/
712 u_char queuedepth; /* Queue depth for this lun */
713 u_char scdev_depth; /* SCSI device queue depth */
714 u_char maxnxs; /* Max possible nexuses */
715
716 /*----------------------------------------------------------------
717 ** Control of tagged command queuing.
718 ** Tags allocation is performed using a circular buffer.
719 ** This avoids using a loop for tag allocation.
720 **----------------------------------------------------------------
721 */
722 u_char ia_tag; /* Allocation index */
723 u_char if_tag; /* Freeing index */
724 u_char cb_tags[MAX_TAGS]; /* Circular tags buffer */
725 u_char usetags; /* Command queuing is active */
726 u_char maxtags; /* Max nr of tags asked by user */
727 u_char numtags; /* Current number of tags */
728 u_char inq_byte7; /* Store unit CmdQ capabitility */
729
730 /*----------------------------------------------------------------
731 ** QUEUE FULL control and ORDERED tag control.
732 **----------------------------------------------------------------
733 */
734 /*----------------------------------------------------------------
735 ** QUEUE FULL and ORDERED tag control.
736 **----------------------------------------------------------------
737 */
738 u_short num_good; /* Nr of GOOD since QUEUE FULL */
739 tagmap_t tags_umap; /* Used tags bitmap */
740 tagmap_t tags_smap; /* Tags in use at 'tag_stime' */
741 u_long tags_stime; /* Last time we set smap=umap */
742 ccb_p held_ccb; /* CCB held for QUEUE FULL */
743 };
744
745 /*========================================================================
746 **
747 ** Declaration of structs: the launch script.
748 **
749 **========================================================================
750 **
751 ** It is part of the CCB and is called by the scripts processor to
752 ** start or restart the data structure (nexus).
753 ** This 6 DWORDs mini script makes use of prefetching.
754 **
755 **------------------------------------------------------------------------
756 */
757 struct launch {
758 /*----------------------------------------------------------------
759 ** SCR_COPY(4), @(p_phys), @(dsa register)
760 ** SCR_JUMP, @(scheduler_point)
761 **----------------------------------------------------------------
762 */
763 ncrcmd setup_dsa[3]; /* Copy 'phys' address to dsa */
764 struct link schedule; /* Jump to scheduler point */
765 ncrcmd p_phys; /* 'phys' header bus address */
766 };
767
768 /*========================================================================
769 **
770 ** Declaration of structs: global HEADER.
771 **
772 **========================================================================
773 **
774 ** This substructure is copied from the ccb to a global address after
775 ** selection (or reselection) and copied back before disconnect.
776 **
777 ** These fields are accessible to the script processor.
778 **
779 **------------------------------------------------------------------------
780 */
781
782 struct head {
783 /*----------------------------------------------------------------
784 ** Saved data pointer.
785 ** Points to the position in the script responsible for the
786 ** actual transfer transfer of data.
787 ** It's written after reception of a SAVE_DATA_POINTER message.
788 ** The goalpointer points after the last transfer command.
789 **----------------------------------------------------------------
790 */
791 u_int32 savep;
792 u_int32 lastp;
793 u_int32 goalp;
794
795 /*----------------------------------------------------------------
796 ** Alternate data pointer.
797 ** They are copied back to savep/lastp/goalp by the SCRIPTS
798 ** when the direction is unknown and the device claims data out.
799 **----------------------------------------------------------------
800 */
801 u_int32 wlastp;
802 u_int32 wgoalp;
803
804 /*----------------------------------------------------------------
805 ** The virtual address of the ccb containing this header.
806 **----------------------------------------------------------------
807 */
808 ccb_p cp;
809
810 /*----------------------------------------------------------------
811 ** Status fields.
812 **----------------------------------------------------------------
813 */
814 u_char scr_st[4]; /* script status */
815 u_char status[4]; /* host status. must be the */
816 /* last DWORD of the header. */
817 };
818
819 /*
820 ** The status bytes are used by the host and the script processor.
821 **
822 ** The byte corresponding to the host_status must be stored in the
823 ** last DWORD of the CCB header since it is used for command
824 ** completion (ncr_wakeup()). Doing so, we are sure that the header
825 ** has been entirely copied back to the CCB when the host_status is
826 ** seen complete by the CPU.
827 **
828 ** The last four bytes (status[4]) are copied to the scratchb register
829 ** (declared as scr0..scr3 in ncr_reg.h) just after the select/reselect,
830 ** and copied back just after disconnecting.
831 ** Inside the script the XX_REG are used.
832 **
833 ** The first four bytes (scr_st[4]) are used inside the script by
834 ** "COPY" commands.
835 ** Because source and destination must have the same alignment
836 ** in a DWORD, the fields HAVE to be at the choosen offsets.
837 ** xerr_st 0 (0x34) scratcha
838 ** sync_st 1 (0x05) sxfer
839 ** wide_st 3 (0x03) scntl3
840 */
841
842 /*
843 ** Last four bytes (script)
844 */
845 #define QU_REG scr0
846 #define HS_REG scr1
847 #define HS_PRT nc_scr1
848 #define SS_REG scr2
849 #define SS_PRT nc_scr2
850 #define PS_REG scr3
851
852 /*
853 ** Last four bytes (host)
854 */
855 #ifdef SCSI_NCR_BIG_ENDIAN
856 #define actualquirks phys.header.status[3]
857 #define host_status phys.header.status[2]
858 #define scsi_status phys.header.status[1]
859 #define parity_status phys.header.status[0]
860 #else
861 #define actualquirks phys.header.status[0]
862 #define host_status phys.header.status[1]
863 #define scsi_status phys.header.status[2]
864 #define parity_status phys.header.status[3]
865 #endif
866
867 /*
868 ** First four bytes (script)
869 */
870 #define xerr_st header.scr_st[0]
871 #define sync_st header.scr_st[1]
872 #define nego_st header.scr_st[2]
873 #define wide_st header.scr_st[3]
874
875 /*
876 ** First four bytes (host)
877 */
878 #define xerr_status phys.xerr_st
879 #define nego_status phys.nego_st
880
881 #if 0
882 #define sync_status phys.sync_st
883 #define wide_status phys.wide_st
884 #endif
885
886 /*==========================================================
887 **
888 ** Declaration of structs: Data structure block
889 **
890 **==========================================================
891 **
892 ** During execution of a ccb by the script processor,
893 ** the DSA (data structure address) register points
894 ** to this substructure of the ccb.
895 ** This substructure contains the header with
896 ** the script-processor-changable data and
897 ** data blocks for the indirect move commands.
898 **
899 **----------------------------------------------------------
900 */
901
902 struct dsb {
903
904 /*
905 ** Header.
906 */
907
908 struct head header;
909
910 /*
911 ** Table data for Script
912 */
913
914 struct scr_tblsel select;
915 struct scr_tblmove smsg ;
916 struct scr_tblmove cmd ;
917 struct scr_tblmove sense ;
918 struct scr_tblmove data [MAX_SCATTER];
919 };
920
921
922 /*========================================================================
923 **
924 ** Declaration of structs: Command control block.
925 **
926 **========================================================================
927 */
928 struct ccb {
929 /*----------------------------------------------------------------
930 ** This is the data structure which is pointed by the DSA
931 ** register when it is executed by the script processor.
932 ** It must be the first entry because it contains the header
933 ** as first entry that must be cache line aligned.
934 **----------------------------------------------------------------
935 */
936 struct dsb phys;
937
938 /*----------------------------------------------------------------
939 ** Mini-script used at CCB execution start-up.
940 ** Load the DSA with the data structure address (phys) and
941 ** jump to SELECT. Jump to CANCEL if CCB is to be canceled.
942 **----------------------------------------------------------------
943 */
944 struct launch start;
945
946 /*----------------------------------------------------------------
947 ** Mini-script used at CCB relection to restart the nexus.
948 ** Load the DSA with the data structure address (phys) and
949 ** jump to RESEL_DSA. Jump to ABORT if CCB is to be aborted.
950 **----------------------------------------------------------------
951 */
952 struct launch restart;
953
954 /*----------------------------------------------------------------
955 ** If a data transfer phase is terminated too early
956 ** (after reception of a message (i.e. DISCONNECT)),
957 ** we have to prepare a mini script to transfer
958 ** the rest of the data.
959 **----------------------------------------------------------------
960 */
961 ncrcmd patch[8];
962
963 /*----------------------------------------------------------------
964 ** The general SCSI driver provides a
965 ** pointer to a control block.
966 **----------------------------------------------------------------
967 */
968 Scsi_Cmnd *cmd; /* SCSI command */
969 u_char cdb_buf[16]; /* Copy of CDB */
970 u_char sense_buf[64];
971 int data_len; /* Total data length */
972
973 /*----------------------------------------------------------------
974 ** Message areas.
975 ** We prepare a message to be sent after selection.
976 ** We may use a second one if the command is rescheduled
977 ** due to GETCC or QFULL.
978 ** Contents are IDENTIFY and SIMPLE_TAG.
979 ** While negotiating sync or wide transfer,
980 ** a SDTR or WDTR message is appended.
981 **----------------------------------------------------------------
982 */
983 u_char scsi_smsg [8];
984 u_char scsi_smsg2[8];
985
986 /*----------------------------------------------------------------
987 ** Other fields.
988 **----------------------------------------------------------------
989 */
990 u_long p_ccb; /* BUS address of this CCB */
991 u_char sensecmd[6]; /* Sense command */
992 u_char tag; /* Tag for this transfer */
993 /* 255 means no tag */
994 u_char target;
995 u_char lun;
996 u_char queued;
997 u_char auto_sense;
998 ccb_p link_ccb; /* Host adapter CCB chain */
999 XPT_QUEHEAD link_ccbq; /* Link to unit CCB queue */
1000 u_int32 startp; /* Initial data pointer */
1001 u_long magic; /* Free / busy CCB flag */
1002 };
1003
1004 #define CCB_PHYS(cp,lbl) (cp->p_ccb + offsetof(struct ccb, lbl))
1005
1006
1007 /*========================================================================
1008 **
1009 ** Declaration of structs: NCR device descriptor
1010 **
1011 **========================================================================
1012 */
1013 struct ncb {
1014 /*----------------------------------------------------------------
1015 ** The global header.
1016 ** It is accessible to both the host and the script processor.
1017 ** Must be cache line size aligned (32 for x86) in order to
1018 ** allow cache line bursting when it is copied to/from CCB.
1019 **----------------------------------------------------------------
1020 */
1021 struct head header;
1022
1023 /*----------------------------------------------------------------
1024 ** CCBs management queues.
1025 **----------------------------------------------------------------
1026 */
1027 Scsi_Cmnd *waiting_list; /* Commands waiting for a CCB */
1028 /* when lcb is not allocated. */
1029 Scsi_Cmnd *done_list; /* Commands waiting for done() */
1030 /* callback to be invoked. */
1031 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,93)
1032 spinlock_t smp_lock; /* Lock for SMP threading */
1033 #endif
1034
1035 /*----------------------------------------------------------------
1036 ** Chip and controller indentification.
1037 **----------------------------------------------------------------
1038 */
1039 int unit; /* Unit number */
1040 char chip_name[8]; /* Chip name */
1041 char inst_name[16]; /* ncb instance name */
1042
1043 /*----------------------------------------------------------------
1044 ** Initial value of some IO register bits.
1045 ** These values are assumed to have been set by BIOS, and may
1046 ** be used for probing adapter implementation differences.
1047 **----------------------------------------------------------------
1048 */
1049 u_char sv_scntl0, sv_scntl3, sv_dmode, sv_dcntl, sv_ctest0, sv_ctest3,
1050 sv_ctest4, sv_ctest5, sv_gpcntl, sv_stest2, sv_stest4;
1051
1052 /*----------------------------------------------------------------
1053 ** Actual initial value of IO register bits used by the
1054 ** driver. They are loaded at initialisation according to
1055 ** features that are to be enabled.
1056 **----------------------------------------------------------------
1057 */
1058 u_char rv_scntl0, rv_scntl3, rv_dmode, rv_dcntl, rv_ctest0, rv_ctest3,
1059 rv_ctest4, rv_ctest5, rv_stest2;
1060
1061 /*----------------------------------------------------------------
1062 ** Targets management.
1063 ** During reselection the ncr jumps to jump_tcb.
1064 ** The SFBR register is loaded with the encoded target id.
1065 ** For i = 0 to 3
1066 ** SCR_JUMP ^ IFTRUE(MASK(i, 3)), @(next tcb mod. i)
1067 **
1068 ** Recent chips will prefetch the 4 JUMPS using only 1 burst.
1069 ** It is kind of hashcoding.
1070 **----------------------------------------------------------------
1071 */
1072 struct link jump_tcb[4]; /* JUMPs for reselection */
1073 struct tcb target[MAX_TARGET]; /* Target data */
1074
1075 /*----------------------------------------------------------------
1076 ** Virtual and physical bus addresses of the chip.
1077 **----------------------------------------------------------------
1078 */
1079 vm_offset_t vaddr; /* Virtual and bus address of */
1080 vm_offset_t paddr; /* chip's IO registers. */
1081 vm_offset_t paddr2; /* On-chip RAM bus address. */
1082 volatile /* Pointer to volatile for */
1083 struct ncr_reg *reg; /* memory mapped IO. */
1084
1085 /*----------------------------------------------------------------
1086 ** SCRIPTS virtual and physical bus addresses.
1087 ** 'script' is loaded in the on-chip RAM if present.
1088 ** 'scripth' stays in main memory.
1089 **----------------------------------------------------------------
1090 */
1091 struct script *script0; /* Copies of script and scripth */
1092 struct scripth *scripth0; /* relocated for this ncb. */
1093 struct scripth *scripth; /* Actual scripth virt. address */
1094 u_long p_script; /* Actual script and scripth */
1095 u_long p_scripth; /* bus addresses. */
1096
1097 /*----------------------------------------------------------------
1098 ** General controller parameters and configuration.
1099 **----------------------------------------------------------------
1100 */
1101 device_t dev;
1102 u_short device_id; /* PCI device id */
1103 u_char revision_id; /* PCI device revision id */
1104 u_char bus; /* PCI BUS number */
1105 u_char device_fn; /* PCI BUS device and function */
1106 u_long base_io; /* IO space base address */
1107 u_int irq; /* IRQ level */
1108 u_int features; /* Chip features map */
1109 u_char myaddr; /* SCSI id of the adapter */
1110 u_char maxburst; /* log base 2 of dwords burst */
1111 u_char maxwide; /* Maximum transfer width */
1112 u_char minsync; /* Minimum sync period factor */
1113 u_char maxsync; /* Maximum sync period factor */
1114 u_char maxoffs; /* Max scsi offset */
1115 u_char multiplier; /* Clock multiplier (1,2,4) */
1116 u_char clock_divn; /* Number of clock divisors */
1117 u_long clock_khz; /* SCSI clock frequency in KHz */
1118
1119 /*----------------------------------------------------------------
1120 ** Start queue management.
1121 ** It is filled up by the host processor and accessed by the
1122 ** SCRIPTS processor in order to start SCSI commands.
1123 **----------------------------------------------------------------
1124 */
1125 u_short squeueput; /* Next free slot of the queue */
1126 u_short actccbs; /* Number of allocated CCBs */
1127 u_short queuedccbs; /* Number of CCBs in start queue*/
1128 u_short queuedepth; /* Start queue depth */
1129
1130 /*----------------------------------------------------------------
1131 ** Timeout handler.
1132 **----------------------------------------------------------------
1133 */
1134 struct timer_list timer; /* Timer handler link header */
1135 u_long lasttime;
1136 u_long settle_time; /* Resetting the SCSI BUS */
1137
1138 /*----------------------------------------------------------------
1139 ** Debugging and profiling.
1140 **----------------------------------------------------------------
1141 */
1142 struct ncr_reg regdump; /* Register dump */
1143 u_long regtime; /* Time it has been done */
1144
1145 /*----------------------------------------------------------------
1146 ** Miscellaneous buffers accessed by the scripts-processor.
1147 ** They shall be DWORD aligned, because they may be read or
1148 ** written with a SCR_COPY script command.
1149 **----------------------------------------------------------------
1150 */
1151 u_char msgout[8]; /* Buffer for MESSAGE OUT */
1152 u_char msgin [8]; /* Buffer for MESSAGE IN */
1153 u_int32 lastmsg; /* Last SCSI message sent */
1154 u_char scratch; /* Scratch for SCSI receive */
1155
1156 /*----------------------------------------------------------------
1157 ** Miscellaneous configuration and status parameters.
1158 **----------------------------------------------------------------
1159 */
1160 u_char disc; /* Diconnection allowed */
1161 u_char scsi_mode; /* Current SCSI BUS mode */
1162 u_char order; /* Tag order to use */
1163 u_char verbose; /* Verbosity for this controller*/
1164 int ncr_cache; /* Used for cache test at init. */
1165 u_long p_ncb; /* BUS address of this NCB */
1166
1167 /*----------------------------------------------------------------
1168 ** Command completion handling.
1169 **----------------------------------------------------------------
1170 */
1171 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
1172 struct ccb *(ccb_done[MAX_DONE]);
1173 int ccb_done_ic;
1174 #endif
1175 /*----------------------------------------------------------------
1176 ** Fields that should be removed or changed.
1177 **----------------------------------------------------------------
1178 */
1179 struct ccb *ccb; /* Global CCB */
1180 struct usrcmd user; /* Command from user */
1181 volatile u_char release_stage; /* Synchronisation stage on release */
1182
1183 #ifdef SCSI_NCR_INTEGRITY_CHECKING
1184 /*----------------------------------------------------------------
1185 ** Fields that are used for integrity check
1186 **----------------------------------------------------------------
1187 */
1188 unsigned char check_integrity; /* Enable midlayer integ.check on
1189 * bus scan. */
1190 unsigned char check_integ_par; /* Set if par or Init. Det. error
1191 * used only during integ check */
1192 #endif
1193 };
1194
1195 #define NCB_SCRIPT_PHYS(np,lbl) (np->p_script + offsetof (struct script, lbl))
1196 #define NCB_SCRIPTH_PHYS(np,lbl) (np->p_scripth + offsetof (struct scripth,lbl))
1197
1198 /*==========================================================
1199 **
1200 **
1201 ** Script for NCR-Processor.
1202 **
1203 ** Use ncr_script_fill() to create the variable parts.
1204 ** Use ncr_script_copy_and_bind() to make a copy and
1205 ** bind to physical addresses.
1206 **
1207 **
1208 **==========================================================
1209 **
1210 ** We have to know the offsets of all labels before
1211 ** we reach them (for forward jumps).
1212 ** Therefore we declare a struct here.
1213 ** If you make changes inside the script,
1214 ** DONT FORGET TO CHANGE THE LENGTHS HERE!
1215 **
1216 **----------------------------------------------------------
1217 */
1218
1219 /*
1220 ** For HP Zalon/53c720 systems, the Zalon interface
1221 ** between CPU and 53c720 does prefetches, which causes
1222 ** problems with self modifying scripts. The problem
1223 ** is overcome by calling a dummy subroutine after each
1224 ** modification, to force a refetch of the script on
1225 ** return from the subroutine.
1226 */
1227
1228 #ifdef CONFIG_NCR53C8XX_PREFETCH
1229 #define PREFETCH_FLUSH_CNT 2
1230 #define PREFETCH_FLUSH SCR_CALL, PADDRH (wait_dma),
1231 #else
1232 #define PREFETCH_FLUSH_CNT 0
1233 #define PREFETCH_FLUSH
1234 #endif
1235
1236 /*
1237 ** Script fragments which are loaded into the on-chip RAM
1238 ** of 825A, 875 and 895 chips.
1239 */
1240 struct script {
1241 ncrcmd start [ 5];
1242 ncrcmd startpos [ 1];
1243 ncrcmd select [ 6];
1244 ncrcmd select2 [ 9 + PREFETCH_FLUSH_CNT];
1245 ncrcmd loadpos [ 4];
1246 ncrcmd send_ident [ 9];
1247 ncrcmd prepare [ 6];
1248 ncrcmd prepare2 [ 7];
1249 ncrcmd command [ 6];
1250 ncrcmd dispatch [ 32];
1251 ncrcmd clrack [ 4];
1252 ncrcmd no_data [ 17];
1253 ncrcmd status [ 8];
1254 ncrcmd msg_in [ 2];
1255 ncrcmd msg_in2 [ 16];
1256 ncrcmd msg_bad [ 4];
1257 ncrcmd setmsg [ 7];
1258 ncrcmd cleanup [ 6];
1259 ncrcmd complete [ 9];
1260 ncrcmd cleanup_ok [ 8 + PREFETCH_FLUSH_CNT];
1261 ncrcmd cleanup0 [ 1];
1262 #ifndef SCSI_NCR_CCB_DONE_SUPPORT
1263 ncrcmd signal [ 12];
1264 #else
1265 ncrcmd signal [ 9];
1266 ncrcmd done_pos [ 1];
1267 ncrcmd done_plug [ 2];
1268 ncrcmd done_end [ 7];
1269 #endif
1270 ncrcmd save_dp [ 7];
1271 ncrcmd restore_dp [ 5];
1272 ncrcmd disconnect [ 17];
1273 ncrcmd msg_out [ 9];
1274 ncrcmd msg_out_done [ 7];
1275 ncrcmd idle [ 2];
1276 ncrcmd reselect [ 8];
1277 ncrcmd reselected [ 8];
1278 ncrcmd resel_dsa [ 6 + PREFETCH_FLUSH_CNT];
1279 ncrcmd loadpos1 [ 4];
1280 ncrcmd resel_lun [ 6];
1281 ncrcmd resel_tag [ 6];
1282 ncrcmd jump_to_nexus [ 4 + PREFETCH_FLUSH_CNT];
1283 ncrcmd nexus_indirect [ 4];
1284 ncrcmd resel_notag [ 4];
1285 ncrcmd data_in [MAX_SCATTERL * 4];
1286 ncrcmd data_in2 [ 4];
1287 ncrcmd data_out [MAX_SCATTERL * 4];
1288 ncrcmd data_out2 [ 4];
1289 };
1290
1291 /*
1292 ** Script fragments which stay in main memory for all chips.
1293 */
1294 struct scripth {
1295 ncrcmd tryloop [MAX_START*2];
1296 ncrcmd tryloop2 [ 2];
1297 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
1298 ncrcmd done_queue [MAX_DONE*5];
1299 ncrcmd done_queue2 [ 2];
1300 #endif
1301 ncrcmd select_no_atn [ 8];
1302 ncrcmd cancel [ 4];
1303 ncrcmd skip [ 9 + PREFETCH_FLUSH_CNT];
1304 ncrcmd skip2 [ 19];
1305 ncrcmd par_err_data_in [ 6];
1306 ncrcmd par_err_other [ 4];
1307 ncrcmd msg_reject [ 8];
1308 ncrcmd msg_ign_residue [ 24];
1309 ncrcmd msg_extended [ 10];
1310 ncrcmd msg_ext_2 [ 10];
1311 ncrcmd msg_wdtr [ 14];
1312 ncrcmd send_wdtr [ 7];
1313 ncrcmd msg_ext_3 [ 10];
1314 ncrcmd msg_sdtr [ 14];
1315 ncrcmd send_sdtr [ 7];
1316 ncrcmd nego_bad_phase [ 4];
1317 ncrcmd msg_out_abort [ 10];
1318 ncrcmd hdata_in [MAX_SCATTERH * 4];
1319 ncrcmd hdata_in2 [ 2];
1320 ncrcmd hdata_out [MAX_SCATTERH * 4];
1321 ncrcmd hdata_out2 [ 2];
1322 ncrcmd reset [ 4];
1323 ncrcmd aborttag [ 4];
1324 ncrcmd abort [ 2];
1325 ncrcmd abort_resel [ 20];
1326 ncrcmd resend_ident [ 4];
1327 ncrcmd clratn_go_on [ 3];
1328 ncrcmd nxtdsp_go_on [ 1];
1329 ncrcmd sdata_in [ 8];
1330 ncrcmd data_io [ 18];
1331 ncrcmd bad_identify [ 12];
1332 ncrcmd bad_i_t_l [ 4];
1333 ncrcmd bad_i_t_l_q [ 4];
1334 ncrcmd bad_target [ 8];
1335 ncrcmd bad_status [ 8];
1336 ncrcmd start_ram [ 4 + PREFETCH_FLUSH_CNT];
1337 ncrcmd start_ram0 [ 4];
1338 ncrcmd sto_restart [ 5];
1339 ncrcmd wait_dma [ 2];
1340 ncrcmd snooptest [ 9];
1341 ncrcmd snoopend [ 2];
1342 };
1343
1344 /*==========================================================
1345 **
1346 **
1347 ** Function headers.
1348 **
1349 **
1350 **==========================================================
1351 */
1352
1353 static void ncr_alloc_ccb (ncb_p np, u_char tn, u_char ln);
1354 static void ncr_complete (ncb_p np, ccb_p cp);
1355 static void ncr_exception (ncb_p np);
1356 static void ncr_free_ccb (ncb_p np, ccb_p cp);
1357 static void ncr_init_ccb (ncb_p np, ccb_p cp);
1358 static void ncr_init_tcb (ncb_p np, u_char tn);
1359 static lcb_p ncr_alloc_lcb (ncb_p np, u_char tn, u_char ln);
1360 static lcb_p ncr_setup_lcb (ncb_p np, u_char tn, u_char ln,
1361 u_char *inq_data);
1362 static void ncr_getclock (ncb_p np, int mult);
1363 static void ncr_selectclock (ncb_p np, u_char scntl3);
1364 static ccb_p ncr_get_ccb (ncb_p np, u_char tn, u_char ln);
1365 static void ncr_chip_reset (ncb_p np, int delay);
1366 static void ncr_init (ncb_p np, int reset, char * msg, u_long code);
1367 static int ncr_int_sbmc (ncb_p np);
1368 static int ncr_int_par (ncb_p np);
1369 static void ncr_int_ma (ncb_p np);
1370 static void ncr_int_sir (ncb_p np);
1371 static void ncr_int_sto (ncb_p np);
1372 static u_long ncr_lookup (char* id);
1373 static void ncr_negotiate (struct ncb* np, struct tcb* tp);
1374 static int ncr_prepare_nego(ncb_p np, ccb_p cp, u_char *msgptr);
1375 #ifdef SCSI_NCR_INTEGRITY_CHECKING
1376 static int ncr_ic_nego(ncb_p np, ccb_p cp, Scsi_Cmnd *cmd, u_char *msgptr);
1377 #endif
1378
1379 static void ncr_script_copy_and_bind
1380 (ncb_p np, ncrcmd *src, ncrcmd *dst, int len);
1381 static void ncr_script_fill (struct script * scr, struct scripth * scripth);
1382 static int ncr_scatter (ncb_p np, ccb_p cp, Scsi_Cmnd *cmd);
1383 static void ncr_getsync (ncb_p np, u_char sfac, u_char *fakp, u_char *scntl3p);
1384 static void ncr_setsync (ncb_p np, ccb_p cp, u_char scntl3, u_char sxfer);
1385 static void ncr_setup_tags (ncb_p np, u_char tn, u_char ln);
1386 static void ncr_setwide (ncb_p np, ccb_p cp, u_char wide, u_char ack);
1387 static int ncr_show_msg (u_char * msg);
1388 static void ncr_print_msg (ccb_p cp, char *label, u_char *msg);
1389 static int ncr_snooptest (ncb_p np);
1390 static void ncr_timeout (ncb_p np);
1391 static void ncr_wakeup (ncb_p np, u_long code);
1392 static void ncr_wakeup_done (ncb_p np);
1393 static void ncr_start_next_ccb (ncb_p np, lcb_p lp, int maxn);
1394 static void ncr_put_start_queue(ncb_p np, ccb_p cp);
1395 static void ncr_start_reset (ncb_p np);
1396 static int ncr_reset_scsi_bus (ncb_p np, int enab_int, int settle_delay);
1397
1398 #ifdef SCSI_NCR_USER_COMMAND_SUPPORT
1399 static void ncr_usercmd (ncb_p np);
1400 #endif
1401
1402 static void insert_into_waiting_list(ncb_p np, Scsi_Cmnd *cmd);
1403 static Scsi_Cmnd *retrieve_from_waiting_list(int to_remove, ncb_p np, Scsi_Cmnd *cmd);
1404 static void process_waiting_list(ncb_p np, int sts);
1405
1406 #define remove_from_waiting_list(np, cmd) \
1407 retrieve_from_waiting_list(1, (np), (cmd))
1408 #define requeue_waiting_list(np) process_waiting_list((np), DID_OK)
1409 #define reset_waiting_list(np) process_waiting_list((np), DID_RESET)
1410
1411 static inline char *ncr_name (ncb_p np)
1412 {
1413 return np->inst_name;
1414 }
1415
1416
1417 /*==========================================================
1418 **
1419 **
1420 ** Scripts for NCR-Processor.
1421 **
1422 ** Use ncr_script_bind for binding to physical addresses.
1423 **
1424 **
1425 **==========================================================
1426 **
1427 ** NADDR generates a reference to a field of the controller data.
1428 ** PADDR generates a reference to another part of the script.
1429 ** RADDR generates a reference to a script processor register.
1430 ** FADDR generates a reference to a script processor register
1431 ** with offset.
1432 **
1433 **----------------------------------------------------------
1434 */
1435
1436 #define RELOC_SOFTC 0x40000000
1437 #define RELOC_LABEL 0x50000000
1438 #define RELOC_REGISTER 0x60000000
1439 #if 0
1440 #define RELOC_KVAR 0x70000000
1441 #endif
1442 #define RELOC_LABELH 0x80000000
1443 #define RELOC_MASK 0xf0000000
1444
1445 #define NADDR(label) (RELOC_SOFTC | offsetof(struct ncb, label))
1446 #define PADDR(label) (RELOC_LABEL | offsetof(struct script, label))
1447 #define PADDRH(label) (RELOC_LABELH | offsetof(struct scripth, label))
1448 #define RADDR(label) (RELOC_REGISTER | REG(label))
1449 #define FADDR(label,ofs)(RELOC_REGISTER | ((REG(label))+(ofs)))
1450 #if 0
1451 #define KVAR(which) (RELOC_KVAR | (which))
1452 #endif
1453
1454 #if 0
1455 #define SCRIPT_KVAR_JIFFIES (0)
1456 #define SCRIPT_KVAR_FIRST SCRIPT_KVAR_JIFFIES
1457 #define SCRIPT_KVAR_LAST SCRIPT_KVAR_JIFFIES
1458 /*
1459 * Kernel variables referenced in the scripts.
1460 * THESE MUST ALL BE ALIGNED TO A 4-BYTE BOUNDARY.
1461 */
1462 static void *script_kvars[] __initdata =
1463 { (void *)&jiffies };
1464 #endif
1465
1466 static struct script script0 __initdata = {
1467 /*--------------------------< START >-----------------------*/ {
1468 /*
1469 ** This NOP will be patched with LED ON
1470 ** SCR_REG_REG (gpreg, SCR_AND, 0xfe)
1471 */
1472 SCR_NO_OP,
1473 0,
1474 /*
1475 ** Clear SIGP.
1476 */
1477 SCR_FROM_REG (ctest2),
1478 0,
1479 /*
1480 ** Then jump to a certain point in tryloop.
1481 ** Due to the lack of indirect addressing the code
1482 ** is self modifying here.
1483 */
1484 SCR_JUMP,
1485 }/*-------------------------< STARTPOS >--------------------*/,{
1486 PADDRH(tryloop),
1487
1488 }/*-------------------------< SELECT >----------------------*/,{
1489 /*
1490 ** DSA contains the address of a scheduled
1491 ** data structure.
1492 **
1493 ** SCRATCHA contains the address of the script,
1494 ** which starts the next entry.
1495 **
1496 ** Set Initiator mode.
1497 **
1498 ** (Target mode is left as an exercise for the reader)
1499 */
1500
1501 SCR_CLR (SCR_TRG),
1502 0,
1503 SCR_LOAD_REG (HS_REG, HS_SELECTING),
1504 0,
1505
1506 /*
1507 ** And try to select this target.
1508 */
1509 SCR_SEL_TBL_ATN ^ offsetof (struct dsb, select),
1510 PADDR (reselect),
1511
1512 }/*-------------------------< SELECT2 >----------------------*/,{
1513 /*
1514 ** Now there are 4 possibilities:
1515 **
1516 ** (1) The ncr loses arbitration.
1517 ** This is ok, because it will try again,
1518 ** when the bus becomes idle.
1519 ** (But beware of the timeout function!)
1520 **
1521 ** (2) The ncr is reselected.
1522 ** Then the script processor takes the jump
1523 ** to the RESELECT label.
1524 **
1525 ** (3) The ncr wins arbitration.
1526 ** Then it will execute SCRIPTS instruction until
1527 ** the next instruction that checks SCSI phase.
1528 ** Then will stop and wait for selection to be
1529 ** complete or selection time-out to occur.
1530 ** As a result the SCRIPTS instructions until
1531 ** LOADPOS + 2 should be executed in parallel with
1532 ** the SCSI core performing selection.
1533 */
1534
1535 /*
1536 ** The M_REJECT problem seems to be due to a selection
1537 ** timing problem.
1538 ** Wait immediately for the selection to complete.
1539 ** (2.5x behaves so)
1540 */
1541 SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_OUT)),
1542 0,
1543
1544 /*
1545 ** Next time use the next slot.
1546 */
1547 SCR_COPY (4),
1548 RADDR (temp),
1549 PADDR (startpos),
1550 /*
1551 ** The ncr doesn't have an indirect load
1552 ** or store command. So we have to
1553 ** copy part of the control block to a
1554 ** fixed place, where we can access it.
1555 **
1556 ** We patch the address part of a
1557 ** COPY command with the DSA-register.
1558 */
1559 SCR_COPY_F (4),
1560 RADDR (dsa),
1561 PADDR (loadpos),
1562 /*
1563 ** Flush script prefetch if required
1564 */
1565 PREFETCH_FLUSH
1566 /*
1567 ** then we do the actual copy.
1568 */
1569 SCR_COPY (sizeof (struct head)),
1570 /*
1571 ** continued after the next label ...
1572 */
1573 }/*-------------------------< LOADPOS >---------------------*/,{
1574 0,
1575 NADDR (header),
1576 /*
1577 ** Wait for the next phase or the selection
1578 ** to complete or time-out.
1579 */
1580 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_OUT)),
1581 PADDR (prepare),
1582
1583 }/*-------------------------< SEND_IDENT >----------------------*/,{
1584 /*
1585 ** Selection complete.
1586 ** Send the IDENTIFY and SIMPLE_TAG messages
1587 ** (and the M_X_SYNC_REQ message)
1588 */
1589 SCR_MOVE_TBL ^ SCR_MSG_OUT,
1590 offsetof (struct dsb, smsg),
1591 SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_OUT)),
1592 PADDRH (resend_ident),
1593 SCR_LOAD_REG (scratcha, 0x80),
1594 0,
1595 SCR_COPY (1),
1596 RADDR (scratcha),
1597 NADDR (lastmsg),
1598 }/*-------------------------< PREPARE >----------------------*/,{
1599 /*
1600 ** load the savep (saved pointer) into
1601 ** the TEMP register (actual pointer)
1602 */
1603 SCR_COPY (4),
1604 NADDR (header.savep),
1605 RADDR (temp),
1606 /*
1607 ** Initialize the status registers
1608 */
1609 SCR_COPY (4),
1610 NADDR (header.status),
1611 RADDR (scr0),
1612 }/*-------------------------< PREPARE2 >---------------------*/,{
1613 /*
1614 ** Initialize the msgout buffer with a NOOP message.
1615 */
1616 SCR_LOAD_REG (scratcha, M_NOOP),
1617 0,
1618 SCR_COPY (1),
1619 RADDR (scratcha),
1620 NADDR (msgout),
1621 #if 0
1622 SCR_COPY (1),
1623 RADDR (scratcha),
1624 NADDR (msgin),
1625 #endif
1626 /*
1627 ** Anticipate the COMMAND phase.
1628 ** This is the normal case for initial selection.
1629 */
1630 SCR_JUMP ^ IFFALSE (WHEN (SCR_COMMAND)),
1631 PADDR (dispatch),
1632
1633 }/*-------------------------< COMMAND >--------------------*/,{
1634 /*
1635 ** ... and send the command
1636 */
1637 SCR_MOVE_TBL ^ SCR_COMMAND,
1638 offsetof (struct dsb, cmd),
1639 /*
1640 ** If status is still HS_NEGOTIATE, negotiation failed.
1641 ** We check this here, since we want to do that
1642 ** only once.
1643 */
1644 SCR_FROM_REG (HS_REG),
1645 0,
1646 SCR_INT ^ IFTRUE (DATA (HS_NEGOTIATE)),
1647 SIR_NEGO_FAILED,
1648
1649 }/*-----------------------< DISPATCH >----------------------*/,{
1650 /*
1651 ** MSG_IN is the only phase that shall be
1652 ** entered at least once for each (re)selection.
1653 ** So we test it first.
1654 */
1655 SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_IN)),
1656 PADDR (msg_in),
1657
1658 SCR_RETURN ^ IFTRUE (IF (SCR_DATA_OUT)),
1659 0,
1660 /*
1661 ** DEL 397 - 53C875 Rev 3 - Part Number 609-0392410 - ITEM 4.
1662 ** Possible data corruption during Memory Write and Invalidate.
1663 ** This work-around resets the addressing logic prior to the
1664 ** start of the first MOVE of a DATA IN phase.
1665 ** (See Documentation/scsi/ncr53c8xx.txt for more information)
1666 */
1667 SCR_JUMPR ^ IFFALSE (IF (SCR_DATA_IN)),
1668 20,
1669 SCR_COPY (4),
1670 RADDR (scratcha),
1671 RADDR (scratcha),
1672 SCR_RETURN,
1673 0,
1674 SCR_JUMP ^ IFTRUE (IF (SCR_STATUS)),
1675 PADDR (status),
1676 SCR_JUMP ^ IFTRUE (IF (SCR_COMMAND)),
1677 PADDR (command),
1678 SCR_JUMP ^ IFTRUE (IF (SCR_MSG_OUT)),
1679 PADDR (msg_out),
1680 /*
1681 ** Discard one illegal phase byte, if required.
1682 */
1683 SCR_LOAD_REG (scratcha, XE_BAD_PHASE),
1684 0,
1685 SCR_COPY (1),
1686 RADDR (scratcha),
1687 NADDR (xerr_st),
1688 SCR_JUMPR ^ IFFALSE (IF (SCR_ILG_OUT)),
1689 8,
1690 SCR_MOVE_ABS (1) ^ SCR_ILG_OUT,
1691 NADDR (scratch),
1692 SCR_JUMPR ^ IFFALSE (IF (SCR_ILG_IN)),
1693 8,
1694 SCR_MOVE_ABS (1) ^ SCR_ILG_IN,
1695 NADDR (scratch),
1696 SCR_JUMP,
1697 PADDR (dispatch),
1698
1699 }/*-------------------------< CLRACK >----------------------*/,{
1700 /*
1701 ** Terminate possible pending message phase.
1702 */
1703 SCR_CLR (SCR_ACK),
1704 0,
1705 SCR_JUMP,
1706 PADDR (dispatch),
1707
1708 }/*-------------------------< NO_DATA >--------------------*/,{
1709 /*
1710 ** The target wants to tranfer too much data
1711 ** or in the wrong direction.
1712 ** Remember that in extended error.
1713 */
1714 SCR_LOAD_REG (scratcha, XE_EXTRA_DATA),
1715 0,
1716 SCR_COPY (1),
1717 RADDR (scratcha),
1718 NADDR (xerr_st),
1719 /*
1720 ** Discard one data byte, if required.
1721 */
1722 SCR_JUMPR ^ IFFALSE (WHEN (SCR_DATA_OUT)),
1723 8,
1724 SCR_MOVE_ABS (1) ^ SCR_DATA_OUT,
1725 NADDR (scratch),
1726 SCR_JUMPR ^ IFFALSE (IF (SCR_DATA_IN)),
1727 8,
1728 SCR_MOVE_ABS (1) ^ SCR_DATA_IN,
1729 NADDR (scratch),
1730 /*
1731 ** .. and repeat as required.
1732 */
1733 SCR_CALL,
1734 PADDR (dispatch),
1735 SCR_JUMP,
1736 PADDR (no_data),
1737
1738 }/*-------------------------< STATUS >--------------------*/,{
1739 /*
1740 ** get the status
1741 */
1742 SCR_MOVE_ABS (1) ^ SCR_STATUS,
1743 NADDR (scratch),
1744 /*
1745 ** save status to scsi_status.
1746 ** mark as complete.
1747 */
1748 SCR_TO_REG (SS_REG),
1749 0,
1750 SCR_LOAD_REG (HS_REG, HS_COMPLETE),
1751 0,
1752 SCR_JUMP,
1753 PADDR (dispatch),
1754 }/*-------------------------< MSG_IN >--------------------*/,{
1755 /*
1756 ** Get the first byte of the message
1757 ** and save it to SCRATCHA.
1758 **
1759 ** The script processor doesn't negate the
1760 ** ACK signal after this transfer.
1761 */
1762 SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
1763 NADDR (msgin[0]),
1764 }/*-------------------------< MSG_IN2 >--------------------*/,{
1765 /*
1766 ** Handle this message.
1767 */
1768 SCR_JUMP ^ IFTRUE (DATA (M_COMPLETE)),
1769 PADDR (complete),
1770 SCR_JUMP ^ IFTRUE (DATA (M_DISCONNECT)),
1771 PADDR (disconnect),
1772 SCR_JUMP ^ IFTRUE (DATA (M_SAVE_DP)),
1773 PADDR (save_dp),
1774 SCR_JUMP ^ IFTRUE (DATA (M_RESTORE_DP)),
1775 PADDR (restore_dp),
1776 SCR_JUMP ^ IFTRUE (DATA (M_EXTENDED)),
1777 PADDRH (msg_extended),
1778 SCR_JUMP ^ IFTRUE (DATA (M_NOOP)),
1779 PADDR (clrack),
1780 SCR_JUMP ^ IFTRUE (DATA (M_REJECT)),
1781 PADDRH (msg_reject),
1782 SCR_JUMP ^ IFTRUE (DATA (M_IGN_RESIDUE)),
1783 PADDRH (msg_ign_residue),
1784 /*
1785 ** Rest of the messages left as
1786 ** an exercise ...
1787 **
1788 ** Unimplemented messages:
1789 ** fall through to MSG_BAD.
1790 */
1791 }/*-------------------------< MSG_BAD >------------------*/,{
1792 /*
1793 ** unimplemented message - reject it.
1794 */
1795 SCR_INT,
1796 SIR_REJECT_SENT,
1797 SCR_LOAD_REG (scratcha, M_REJECT),
1798 0,
1799 }/*-------------------------< SETMSG >----------------------*/,{
1800 SCR_COPY (1),
1801 RADDR (scratcha),
1802 NADDR (msgout),
1803 SCR_SET (SCR_ATN),
1804 0,
1805 SCR_JUMP,
1806 PADDR (clrack),
1807 }/*-------------------------< CLEANUP >-------------------*/,{
1808 /*
1809 ** dsa: Pointer to ccb
1810 ** or xxxxxxFF (no ccb)
1811 **
1812 ** HS_REG: Host-Status (<>0!)
1813 */
1814 SCR_FROM_REG (dsa),
1815 0,
1816 SCR_JUMP ^ IFTRUE (DATA (0xff)),
1817 PADDR (start),
1818 /*
1819 ** dsa is valid.
1820 ** complete the cleanup.
1821 */
1822 SCR_JUMP,
1823 PADDR (cleanup_ok),
1824
1825 }/*-------------------------< COMPLETE >-----------------*/,{
1826 /*
1827 ** Complete message.
1828 **
1829 ** Copy TEMP register to LASTP in header.
1830 */
1831 SCR_COPY (4),
1832 RADDR (temp),
1833 NADDR (header.lastp),
1834 /*
1835 ** When we terminate the cycle by clearing ACK,
1836 ** the target may disconnect immediately.
1837 **
1838 ** We don't want to be told of an
1839 ** "unexpected disconnect",
1840 ** so we disable this feature.
1841 */
1842 SCR_REG_REG (scntl2, SCR_AND, 0x7f),
1843 0,
1844 /*
1845 ** Terminate cycle ...
1846 */
1847 SCR_CLR (SCR_ACK|SCR_ATN),
1848 0,
1849 /*
1850 ** ... and wait for the disconnect.
1851 */
1852 SCR_WAIT_DISC,
1853 0,
1854 }/*-------------------------< CLEANUP_OK >----------------*/,{
1855 /*
1856 ** Save host status to header.
1857 */
1858 SCR_COPY (4),
1859 RADDR (scr0),
1860 NADDR (header.status),
1861 /*
1862 ** and copy back the header to the ccb.
1863 */
1864 SCR_COPY_F (4),
1865 RADDR (dsa),
1866 PADDR (cleanup0),
1867 /*
1868 ** Flush script prefetch if required
1869 */
1870 PREFETCH_FLUSH
1871 SCR_COPY (sizeof (struct head)),
1872 NADDR (header),
1873 }/*-------------------------< CLEANUP0 >--------------------*/,{
1874 0,
1875 }/*-------------------------< SIGNAL >----------------------*/,{
1876 /*
1877 ** if job not completed ...
1878 */
1879 SCR_FROM_REG (HS_REG),
1880 0,
1881 /*
1882 ** ... start the next command.
1883 */
1884 SCR_JUMP ^ IFTRUE (MASK (0, (HS_DONEMASK|HS_SKIPMASK))),
1885 PADDR(start),
1886 /*
1887 ** If command resulted in not GOOD status,
1888 ** call the C code if needed.
1889 */
1890 SCR_FROM_REG (SS_REG),
1891 0,
1892 SCR_CALL ^ IFFALSE (DATA (S_GOOD)),
1893 PADDRH (bad_status),
1894
1895 #ifndef SCSI_NCR_CCB_DONE_SUPPORT
1896
1897 /*
1898 ** ... signal completion to the host
1899 */
1900 #ifdef SIMULATED_INTFLY
1901 SCR_INT,
1902 SIR_INTFLY,
1903 #else
1904 SCR_INT_FLY,
1905 0,
1906 #endif
1907 /*
1908 ** Auf zu neuen Schandtaten!
1909 */
1910 SCR_JUMP,
1911 PADDR(start),
1912
1913 #else /* defined SCSI_NCR_CCB_DONE_SUPPORT */
1914
1915 /*
1916 ** ... signal completion to the host
1917 */
1918 SCR_JUMP,
1919 }/*------------------------< DONE_POS >---------------------*/,{
1920 PADDRH (done_queue),
1921 }/*------------------------< DONE_PLUG >--------------------*/,{
1922 SCR_INT,
1923 SIR_DONE_OVERFLOW,
1924 }/*------------------------< DONE_END >---------------------*/,{
1925 #ifdef SIMULATED_INTFLY
1926 SCR_INT,
1927 SIR_INTFLY,
1928 #else
1929 SCR_INT_FLY,
1930 0,
1931 #endif
1932 SCR_COPY (4),
1933 RADDR (temp),
1934 PADDR (done_pos),
1935 SCR_JUMP,
1936 PADDR (start),
1937
1938 #endif /* SCSI_NCR_CCB_DONE_SUPPORT */
1939
1940 }/*-------------------------< SAVE_DP >------------------*/,{
1941 /*
1942 ** SAVE_DP message:
1943 ** Copy TEMP register to SAVEP in header.
1944 */
1945 SCR_COPY (4),
1946 RADDR (temp),
1947 NADDR (header.savep),
1948 SCR_CLR (SCR_ACK),
1949 0,
1950 SCR_JUMP,
1951 PADDR (dispatch),
1952 }/*-------------------------< RESTORE_DP >---------------*/,{
1953 /*
1954 ** RESTORE_DP message:
1955 ** Copy SAVEP in header to TEMP register.
1956 */
1957 SCR_COPY (4),
1958 NADDR (header.savep),
1959 RADDR (temp),
1960 SCR_JUMP,
1961 PADDR (clrack),
1962
1963 }/*-------------------------< DISCONNECT >---------------*/,{
1964 /*
1965 ** DISCONNECTing ...
1966 **
1967 ** disable the "unexpected disconnect" feature,
1968 ** and remove the ACK signal.
1969 */
1970 SCR_REG_REG (scntl2, SCR_AND, 0x7f),
1971 0,
1972 SCR_CLR (SCR_ACK|SCR_ATN),
1973 0,
1974 /*
1975 ** Wait for the disconnect.
1976 */
1977 SCR_WAIT_DISC,
1978 0,
1979 /*
1980 ** Status is: DISCONNECTED.
1981 */
1982 SCR_LOAD_REG (HS_REG, HS_DISCONNECT),
1983 0,
1984 /*
1985 ** If QUIRK_AUTOSAVE is set,
1986 ** do an "save pointer" operation.
1987 */
1988 SCR_FROM_REG (QU_REG),
1989 0,
1990 SCR_JUMP ^ IFFALSE (MASK (QUIRK_AUTOSAVE, QUIRK_AUTOSAVE)),
1991 PADDR (cleanup_ok),
1992 /*
1993 ** like SAVE_DP message:
1994 ** Copy TEMP register to SAVEP in header.
1995 */
1996 SCR_COPY (4),
1997 RADDR (temp),
1998 NADDR (header.savep),
1999 SCR_JUMP,
2000 PADDR (cleanup_ok),
2001
2002 }/*-------------------------< MSG_OUT >-------------------*/,{
2003 /*
2004 ** The target requests a message.
2005 */
2006 SCR_MOVE_ABS (1) ^ SCR_MSG_OUT,
2007 NADDR (msgout),
2008 SCR_COPY (1),
2009 NADDR (msgout),
2010 NADDR (lastmsg),
2011 /*
2012 ** If it was no ABORT message ...
2013 */
2014 SCR_JUMP ^ IFTRUE (DATA (M_ABORT)),
2015 PADDRH (msg_out_abort),
2016 /*
2017 ** ... wait for the next phase
2018 ** if it's a message out, send it again, ...
2019 */
2020 SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_OUT)),
2021 PADDR (msg_out),
2022 }/*-------------------------< MSG_OUT_DONE >--------------*/,{
2023 /*
2024 ** ... else clear the message ...
2025 */
2026 SCR_LOAD_REG (scratcha, M_NOOP),
2027 0,
2028 SCR_COPY (4),
2029 RADDR (scratcha),
2030 NADDR (msgout),
2031 /*
2032 ** ... and process the next phase
2033 */
2034 SCR_JUMP,
2035 PADDR (dispatch),
2036 }/*-------------------------< IDLE >------------------------*/,{
2037 /*
2038 ** Nothing to do?
2039 ** Wait for reselect.
2040 ** This NOP will be patched with LED OFF
2041 ** SCR_REG_REG (gpreg, SCR_OR, 0x01)
2042 */
2043 SCR_NO_OP,
2044 0,
2045 }/*-------------------------< RESELECT >--------------------*/,{
2046 /*
2047 ** make the DSA invalid.
2048 */
2049 SCR_LOAD_REG (dsa, 0xff),
2050 0,
2051 SCR_CLR (SCR_TRG),
2052 0,
2053 SCR_LOAD_REG (HS_REG, HS_IN_RESELECT),
2054 0,
2055 /*
2056 ** Sleep waiting for a reselection.
2057 ** If SIGP is set, special treatment.
2058 **
2059 ** Zu allem bereit ..
2060 */
2061 SCR_WAIT_RESEL,
2062 PADDR(start),
2063 }/*-------------------------< RESELECTED >------------------*/,{
2064 /*
2065 ** This NOP will be patched with LED ON
2066 ** SCR_REG_REG (gpreg, SCR_AND, 0xfe)
2067 */
2068 SCR_NO_OP,
2069 0,
2070 /*
2071 ** ... zu nichts zu gebrauchen ?
2072 **
2073 ** load the target id into the SFBR
2074 ** and jump to the control block.
2075 **
2076 ** Look at the declarations of
2077 ** - struct ncb
2078 ** - struct tcb
2079 ** - struct lcb
2080 ** - struct ccb
2081 ** to understand what's going on.
2082 */
2083 SCR_REG_SFBR (ssid, SCR_AND, 0x8F),
2084 0,
2085 SCR_TO_REG (sdid),
2086 0,
2087 SCR_JUMP,
2088 NADDR (jump_tcb),
2089
2090 }/*-------------------------< RESEL_DSA >-------------------*/,{
2091 /*
2092 ** Ack the IDENTIFY or TAG previously received.
2093 */
2094 SCR_CLR (SCR_ACK),
2095 0,
2096 /*
2097 ** The ncr doesn't have an indirect load
2098 ** or store command. So we have to
2099 ** copy part of the control block to a
2100 ** fixed place, where we can access it.
2101 **
2102 ** We patch the address part of a
2103 ** COPY command with the DSA-register.
2104 */
2105 SCR_COPY_F (4),
2106 RADDR (dsa),
2107 PADDR (loadpos1),
2108 /*
2109 ** Flush script prefetch if required
2110 */
2111 PREFETCH_FLUSH
2112 /*
2113 ** then we do the actual copy.
2114 */
2115 SCR_COPY (sizeof (struct head)),
2116 /*
2117 ** continued after the next label ...
2118 */
2119
2120 }/*-------------------------< LOADPOS1 >-------------------*/,{
2121 0,
2122 NADDR (header),
2123 /*
2124 ** The DSA contains the data structure address.
2125 */
2126 SCR_JUMP,
2127 PADDR (prepare),
2128
2129 }/*-------------------------< RESEL_LUN >-------------------*/,{
2130 /*
2131 ** come back to this point
2132 ** to get an IDENTIFY message
2133 ** Wait for a msg_in phase.
2134 */
2135 SCR_INT ^ IFFALSE (WHEN (SCR_MSG_IN)),
2136 SIR_RESEL_NO_MSG_IN,
2137 /*
2138 ** message phase.
2139 ** Read the data directly from the BUS DATA lines.
2140 ** This helps to support very old SCSI devices that
2141 ** may reselect without sending an IDENTIFY.
2142 */
2143 SCR_FROM_REG (sbdl),
2144 0,
2145 /*
2146 ** It should be an Identify message.
2147 */
2148 SCR_RETURN,
2149 0,
2150 }/*-------------------------< RESEL_TAG >-------------------*/,{
2151 /*
2152 ** Read IDENTIFY + SIMPLE + TAG using a single MOVE.
2153 ** Agressive optimization, is'nt it?
2154 ** No need to test the SIMPLE TAG message, since the
2155 ** driver only supports conformant devices for tags. ;-)
2156 */
2157 SCR_MOVE_ABS (3) ^ SCR_MSG_IN,
2158 NADDR (msgin),
2159 /*
2160 ** Read the TAG from the SIDL.
2161 ** Still an aggressive optimization. ;-)
2162 ** Compute the CCB indirect jump address which
2163 ** is (#TAG*2 & 0xfc) due to tag numbering using
2164 ** 1,3,5..MAXTAGS*2+1 actual values.
2165 */
2166 SCR_REG_SFBR (sidl, SCR_SHL, 0),
2167 0,
2168 SCR_SFBR_REG (temp, SCR_AND, 0xfc),
2169 0,
2170 }/*-------------------------< JUMP_TO_NEXUS >-------------------*/,{
2171 SCR_COPY_F (4),
2172 RADDR (temp),
2173 PADDR (nexus_indirect),
2174 /*
2175 ** Flush script prefetch if required
2176 */
2177 PREFETCH_FLUSH
2178 SCR_COPY (4),
2179 }/*-------------------------< NEXUS_INDIRECT >-------------------*/,{
2180 0,
2181 RADDR (temp),
2182 SCR_RETURN,
2183 0,
2184 }/*-------------------------< RESEL_NOTAG >-------------------*/,{
2185 /*
2186 ** No tag expected.
2187 ** Read an throw away the IDENTIFY.
2188 */
2189 SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2190 NADDR (msgin),
2191 SCR_JUMP,
2192 PADDR (jump_to_nexus),
2193 }/*-------------------------< DATA_IN >--------------------*/,{
2194 /*
2195 ** Because the size depends on the
2196 ** #define MAX_SCATTERL parameter,
2197 ** it is filled in at runtime.
2198 **
2199 ** ##===========< i=0; i<MAX_SCATTERL >=========
2200 ** || SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN)),
2201 ** || PADDR (dispatch),
2202 ** || SCR_MOVE_TBL ^ SCR_DATA_IN,
2203 ** || offsetof (struct dsb, data[ i]),
2204 ** ##==========================================
2205 **
2206 **---------------------------------------------------------
2207 */
2208 0
2209 }/*-------------------------< DATA_IN2 >-------------------*/,{
2210 SCR_CALL,
2211 PADDR (dispatch),
2212 SCR_JUMP,
2213 PADDR (no_data),
2214 }/*-------------------------< DATA_OUT >--------------------*/,{
2215 /*
2216 ** Because the size depends on the
2217 ** #define MAX_SCATTERL parameter,
2218 ** it is filled in at runtime.
2219 **
2220 ** ##===========< i=0; i<MAX_SCATTERL >=========
2221 ** || SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT)),
2222 ** || PADDR (dispatch),
2223 ** || SCR_MOVE_TBL ^ SCR_DATA_OUT,
2224 ** || offsetof (struct dsb, data[ i]),
2225 ** ##==========================================
2226 **
2227 **---------------------------------------------------------
2228 */
2229 0
2230 }/*-------------------------< DATA_OUT2 >-------------------*/,{
2231 SCR_CALL,
2232 PADDR (dispatch),
2233 SCR_JUMP,
2234 PADDR (no_data),
2235 }/*--------------------------------------------------------*/
2236 };
2237
2238 static struct scripth scripth0 __initdata = {
2239 /*-------------------------< TRYLOOP >---------------------*/{
2240 /*
2241 ** Start the next entry.
2242 ** Called addresses point to the launch script in the CCB.
2243 ** They are patched by the main processor.
2244 **
2245 ** Because the size depends on the
2246 ** #define MAX_START parameter, it is filled
2247 ** in at runtime.
2248 **
2249 **-----------------------------------------------------------
2250 **
2251 ** ##===========< I=0; i<MAX_START >===========
2252 ** || SCR_CALL,
2253 ** || PADDR (idle),
2254 ** ##==========================================
2255 **
2256 **-----------------------------------------------------------
2257 */
2258 0
2259 }/*------------------------< TRYLOOP2 >---------------------*/,{
2260 SCR_JUMP,
2261 PADDRH(tryloop),
2262
2263 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
2264
2265 }/*------------------------< DONE_QUEUE >-------------------*/,{
2266 /*
2267 ** Copy the CCB address to the next done entry.
2268 ** Because the size depends on the
2269 ** #define MAX_DONE parameter, it is filled
2270 ** in at runtime.
2271 **
2272 **-----------------------------------------------------------
2273 **
2274 ** ##===========< I=0; i<MAX_DONE >===========
2275 ** || SCR_COPY (sizeof(ccb_p)),
2276 ** || NADDR (header.cp),
2277 ** || NADDR (ccb_done[i]),
2278 ** || SCR_CALL,
2279 ** || PADDR (done_end),
2280 ** ##==========================================
2281 **
2282 **-----------------------------------------------------------
2283 */
2284 0
2285 }/*------------------------< DONE_QUEUE2 >------------------*/,{
2286 SCR_JUMP,
2287 PADDRH (done_queue),
2288
2289 #endif /* SCSI_NCR_CCB_DONE_SUPPORT */
2290 }/*------------------------< SELECT_NO_ATN >-----------------*/,{
2291 /*
2292 ** Set Initiator mode.
2293 ** And try to select this target without ATN.
2294 */
2295
2296 SCR_CLR (SCR_TRG),
2297 0,
2298 SCR_LOAD_REG (HS_REG, HS_SELECTING),
2299 0,
2300 SCR_SEL_TBL ^ offsetof (struct dsb, select),
2301 PADDR (reselect),
2302 SCR_JUMP,
2303 PADDR (select2),
2304
2305 }/*-------------------------< CANCEL >------------------------*/,{
2306
2307 SCR_LOAD_REG (scratcha, HS_ABORTED),
2308 0,
2309 SCR_JUMPR,
2310 8,
2311 }/*-------------------------< SKIP >------------------------*/,{
2312 SCR_LOAD_REG (scratcha, 0),
2313 0,
2314 /*
2315 ** This entry has been canceled.
2316 ** Next time use the next slot.
2317 */
2318 SCR_COPY (4),
2319 RADDR (temp),
2320 PADDR (startpos),
2321 /*
2322 ** The ncr doesn't have an indirect load
2323 ** or store command. So we have to
2324 ** copy part of the control block to a
2325 ** fixed place, where we can access it.
2326 **
2327 ** We patch the address part of a
2328 ** COPY command with the DSA-register.
2329 */
2330 SCR_COPY_F (4),
2331 RADDR (dsa),
2332 PADDRH (skip2),
2333 /*
2334 ** Flush script prefetch if required
2335 */
2336 PREFETCH_FLUSH
2337 /*
2338 ** then we do the actual copy.
2339 */
2340 SCR_COPY (sizeof (struct head)),
2341 /*
2342 ** continued after the next label ...
2343 */
2344 }/*-------------------------< SKIP2 >---------------------*/,{
2345 0,
2346 NADDR (header),
2347 /*
2348 ** Initialize the status registers
2349 */
2350 SCR_COPY (4),
2351 NADDR (header.status),
2352 RADDR (scr0),
2353 /*
2354 ** Force host status.
2355 */
2356 SCR_FROM_REG (scratcha),
2357 0,
2358 SCR_JUMPR ^ IFFALSE (MASK (0, HS_DONEMASK)),
2359 16,
2360 SCR_REG_REG (HS_REG, SCR_OR, HS_SKIPMASK),
2361 0,
2362 SCR_JUMPR,
2363 8,
2364 SCR_TO_REG (HS_REG),
2365 0,
2366 SCR_LOAD_REG (SS_REG, S_GOOD),
2367 0,
2368 SCR_JUMP,
2369 PADDR (cleanup_ok),
2370
2371 },/*-------------------------< PAR_ERR_DATA_IN >---------------*/{
2372 /*
2373 ** Ignore all data in byte, until next phase
2374 */
2375 SCR_JUMP ^ IFFALSE (WHEN (SCR_DATA_IN)),
2376 PADDRH (par_err_other),
2377 SCR_MOVE_ABS (1) ^ SCR_DATA_IN,
2378 NADDR (scratch),
2379 SCR_JUMPR,
2380 -24,
2381 },/*-------------------------< PAR_ERR_OTHER >------------------*/{
2382 /*
2383 ** count it.
2384 */
2385 SCR_REG_REG (PS_REG, SCR_ADD, 0x01),
2386 0,
2387 /*
2388 ** jump to dispatcher.
2389 */
2390 SCR_JUMP,
2391 PADDR (dispatch),
2392 }/*-------------------------< MSG_REJECT >---------------*/,{
2393 /*
2394 ** If a negotiation was in progress,
2395 ** negotiation failed.
2396 ** Otherwise, let the C code print
2397 ** some message.
2398 */
2399 SCR_FROM_REG (HS_REG),
2400 0,
2401 SCR_INT ^ IFFALSE (DATA (HS_NEGOTIATE)),
2402 SIR_REJECT_RECEIVED,
2403 SCR_INT ^ IFTRUE (DATA (HS_NEGOTIATE)),
2404 SIR_NEGO_FAILED,
2405 SCR_JUMP,
2406 PADDR (clrack),
2407
2408 }/*-------------------------< MSG_IGN_RESIDUE >----------*/,{
2409 /*
2410 ** Terminate cycle
2411 */
2412 SCR_CLR (SCR_ACK),
2413 0,
2414 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2415 PADDR (dispatch),
2416 /*
2417 ** get residue size.
2418 */
2419 SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2420 NADDR (msgin[1]),
2421 /*
2422 ** Size is 0 .. ignore message.
2423 */
2424 SCR_JUMP ^ IFTRUE (DATA (0)),
2425 PADDR (clrack),
2426 /*
2427 ** Size is not 1 .. have to interrupt.
2428 */
2429 SCR_JUMPR ^ IFFALSE (DATA (1)),
2430 40,
2431 /*
2432 ** Check for residue byte in swide register
2433 */
2434 SCR_FROM_REG (scntl2),
2435 0,
2436 SCR_JUMPR ^ IFFALSE (MASK (WSR, WSR)),
2437 16,
2438 /*
2439 ** There IS data in the swide register.
2440 ** Discard it.
2441 */
2442 SCR_REG_REG (scntl2, SCR_OR, WSR),
2443 0,
2444 SCR_JUMP,
2445 PADDR (clrack),
2446 /*
2447 ** Load again the size to the sfbr register.
2448 */
2449 SCR_FROM_REG (scratcha),
2450 0,
2451 SCR_INT,
2452 SIR_IGN_RESIDUE,
2453 SCR_JUMP,
2454 PADDR (clrack),
2455
2456 }/*-------------------------< MSG_EXTENDED >-------------*/,{
2457 /*
2458 ** Terminate cycle
2459 */
2460 SCR_CLR (SCR_ACK),
2461 0,
2462 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2463 PADDR (dispatch),
2464 /*
2465 ** get length.
2466 */
2467 SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2468 NADDR (msgin[1]),
2469 /*
2470 */
2471 SCR_JUMP ^ IFTRUE (DATA (3)),
2472 PADDRH (msg_ext_3),
2473 SCR_JUMP ^ IFFALSE (DATA (2)),
2474 PADDR (msg_bad),
2475 }/*-------------------------< MSG_EXT_2 >----------------*/,{
2476 SCR_CLR (SCR_ACK),
2477 0,
2478 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2479 PADDR (dispatch),
2480 /*
2481 ** get extended message code.
2482 */
2483 SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2484 NADDR (msgin[2]),
2485 SCR_JUMP ^ IFTRUE (DATA (M_X_WIDE_REQ)),
2486 PADDRH (msg_wdtr),
2487 /*
2488 ** unknown extended message
2489 */
2490 SCR_JUMP,
2491 PADDR (msg_bad)
2492 }/*-------------------------< MSG_WDTR >-----------------*/,{
2493 SCR_CLR (SCR_ACK),
2494 0,
2495 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2496 PADDR (dispatch),
2497 /*
2498 ** get data bus width
2499 */
2500 SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2501 NADDR (msgin[3]),
2502 /*
2503 ** let the host do the real work.
2504 */
2505 SCR_INT,
2506 SIR_NEGO_WIDE,
2507 /*
2508 ** let the target fetch our answer.
2509 */
2510 SCR_SET (SCR_ATN),
2511 0,
2512 SCR_CLR (SCR_ACK),
2513 0,
2514 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_OUT)),
2515 PADDRH (nego_bad_phase),
2516
2517 }/*-------------------------< SEND_WDTR >----------------*/,{
2518 /*
2519 ** Send the M_X_WIDE_REQ
2520 */
2521 SCR_MOVE_ABS (4) ^ SCR_MSG_OUT,
2522 NADDR (msgout),
2523 SCR_COPY (1),
2524 NADDR (msgout),
2525 NADDR (lastmsg),
2526 SCR_JUMP,
2527 PADDR (msg_out_done),
2528
2529 }/*-------------------------< MSG_EXT_3 >----------------*/,{
2530 SCR_CLR (SCR_ACK),
2531 0,
2532 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2533 PADDR (dispatch),
2534 /*
2535 ** get extended message code.
2536 */
2537 SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2538 NADDR (msgin[2]),
2539 SCR_JUMP ^ IFTRUE (DATA (M_X_SYNC_REQ)),
2540 PADDRH (msg_sdtr),
2541 /*
2542 ** unknown extended message
2543 */
2544 SCR_JUMP,
2545 PADDR (msg_bad)
2546
2547 }/*-------------------------< MSG_SDTR >-----------------*/,{
2548 SCR_CLR (SCR_ACK),
2549 0,
2550 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2551 PADDR (dispatch),
2552 /*
2553 ** get period and offset
2554 */
2555 SCR_MOVE_ABS (2) ^ SCR_MSG_IN,
2556 NADDR (msgin[3]),
2557 /*
2558 ** let the host do the real work.
2559 */
2560 SCR_INT,
2561 SIR_NEGO_SYNC,
2562 /*
2563 ** let the target fetch our answer.
2564 */
2565 SCR_SET (SCR_ATN),
2566 0,
2567 SCR_CLR (SCR_ACK),
2568 0,
2569 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_OUT)),
2570 PADDRH (nego_bad_phase),
2571
2572 }/*-------------------------< SEND_SDTR >-------------*/,{
2573 /*
2574 ** Send the M_X_SYNC_REQ
2575 */
2576 SCR_MOVE_ABS (5) ^ SCR_MSG_OUT,
2577 NADDR (msgout),
2578 SCR_COPY (1),
2579 NADDR (msgout),
2580 NADDR (lastmsg),
2581 SCR_JUMP,
2582 PADDR (msg_out_done),
2583
2584 }/*-------------------------< NEGO_BAD_PHASE >------------*/,{
2585 SCR_INT,
2586 SIR_NEGO_PROTO,
2587 SCR_JUMP,
2588 PADDR (dispatch),
2589
2590 }/*-------------------------< MSG_OUT_ABORT >-------------*/,{
2591 /*
2592 ** After ABORT message,
2593 **
2594 ** expect an immediate disconnect, ...
2595 */
2596 SCR_REG_REG (scntl2, SCR_AND, 0x7f),
2597 0,
2598 SCR_CLR (SCR_ACK|SCR_ATN),
2599 0,
2600 SCR_WAIT_DISC,
2601 0,
2602 /*
2603 ** ... and set the status to "ABORTED"
2604 */
2605 SCR_LOAD_REG (HS_REG, HS_ABORTED),
2606 0,
2607 SCR_JUMP,
2608 PADDR (cleanup),
2609
2610 }/*-------------------------< HDATA_IN >-------------------*/,{
2611 /*
2612 ** Because the size depends on the
2613 ** #define MAX_SCATTERH parameter,
2614 ** it is filled in at runtime.
2615 **
2616 ** ##==< i=MAX_SCATTERL; i<MAX_SCATTERL+MAX_SCATTERH >==
2617 ** || SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN)),
2618 ** || PADDR (dispatch),
2619 ** || SCR_MOVE_TBL ^ SCR_DATA_IN,
2620 ** || offsetof (struct dsb, data[ i]),
2621 ** ##===================================================
2622 **
2623 **---------------------------------------------------------
2624 */
2625 0
2626 }/*-------------------------< HDATA_IN2 >------------------*/,{
2627 SCR_JUMP,
2628 PADDR (data_in),
2629
2630 }/*-------------------------< HDATA_OUT >-------------------*/,{
2631 /*
2632 ** Because the size depends on the
2633 ** #define MAX_SCATTERH parameter,
2634 ** it is filled in at runtime.
2635 **
2636 ** ##==< i=MAX_SCATTERL; i<MAX_SCATTERL+MAX_SCATTERH >==
2637 ** || SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT)),
2638 ** || PADDR (dispatch),
2639 ** || SCR_MOVE_TBL ^ SCR_DATA_OUT,
2640 ** || offsetof (struct dsb, data[ i]),
2641 ** ##===================================================
2642 **
2643 **---------------------------------------------------------
2644 */
2645 0
2646 }/*-------------------------< HDATA_OUT2 >------------------*/,{
2647 SCR_JUMP,
2648 PADDR (data_out),
2649
2650 }/*-------------------------< RESET >----------------------*/,{
2651 /*
2652 ** Send a M_RESET message if bad IDENTIFY
2653 ** received on reselection.
2654 */
2655 SCR_LOAD_REG (scratcha, M_ABORT_TAG),
2656 0,
2657 SCR_JUMP,
2658 PADDRH (abort_resel),
2659 }/*-------------------------< ABORTTAG >-------------------*/,{
2660 /*
2661 ** Abort a wrong tag received on reselection.
2662 */
2663 SCR_LOAD_REG (scratcha, M_ABORT_TAG),
2664 0,
2665 SCR_JUMP,
2666 PADDRH (abort_resel),
2667 }/*-------------------------< ABORT >----------------------*/,{
2668 /*
2669 ** Abort a reselection when no active CCB.
2670 */
2671 SCR_LOAD_REG (scratcha, M_ABORT),
2672 0,
2673 }/*-------------------------< ABORT_RESEL >----------------*/,{
2674 SCR_COPY (1),
2675 RADDR (scratcha),
2676 NADDR (msgout),
2677 SCR_SET (SCR_ATN),
2678 0,
2679 SCR_CLR (SCR_ACK),
2680 0,
2681 /*
2682 ** and send it.
2683 ** we expect an immediate disconnect
2684 */
2685 SCR_REG_REG (scntl2, SCR_AND, 0x7f),
2686 0,
2687 SCR_MOVE_ABS (1) ^ SCR_MSG_OUT,
2688 NADDR (msgout),
2689 SCR_COPY (1),
2690 NADDR (msgout),
2691 NADDR (lastmsg),
2692 SCR_CLR (SCR_ACK|SCR_ATN),
2693 0,
2694 SCR_WAIT_DISC,
2695 0,
2696 SCR_JUMP,
2697 PADDR (start),
2698 }/*-------------------------< RESEND_IDENT >-------------------*/,{
2699 /*
2700 ** The target stays in MSG OUT phase after having acked
2701 ** Identify [+ Tag [+ Extended message ]]. Targets shall
2702 ** behave this way on parity error.
2703 ** We must send it again all the messages.
2704 */
2705 SCR_SET (SCR_ATN), /* Shall be asserted 2 deskew delays before the */
2706 0, /* 1rst ACK = 90 ns. Hope the NCR is'nt too fast */
2707 SCR_JUMP,
2708 PADDR (send_ident),
2709 }/*-------------------------< CLRATN_GO_ON >-------------------*/,{
2710 SCR_CLR (SCR_ATN),
2711 0,
2712 SCR_JUMP,
2713 }/*-------------------------< NXTDSP_GO_ON >-------------------*/,{
2714 0,
2715 }/*-------------------------< SDATA_IN >-------------------*/,{
2716 SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN)),
2717 PADDR (dispatch),
2718 SCR_MOVE_TBL ^ SCR_DATA_IN,
2719 offsetof (struct dsb, sense),
2720 SCR_CALL,
2721 PADDR (dispatch),
2722 SCR_JUMP,
2723 PADDR (no_data),
2724 }/*-------------------------< DATA_IO >--------------------*/,{
2725 /*
2726 ** We jump here if the data direction was unknown at the
2727 ** time we had to queue the command to the scripts processor.
2728 ** Pointers had been set as follow in this situation:
2729 ** savep --> DATA_IO
2730 ** lastp --> start pointer when DATA_IN
2731 ** goalp --> goal pointer when DATA_IN
2732 ** wlastp --> start pointer when DATA_OUT
2733 ** wgoalp --> goal pointer when DATA_OUT
2734 ** This script sets savep/lastp/goalp according to the
2735 ** direction chosen by the target.
2736 */
2737 SCR_JUMPR ^ IFTRUE (WHEN (SCR_DATA_OUT)),
2738 32,
2739 /*
2740 ** Direction is DATA IN.
2741 ** Warning: we jump here, even when phase is DATA OUT.
2742 */
2743 SCR_COPY (4),
2744 NADDR (header.lastp),
2745 NADDR (header.savep),
2746
2747 /*
2748 ** Jump to the SCRIPTS according to actual direction.
2749 */
2750 SCR_COPY (4),
2751 NADDR (header.savep),
2752 RADDR (temp),
2753 SCR_RETURN,
2754 0,
2755 /*
2756 ** Direction is DATA OUT.
2757 */
2758 SCR_COPY (4),
2759 NADDR (header.wlastp),
2760 NADDR (header.lastp),
2761 SCR_COPY (4),
2762 NADDR (header.wgoalp),
2763 NADDR (header.goalp),
2764 SCR_JUMPR,
2765 -64,
2766 }/*-------------------------< BAD_IDENTIFY >---------------*/,{
2767 /*
2768 ** If message phase but not an IDENTIFY,
2769 ** get some help from the C code.
2770 ** Old SCSI device may behave so.
2771 */
2772 SCR_JUMPR ^ IFTRUE (MASK (0x80, 0x80)),
2773 16,
2774 SCR_INT,
2775 SIR_RESEL_NO_IDENTIFY,
2776 SCR_JUMP,
2777 PADDRH (reset),
2778 /*
2779 ** Message is an IDENTIFY, but lun is unknown.
2780 ** Read the message, since we got it directly
2781 ** from the SCSI BUS data lines.
2782 ** Signal problem to C code for logging the event.
2783 ** Send a M_ABORT to clear all pending tasks.
2784 */
2785 SCR_INT,
2786 SIR_RESEL_BAD_LUN,
2787 SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2788 NADDR (msgin),
2789 SCR_JUMP,
2790 PADDRH (abort),
2791 }/*-------------------------< BAD_I_T_L >------------------*/,{
2792 /*
2793 ** We donnot have a task for that I_T_L.
2794 ** Signal problem to C code for logging the event.
2795 ** Send a M_ABORT message.
2796 */
2797 SCR_INT,
2798 SIR_RESEL_BAD_I_T_L,
2799 SCR_JUMP,
2800 PADDRH (abort),
2801 }/*-------------------------< BAD_I_T_L_Q >----------------*/,{
2802 /*
2803 ** We donnot have a task that matches the tag.
2804 ** Signal problem to C code for logging the event.
2805 ** Send a M_ABORTTAG message.
2806 */
2807 SCR_INT,
2808 SIR_RESEL_BAD_I_T_L_Q,
2809 SCR_JUMP,
2810 PADDRH (aborttag),
2811 }/*-------------------------< BAD_TARGET >-----------------*/,{
2812 /*
2813 ** We donnot know the target that reselected us.
2814 ** Grab the first message if any (IDENTIFY).
2815 ** Signal problem to C code for logging the event.
2816 ** M_RESET message.
2817 */
2818 SCR_INT,
2819 SIR_RESEL_BAD_TARGET,
2820 SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_IN)),
2821 8,
2822 SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2823 NADDR (msgin),
2824 SCR_JUMP,
2825 PADDRH (reset),
2826 }/*-------------------------< BAD_STATUS >-----------------*/,{
2827 /*
2828 ** If command resulted in either QUEUE FULL,
2829 ** CHECK CONDITION or COMMAND TERMINATED,
2830 ** call the C code.
2831 */
2832 SCR_INT ^ IFTRUE (DATA (S_QUEUE_FULL)),
2833 SIR_BAD_STATUS,
2834 SCR_INT ^ IFTRUE (DATA (S_CHECK_COND)),
2835 SIR_BAD_STATUS,
2836 SCR_INT ^ IFTRUE (DATA (S_TERMINATED)),
2837 SIR_BAD_STATUS,
2838 SCR_RETURN,
2839 0,
2840 }/*-------------------------< START_RAM >-------------------*/,{
2841 /*
2842 ** Load the script into on-chip RAM,
2843 ** and jump to start point.
2844 */
2845 SCR_COPY_F (4),
2846 RADDR (scratcha),
2847 PADDRH (start_ram0),
2848 /*
2849 ** Flush script prefetch if required
2850 */
2851 PREFETCH_FLUSH
2852 SCR_COPY (sizeof (struct script)),
2853 }/*-------------------------< START_RAM0 >--------------------*/,{
2854 0,
2855 PADDR (start),
2856 SCR_JUMP,
2857 PADDR (start),
2858 }/*-------------------------< STO_RESTART >-------------------*/,{
2859 /*
2860 **
2861 ** Repair start queue (e.g. next time use the next slot)
2862 ** and jump to start point.
2863 */
2864 SCR_COPY (4),
2865 RADDR (temp),
2866 PADDR (startpos),
2867 SCR_JUMP,
2868 PADDR (start),
2869 }/*-------------------------< WAIT_DMA >-------------------*/,{
2870 /*
2871 ** For HP Zalon/53c720 systems, the Zalon interface
2872 ** between CPU and 53c720 does prefetches, which causes
2873 ** problems with self modifying scripts. The problem
2874 ** is overcome by calling a dummy subroutine after each
2875 ** modification, to force a refetch of the script on
2876 ** return from the subroutine.
2877 */
2878 SCR_RETURN,
2879 0,
2880 }/*-------------------------< SNOOPTEST >-------------------*/,{
2881 /*
2882 ** Read the variable.
2883 */
2884 SCR_COPY (4),
2885 NADDR(ncr_cache),
2886 RADDR (scratcha),
2887 /*
2888 ** Write the variable.
2889 */
2890 SCR_COPY (4),
2891 RADDR (temp),
2892 NADDR(ncr_cache),
2893 /*
2894 ** Read back the variable.
2895 */
2896 SCR_COPY (4),
2897 NADDR(ncr_cache),
2898 RADDR (temp),
2899 }/*-------------------------< SNOOPEND >-------------------*/,{
2900 /*
2901 ** And stop.
2902 */
2903 SCR_INT,
2904 99,
2905 }/*--------------------------------------------------------*/
2906 };
2907
2908 /*==========================================================
2909 **
2910 **
2911 ** Fill in #define dependent parts of the script
2912 **
2913 **
2914 **==========================================================
2915 */
2916
2917 void __init ncr_script_fill (struct script * scr, struct scripth * scrh)
2918 {
2919 int i;
2920 ncrcmd *p;
2921
2922 p = scrh->tryloop;
2923 for (i=0; i<MAX_START; i++) {
2924 *p++ =SCR_CALL;
2925 *p++ =PADDR (idle);
2926 };
2927
2928 assert ((u_long)p == (u_long)&scrh->tryloop + sizeof (scrh->tryloop));
2929
2930 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
2931
2932 p = scrh->done_queue;
2933 for (i = 0; i<MAX_DONE; i++) {
2934 *p++ =SCR_COPY (sizeof(ccb_p));
2935 *p++ =NADDR (header.cp);
2936 *p++ =NADDR (ccb_done[i]);
2937 *p++ =SCR_CALL;
2938 *p++ =PADDR (done_end);
2939 }
2940
2941 assert ((u_long)p ==(u_long)&scrh->done_queue+sizeof(scrh->done_queue));
2942
2943 #endif /* SCSI_NCR_CCB_DONE_SUPPORT */
2944
2945 p = scrh->hdata_in;
2946 for (i=0; i<MAX_SCATTERH; i++) {
2947 *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN));
2948 *p++ =PADDR (dispatch);
2949 *p++ =SCR_MOVE_TBL ^ SCR_DATA_IN;
2950 *p++ =offsetof (struct dsb, data[i]);
2951 };
2952 assert ((u_long)p == (u_long)&scrh->hdata_in + sizeof (scrh->hdata_in));
2953
2954 p = scr->data_in;
2955 for (i=MAX_SCATTERH; i<MAX_SCATTERH+MAX_SCATTERL; i++) {
2956 *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN));
2957 *p++ =PADDR (dispatch);
2958 *p++ =SCR_MOVE_TBL ^ SCR_DATA_IN;
2959 *p++ =offsetof (struct dsb, data[i]);
2960 };
2961 assert ((u_long)p == (u_long)&scr->data_in + sizeof (scr->data_in));
2962
2963 p = scrh->hdata_out;
2964 for (i=0; i<MAX_SCATTERH; i++) {
2965 *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT));
2966 *p++ =PADDR (dispatch);
2967 *p++ =SCR_MOVE_TBL ^ SCR_DATA_OUT;
2968 *p++ =offsetof (struct dsb, data[i]);
2969 };
2970 assert ((u_long)p==(u_long)&scrh->hdata_out + sizeof (scrh->hdata_out));
2971
2972 p = scr->data_out;
2973 for (i=MAX_SCATTERH; i<MAX_SCATTERH+MAX_SCATTERL; i++) {
2974 *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT));
2975 *p++ =PADDR (dispatch);
2976 *p++ =SCR_MOVE_TBL ^ SCR_DATA_OUT;
2977 *p++ =offsetof (struct dsb, data[i]);
2978 };
2979
2980 assert ((u_long)p == (u_long)&scr->data_out + sizeof (scr->data_out));
2981 }
2982
2983 /*==========================================================
2984 **
2985 **
2986 ** Copy and rebind a script.
2987 **
2988 **
2989 **==========================================================
2990 */
2991
2992 static void __init
2993 ncr_script_copy_and_bind (ncb_p np, ncrcmd *src, ncrcmd *dst, int len)
2994 {
2995 ncrcmd opcode, new, old, tmp1, tmp2;
2996 ncrcmd *start, *end;
2997 int relocs;
2998 int opchanged = 0;
2999
3000 start = src;
3001 end = src + len/4;
3002
3003 while (src < end) {
3004
3005 opcode = *src++;
3006 *dst++ = cpu_to_scr(opcode);
3007
3008 /*
3009 ** If we forget to change the length
3010 ** in struct script, a field will be
3011 ** padded with 0. This is an illegal
3012 ** command.
3013 */
3014
3015 if (opcode == 0) {
3016 printk (KERN_ERR "%s: ERROR0 IN SCRIPT at %d.\n",
3017 ncr_name(np), (int) (src-start-1));
3018 MDELAY (1000);
3019 };
3020
3021 if (DEBUG_FLAGS & DEBUG_SCRIPT)
3022 printk (KERN_DEBUG "%p: <%x>\n",
3023 (src-1), (unsigned)opcode);
3024
3025 /*
3026 ** We don't have to decode ALL commands
3027 */
3028 switch (opcode >> 28) {
3029
3030 case 0xc:
3031 /*
3032 ** COPY has TWO arguments.
3033 */
3034 relocs = 2;
3035 tmp1 = src[0];
3036 #ifdef RELOC_KVAR
3037 if ((tmp1 & RELOC_MASK) == RELOC_KVAR)
3038 tmp1 = 0;
3039 #endif
3040 tmp2 = src[1];
3041 #ifdef RELOC_KVAR
3042 if ((tmp2 & RELOC_MASK) == RELOC_KVAR)
3043 tmp2 = 0;
3044 #endif
3045 if ((tmp1 ^ tmp2) & 3) {
3046 printk (KERN_ERR"%s: ERROR1 IN SCRIPT at %d.\n",
3047 ncr_name(np), (int) (src-start-1));
3048 MDELAY (1000);
3049 }
3050 /*
3051 ** If PREFETCH feature not enabled, remove
3052 ** the NO FLUSH bit if present.
3053 */
3054 if ((opcode & SCR_NO_FLUSH) && !(np->features & FE_PFEN)) {
3055 dst[-1] = cpu_to_scr(opcode & ~SCR_NO_FLUSH);
3056 ++opchanged;
3057 }
3058 break;
3059
3060 case 0x0:
3061 /*
3062 ** MOVE (absolute address)
3063 */
3064 relocs = 1;
3065 break;
3066
3067 case 0x8:
3068 /*
3069 ** JUMP / CALL
3070 ** don't relocate if relative :-)
3071 */
3072 if (opcode & 0x00800000)
3073 relocs = 0;
3074 else
3075 relocs = 1;
3076 break;
3077
3078 case 0x4:
3079 case 0x5:
3080 case 0x6:
3081 case 0x7:
3082 relocs = 1;
3083 break;
3084
3085 default:
3086 relocs = 0;
3087 break;
3088 };
3089
3090 if (relocs) {
3091 while (relocs--) {
3092 old = *src++;
3093
3094 switch (old & RELOC_MASK) {
3095 case RELOC_REGISTER:
3096 new = (old & ~RELOC_MASK) + np->paddr;
3097 break;
3098 case RELOC_LABEL:
3099 new = (old & ~RELOC_MASK) + np->p_script;
3100 break;
3101 case RELOC_LABELH:
3102 new = (old & ~RELOC_MASK) + np->p_scripth;
3103 break;
3104 case RELOC_SOFTC:
3105 new = (old & ~RELOC_MASK) + np->p_ncb;
3106 break;
3107 #ifdef RELOC_KVAR
3108 case RELOC_KVAR:
3109 if (((old & ~RELOC_MASK) <
3110 SCRIPT_KVAR_FIRST) ||
3111 ((old & ~RELOC_MASK) >
3112 SCRIPT_KVAR_LAST))
3113 panic("ncr KVAR out of range");
3114 new = vtophys(script_kvars[old &
3115 ~RELOC_MASK]);
3116 break;
3117 #endif
3118 case 0:
3119 /* Don't relocate a 0 address. */
3120 if (old == 0) {
3121 new = old;
3122 break;
3123 }
3124 /* fall through */
3125 default:
3126 panic("ncr_script_copy_and_bind: weird relocation %x\n", old);
3127 break;
3128 }
3129
3130 *dst++ = cpu_to_scr(new);
3131 }
3132 } else
3133 *dst++ = cpu_to_scr(*src++);
3134
3135 };
3136 }
3137
3138 /*==========================================================
3139 **
3140 **
3141 ** Auto configuration: attach and init a host adapter.
3142 **
3143 **
3144 **==========================================================
3145 */
3146
3147 /*
3148 ** Linux host data structure
3149 **
3150 ** The script area is allocated in the host data structure
3151 ** because kmalloc() returns NULL during scsi initialisations
3152 ** with Linux 1.2.X
3153 */
3154
3155 struct host_data {
3156 struct ncb *ncb;
3157 };
3158
3159 /*
3160 ** Print something which allows to retrieve the controller type, unit,
3161 ** target, lun concerned by a kernel message.
3162 */
3163
3164 static void PRINT_TARGET(ncb_p np, int target)
3165 {
3166 printk(KERN_INFO "%s-<%d,*>: ", ncr_name(np), target);
3167 }
3168
3169 static void PRINT_LUN(ncb_p np, int target, int lun)
3170 {
3171 printk(KERN_INFO "%s-<%d,%d>: ", ncr_name(np), target, lun);
3172 }
3173
3174 static void PRINT_ADDR(Scsi_Cmnd *cmd)
3175 {
3176 struct host_data *host_data = (struct host_data *) cmd->device->host->hostdata;
3177 PRINT_LUN(host_data->ncb, cmd->device->id, cmd->device->lun);
3178 }
3179
3180 /*==========================================================
3181 **
3182 ** NCR chip clock divisor table.
3183 ** Divisors are multiplied by 10,000,000 in order to make
3184 ** calculations more simple.
3185 **
3186 **==========================================================
3187 */
3188
3189 #define _5M 5000000
3190 static u_long div_10M[] =
3191 {2*_5M, 3*_5M, 4*_5M, 6*_5M, 8*_5M, 12*_5M, 16*_5M};
3192
3193
3194 /*===============================================================
3195 **
3196 ** Prepare io register values used by ncr_init() according
3197 ** to selected and supported features.
3198 **
3199 ** NCR chips allow burst lengths of 2, 4, 8, 16, 32, 64, 128
3200 ** transfers. 32,64,128 are only supported by 875 and 895 chips.
3201 ** We use log base 2 (burst length) as internal code, with
3202 ** value 0 meaning "burst disabled".
3203 **
3204 **===============================================================
3205 */
3206
3207 /*
3208 * Burst length from burst code.
3209 */
3210 #define burst_length(bc) (!(bc))? 0 : 1 << (bc)
3211
3212 /*
3213 * Burst code from io register bits. Burst enable is ctest0 for c720,
3214 * ctest4 for others.
3215 */
3216 #define burst_code(dmode, ctest0, ctest4, ctest5) \
3217 (np->device_id == PSEUDO_720_ID) ? \
3218 (ctest0) & 0x80? 0 : (((dmode) & 0xc0) >> 6) + 1 : \
3219 (ctest4) & 0x80? 0 : (((dmode) & 0xc0) >> 6) + ((ctest5) & 0x04) + 1
3220
3221 /*
3222 * Set initial io register bits from burst code.
3223 */
3224 static inline void ncr_init_burst(ncb_p np, u_char bc)
3225 {
3226 u_char *be = (np->device_id == PSEUDO_720_ID) ?
3227 &np->rv_ctest0 : &np->rv_ctest4;
3228 *be &= ~0x80;
3229 np->rv_dmode &= ~(0x3 << 6);
3230 np->rv_ctest5 &= ~0x4;
3231
3232 if (!bc) {
3233 *be |= 0x80;
3234 }
3235 else {
3236 --bc;
3237 np->rv_dmode |= ((bc & 0x3) << 6);
3238 np->rv_ctest5 |= (bc & 0x4);
3239 }
3240 }
3241
3242 #ifdef SCSI_NCR_NVRAM_SUPPORT
3243
3244 /*
3245 ** Get target set-up from Symbios format NVRAM.
3246 */
3247
3248 static void __init
3249 ncr_Symbios_setup_target(ncb_p np, int target, Symbios_nvram *nvram)
3250 {
3251 tcb_p tp = &np->target[target];
3252 Symbios_target *tn = &nvram->target[target];
3253
3254 tp->usrsync = tn->sync_period ? (tn->sync_period + 3) / 4 : 255;
3255 tp->usrwide = tn->bus_width == 0x10 ? 1 : 0;
3256 tp->usrtags =
3257 (tn->flags & SYMBIOS_QUEUE_TAGS_ENABLED)? MAX_TAGS : 0;
3258
3259 if (!(tn->flags & SYMBIOS_DISCONNECT_ENABLE))
3260 tp->usrflag |= UF_NODISC;
3261 if (!(tn->flags & SYMBIOS_SCAN_AT_BOOT_TIME))
3262 tp->usrflag |= UF_NOSCAN;
3263 }
3264
3265 /*
3266 ** Get target set-up from Tekram format NVRAM.
3267 */
3268
3269 static void __init
3270 ncr_Tekram_setup_target(ncb_p np, int target, Tekram_nvram *nvram)
3271 {
3272 tcb_p tp = &np->target[target];
3273 struct Tekram_target *tn = &nvram->target[target];
3274 int i;
3275
3276 if (tn->flags & TEKRAM_SYNC_NEGO) {
3277 i = tn->sync_index & 0xf;
3278 tp->usrsync = Tekram_sync[i];
3279 }
3280
3281 tp->usrwide = (tn->flags & TEKRAM_WIDE_NEGO) ? 1 : 0;
3282
3283 if (tn->flags & TEKRAM_TAGGED_COMMANDS) {
3284 tp->usrtags = 2 << nvram->max_tags_index;
3285 }
3286
3287 if (!(tn->flags & TEKRAM_DISCONNECT_ENABLE))
3288 tp->usrflag = UF_NODISC;
3289
3290 /* If any device does not support parity, we will not use this option */
3291 if (!(tn->flags & TEKRAM_PARITY_CHECK))
3292 np->rv_scntl0 &= ~0x0a; /* SCSI parity checking disabled */
3293 }
3294 #endif /* SCSI_NCR_NVRAM_SUPPORT */
3295
3296 static int __init ncr_prepare_setting(ncb_p np, ncr_nvram *nvram)
3297 {
3298 u_char burst_max;
3299 u_long period;
3300 int i;
3301
3302 /*
3303 ** Save assumed BIOS setting
3304 */
3305
3306 np->sv_scntl0 = INB(nc_scntl0) & 0x0a;
3307 np->sv_scntl3 = INB(nc_scntl3) & 0x07;
3308 np->sv_dmode = INB(nc_dmode) & 0xce;
3309 np->sv_dcntl = INB(nc_dcntl) & 0xa8;
3310 np->sv_ctest0 = INB(nc_ctest0) & 0x84;
3311 np->sv_ctest3 = INB(nc_ctest3) & 0x01;
3312 np->sv_ctest4 = INB(nc_ctest4) & 0x80;
3313 np->sv_ctest5 = INB(nc_ctest5) & 0x24;
3314 np->sv_gpcntl = INB(nc_gpcntl);
3315 np->sv_stest2 = INB(nc_stest2) & 0x20;
3316 np->sv_stest4 = INB(nc_stest4);
3317
3318 /*
3319 ** Wide ?
3320 */
3321
3322 np->maxwide = (np->features & FE_WIDE)? 1 : 0;
3323
3324 /*
3325 * Guess the frequency of the chip's clock.
3326 */
3327 if (np->features & (FE_ULTRA3 | FE_ULTRA2))
3328 np->clock_khz = 160000;
3329 else if (np->features & FE_ULTRA)
3330 np->clock_khz = 80000;
3331 else
3332 np->clock_khz = 40000;
3333
3334 /*
3335 * Get the clock multiplier factor.
3336 */
3337 if (np->features & FE_QUAD)
3338 np->multiplier = 4;
3339 else if (np->features & FE_DBLR)
3340 np->multiplier = 2;
3341 else
3342 np->multiplier = 1;
3343
3344 /*
3345 * Measure SCSI clock frequency for chips
3346 * it may vary from assumed one.
3347 */
3348 if (np->features & FE_VARCLK)
3349 ncr_getclock(np, np->multiplier);
3350
3351 /*
3352 * Divisor to be used for async (timer pre-scaler).
3353 */
3354 i = np->clock_divn - 1;
3355 while (--i >= 0) {
3356 if (10ul * SCSI_NCR_MIN_ASYNC * np->clock_khz > div_10M[i]) {
3357 ++i;
3358 break;
3359 }
3360 }
3361 np->rv_scntl3 = i+1;
3362
3363 /*
3364 * Minimum synchronous period factor supported by the chip.
3365 * Btw, 'period' is in tenths of nanoseconds.
3366 */
3367
3368 period = (4 * div_10M[0] + np->clock_khz - 1) / np->clock_khz;
3369 if (period <= 250) np->minsync = 10;
3370 else if (period <= 303) np->minsync = 11;
3371 else if (period <= 500) np->minsync = 12;
3372 else np->minsync = (period + 40 - 1) / 40;
3373
3374 /*
3375 * Check against chip SCSI standard support (SCSI-2,ULTRA,ULTRA2).
3376 */
3377
3378 if (np->minsync < 25 && !(np->features & (FE_ULTRA|FE_ULTRA2)))
3379 np->minsync = 25;
3380 else if (np->minsync < 12 && !(np->features & FE_ULTRA2))
3381 np->minsync = 12;
3382
3383 /*
3384 * Maximum synchronous period factor supported by the chip.
3385 */
3386
3387 period = (11 * div_10M[np->clock_divn - 1]) / (4 * np->clock_khz);
3388 np->maxsync = period > 2540 ? 254 : period / 10;
3389
3390 /*
3391 ** Prepare initial value of other IO registers
3392 */
3393 #if defined SCSI_NCR_TRUST_BIOS_SETTING
3394 np->rv_scntl0 = np->sv_scntl0;
3395 np->rv_dmode = np->sv_dmode;
3396 np->rv_dcntl = np->sv_dcntl;
3397 np->rv_ctest0 = np->sv_ctest0;
3398 np->rv_ctest3 = np->sv_ctest3;
3399 np->rv_ctest4 = np->sv_ctest4;
3400 np->rv_ctest5 = np->sv_ctest5;
3401 burst_max = burst_code(np->sv_dmode, np->sv_ctest0, np->sv_ctest4, np->sv_ctest5);
3402 #else
3403
3404 /*
3405 ** Select burst length (dwords)
3406 */
3407 burst_max = driver_setup.burst_max;
3408 if (burst_max == 255)
3409 burst_max = burst_code(np->sv_dmode, np->sv_ctest0, np->sv_ctest4, np->sv_ctest5);
3410 if (burst_max > 7)
3411 burst_max = 7;
3412 if (burst_max > np->maxburst)
3413 burst_max = np->maxburst;
3414
3415 /*
3416 ** Select all supported special features
3417 */
3418 if (np->features & FE_ERL)
3419 np->rv_dmode |= ERL; /* Enable Read Line */
3420 if (np->features & FE_BOF)
3421 np->rv_dmode |= BOF; /* Burst Opcode Fetch */
3422 if (np->features & FE_ERMP)
3423 np->rv_dmode |= ERMP; /* Enable Read Multiple */
3424 if (np->features & FE_PFEN)
3425 np->rv_dcntl |= PFEN; /* Prefetch Enable */
3426 if (np->features & FE_CLSE)
3427 np->rv_dcntl |= CLSE; /* Cache Line Size Enable */
3428 if (np->features & FE_WRIE)
3429 np->rv_ctest3 |= WRIE; /* Write and Invalidate */
3430 if (np->features & FE_DFS)
3431 np->rv_ctest5 |= DFS; /* Dma Fifo Size */
3432 if (np->features & FE_MUX)
3433 np->rv_ctest4 |= MUX; /* Host bus multiplex mode */
3434 if (np->features & FE_EA)
3435 np->rv_dcntl |= EA; /* Enable ACK */
3436 if (np->features & FE_EHP)
3437 np->rv_ctest0 |= EHP; /* Even host parity */
3438
3439 /*
3440 ** Select some other
3441 */
3442 if (driver_setup.master_parity)
3443 np->rv_ctest4 |= MPEE; /* Master parity checking */
3444 if (driver_setup.scsi_parity)
3445 np->rv_scntl0 |= 0x0a; /* full arb., ena parity, par->ATN */
3446
3447 #ifdef SCSI_NCR_NVRAM_SUPPORT
3448 /*
3449 ** Get parity checking, host ID and verbose mode from NVRAM
3450 **/
3451 if (nvram) {
3452 switch(nvram->type) {
3453 case SCSI_NCR_TEKRAM_NVRAM:
3454 np->myaddr = nvram->data.Tekram.host_id & 0x0f;
3455 break;
3456 case SCSI_NCR_SYMBIOS_NVRAM:
3457 if (!(nvram->data.Symbios.flags & SYMBIOS_PARITY_ENABLE))
3458 np->rv_scntl0 &= ~0x0a;
3459 np->myaddr = nvram->data.Symbios.host_id & 0x0f;
3460 if (nvram->data.Symbios.flags & SYMBIOS_VERBOSE_MSGS)
3461 np->verbose += 1;
3462 break;
3463 }
3464 }
3465 #endif
3466 /*
3467 ** Get SCSI addr of host adapter (set by bios?).
3468 */
3469 if (np->myaddr == 255) {
3470 np->myaddr = INB(nc_scid) & 0x07;
3471 if (!np->myaddr)
3472 np->myaddr = SCSI_NCR_MYADDR;
3473 }
3474
3475 #endif /* SCSI_NCR_TRUST_BIOS_SETTING */
3476
3477 /*
3478 * Prepare initial io register bits for burst length
3479 */
3480 ncr_init_burst(np, burst_max);
3481
3482 /*
3483 ** Set SCSI BUS mode.
3484 **
3485 ** - ULTRA2 chips (895/895A/896) report the current
3486 ** BUS mode through the STEST4 IO register.
3487 ** - For previous generation chips (825/825A/875),
3488 ** user has to tell us how to check against HVD,
3489 ** since a 100% safe algorithm is not possible.
3490 */
3491 np->scsi_mode = SMODE_SE;
3492 if (np->features & FE_ULTRA2)
3493 np->scsi_mode = (np->sv_stest4 & SMODE);
3494 else if (np->features & FE_DIFF) {
3495 switch(driver_setup.diff_support) {
3496 case 4: /* Trust previous settings if present, then GPIO3 */
3497 if (np->sv_scntl3) {
3498 if (np->sv_stest2 & 0x20)
3499 np->scsi_mode = SMODE_HVD;
3500 break;
3501 }
3502 case 3: /* SYMBIOS controllers report HVD through GPIO3 */
3503 if (nvram && nvram->type != SCSI_NCR_SYMBIOS_NVRAM)
3504 break;
3505 if (INB(nc_gpreg) & 0x08)
3506 break;
3507 case 2: /* Set HVD unconditionally */
3508 np->scsi_mode = SMODE_HVD;
3509 case 1: /* Trust previous settings for HVD */
3510 if (np->sv_stest2 & 0x20)
3511 np->scsi_mode = SMODE_HVD;
3512 break;
3513 default:/* Don't care about HVD */
3514 break;
3515 }
3516 }
3517 if (np->scsi_mode == SMODE_HVD)
3518 np->rv_stest2 |= 0x20;
3519
3520 /*
3521 ** Set LED support from SCRIPTS.
3522 ** Ignore this feature for boards known to use a
3523 ** specific GPIO wiring and for the 895A or 896
3524 ** that drive the LED directly.
3525 ** Also probe initial setting of GPIO0 as output.
3526 */
3527 if ((driver_setup.led_pin ||
3528 (nvram && nvram->type == SCSI_NCR_SYMBIOS_NVRAM)) &&
3529 !(np->features & FE_LEDC) && !(np->sv_gpcntl & 0x01))
3530 np->features |= FE_LED0;
3531
3532 /*
3533 ** Set irq mode.
3534 */
3535 switch(driver_setup.irqm & 3) {
3536 case 2:
3537 np->rv_dcntl |= IRQM;
3538 break;
3539 case 1:
3540 np->rv_dcntl |= (np->sv_dcntl & IRQM);
3541 break;
3542 default:
3543 break;
3544 }
3545
3546 /*
3547 ** Configure targets according to driver setup.
3548 ** If NVRAM present get targets setup from NVRAM.
3549 ** Allow to override sync, wide and NOSCAN from
3550 ** boot command line.
3551 */
3552 for (i = 0 ; i < MAX_TARGET ; i++) {
3553 tcb_p tp = &np->target[i];
3554
3555 tp->usrsync = 255;
3556 #ifdef SCSI_NCR_NVRAM_SUPPORT
3557 if (nvram) {
3558 switch(nvram->type) {
3559 case SCSI_NCR_TEKRAM_NVRAM:
3560 ncr_Tekram_setup_target(np, i, &nvram->data.Tekram);
3561 break;
3562 case SCSI_NCR_SYMBIOS_NVRAM:
3563 ncr_Symbios_setup_target(np, i, &nvram->data.Symbios);
3564 break;
3565 }
3566 if (driver_setup.use_nvram & 0x2)
3567 tp->usrsync = driver_setup.default_sync;
3568 if (driver_setup.use_nvram & 0x4)
3569 tp->usrwide = driver_setup.max_wide;
3570 if (driver_setup.use_nvram & 0x8)
3571 tp->usrflag &= ~UF_NOSCAN;
3572 }
3573 else {
3574 #else
3575 if (1) {
3576 #endif
3577 tp->usrsync = driver_setup.default_sync;
3578 tp->usrwide = driver_setup.max_wide;
3579 tp->usrtags = MAX_TAGS;
3580 if (!driver_setup.disconnection)
3581 np->target[i].usrflag = UF_NODISC;
3582 }
3583 }
3584
3585 /*
3586 ** Announce all that stuff to user.
3587 */
3588
3589 i = nvram ? nvram->type : 0;
3590 printk(KERN_INFO "%s: %sID %d, Fast-%d%s%s\n", ncr_name(np),
3591 i == SCSI_NCR_SYMBIOS_NVRAM ? "Symbios format NVRAM, " :
3592 (i == SCSI_NCR_TEKRAM_NVRAM ? "Tekram format NVRAM, " : ""),
3593 np->myaddr,
3594 np->minsync < 12 ? 40 : (np->minsync < 25 ? 20 : 10),
3595 (np->rv_scntl0 & 0xa) ? ", Parity Checking" : ", NO Parity",
3596 (np->rv_stest2 & 0x20) ? ", Differential" : "");
3597
3598 if (bootverbose > 1) {
3599 printk (KERN_INFO "%s: initial SCNTL3/DMODE/DCNTL/CTEST3/4/5 = "
3600 "(hex) %02x/%02x/%02x/%02x/%02x/%02x\n",
3601 ncr_name(np), np->sv_scntl3, np->sv_dmode, np->sv_dcntl,
3602 np->sv_ctest3, np->sv_ctest4, np->sv_ctest5);
3603
3604 printk (KERN_INFO "%s: final SCNTL3/DMODE/DCNTL/CTEST3/4/5 = "
3605 "(hex) %02x/%02x/%02x/%02x/%02x/%02x\n",
3606 ncr_name(np), np->rv_scntl3, np->rv_dmode, np->rv_dcntl,
3607 np->rv_ctest3, np->rv_ctest4, np->rv_ctest5);
3608 }
3609
3610 if (bootverbose && np->paddr2)
3611 printk (KERN_INFO "%s: on-chip RAM at 0x%lx\n",
3612 ncr_name(np), np->paddr2);
3613
3614 return 0;
3615 }
3616
3617 /*
3618 ** Host attach and initialisations.
3619 **
3620 ** Allocate host data and ncb structure.
3621 ** Request IO region and remap MMIO region.
3622 ** Do chip initialization.
3623 ** If all is OK, install interrupt handling and
3624 ** start the timer daemon.
3625 */
3626
3627 struct Scsi_Host * __init
3628 ncr_attach (Scsi_Host_Template *tpnt, int unit, ncr_device *device)
3629 {
3630 struct host_data *host_data;
3631 ncb_p np = 0;
3632 struct Scsi_Host *instance = 0;
3633 u_long flags = 0;
3634 ncr_nvram *nvram = device->nvram;
3635 int i;
3636
3637 #ifdef SCSI_NCR_PROC_INFO_SUPPORT
3638 tpnt->proc_info = ncr53c8xx_proc_info,
3639 #endif
3640 tpnt->info = ncr53c8xx_info;
3641 tpnt->queuecommand = ncr53c8xx_queue_command;
3642 tpnt->slave_configure = ncr53c8xx_slave_configure;
3643 tpnt->eh_bus_reset_handler = ncr53c8xx_bus_reset;
3644 tpnt->can_queue = SCSI_NCR_CAN_QUEUE;
3645 tpnt->this_id = 7;
3646 tpnt->sg_tablesize = SCSI_NCR_SG_TABLESIZE;
3647 tpnt->cmd_per_lun = SCSI_NCR_CMD_PER_LUN;
3648 tpnt->use_clustering = DISABLE_CLUSTERING;
3649
3650 if(device->differential)
3651 driver_setup.diff_support = device->differential;
3652
3653 printk(KERN_INFO "ncr53c%s-%d: rev 0x%x on pci bus %d device %d function %d "
3654 #ifdef __sparc__
3655 "irq %s\n",
3656 #else
3657 "irq %d\n",
3658 #endif
3659 device->chip.name, unit, device->chip.revision_id,
3660 device->slot.bus, (device->slot.device_fn & 0xf8) >> 3,
3661 device->slot.device_fn & 7,
3662 #ifdef __sparc__
3663 __irq_itoa(device->slot.irq));
3664 #else
3665 device->slot.irq);
3666 #endif
3667
3668 /*
3669 ** Allocate host_data structure
3670 */
3671 if (!(instance = scsi_host_alloc(tpnt, sizeof(*host_data))))
3672 goto attach_error;
3673 host_data = (struct host_data *) instance->hostdata;
3674
3675 /*
3676 ** Allocate the host control block.
3677 */
3678 np = __m_calloc_dma(device->dev, sizeof(struct ncb), "NCB");
3679 if (!np)
3680 goto attach_error;
3681 NCR_INIT_LOCK_NCB(np);
3682 np->dev = device->dev;
3683 np->p_ncb = vtobus(np);
3684 host_data->ncb = np;
3685
3686 /*
3687 ** Allocate the default CCB.
3688 */
3689 np->ccb = (ccb_p) m_calloc_dma(sizeof(struct ccb), "CCB");
3690 if (!np->ccb)
3691 goto attach_error;
3692
3693 /*
3694 ** Store input informations in the host data structure.
3695 */
3696 strlcpy(np->chip_name, device->chip.name, sizeof(np->chip_name));
3697 np->unit = unit;
3698 np->verbose = driver_setup.verbose;
3699 sprintf(np->inst_name, "ncr53c%s-%d", np->chip_name, np->unit);
3700 np->device_id = device->chip.device_id;
3701 np->revision_id = device->chip.revision_id;
3702 np->bus = device->slot.bus;
3703 np->device_fn = device->slot.device_fn;
3704 np->features = device->chip.features;
3705 np->clock_divn = device->chip.nr_divisor;
3706 np->maxoffs = device->chip.offset_max;
3707 np->maxburst = device->chip.burst_max;
3708 np->myaddr = device->host_id;
3709
3710 /*
3711 ** Allocate SCRIPTS areas.
3712 */
3713 np->script0 = (struct script *)
3714 m_calloc_dma(sizeof(struct script), "SCRIPT");
3715 if (!np->script0)
3716 goto attach_error;
3717 np->scripth0 = (struct scripth *)
3718 m_calloc_dma(sizeof(struct scripth), "SCRIPTH");
3719 if (!np->scripth0)
3720 goto attach_error;
3721
3722 /*
3723 ** Initialize timer structure
3724 **
3725 */
3726 init_timer(&np->timer);
3727 np->timer.data = (unsigned long) np;
3728 np->timer.function = ncr53c8xx_timeout;
3729
3730 /*
3731 ** Try to map the controller chip to
3732 ** virtual and physical memory.
3733 */
3734
3735 np->paddr = device->slot.base;
3736 np->paddr2 = (np->features & FE_RAM)? device->slot.base_2 : 0;
3737
3738 #ifndef SCSI_NCR_IOMAPPED
3739 if(device->slot.base_v)
3740 np->vaddr = device->slot.base_v;
3741 else
3742 np->vaddr = remap_pci_mem(device->slot.base_c, (u_long) 128);
3743
3744 if (!np->vaddr) {
3745 printk(KERN_ERR
3746 "%s: can't map memory mapped IO region\n",ncr_name(np));
3747 goto attach_error;
3748 }
3749 else
3750 if (bootverbose > 1)
3751 printk(KERN_INFO
3752 "%s: using memory mapped IO at virtual address 0x%lx\n", ncr_name(np), (u_long) np->vaddr);
3753
3754 /*
3755 ** Make the controller's registers available.
3756 ** Now the INB INW INL OUTB OUTW OUTL macros
3757 ** can be used safely.
3758 */
3759
3760 np->reg = (struct ncr_reg*) np->vaddr;
3761
3762 #else
3763
3764 /*
3765 ** Try to map the controller chip into iospace.
3766 */
3767
3768 np->base_io = device->slot.io_port;
3769 #endif /* !defined SCSI_NCR_IOMAPPED */
3770
3771 #ifdef SCSI_NCR_NVRAM_SUPPORT
3772 if (nvram) {
3773 switch(nvram->type) {
3774 case SCSI_NCR_SYMBIOS_NVRAM:
3775 #ifdef SCSI_NCR_DEBUG_NVRAM
3776 ncr_display_Symbios_nvram(&nvram->data.Symbios);
3777 #endif
3778 break;
3779 case SCSI_NCR_TEKRAM_NVRAM:
3780 #ifdef SCSI_NCR_DEBUG_NVRAM
3781 ncr_display_Tekram_nvram(&nvram->data.Tekram);
3782 #endif
3783 break;
3784 default:
3785 nvram = 0;
3786 #ifdef SCSI_NCR_DEBUG_NVRAM
3787 printk(KERN_DEBUG "%s: NVRAM: None or invalid data.\n", ncr_name(np));
3788 #endif
3789 }
3790 }
3791 #endif
3792
3793 /*
3794 ** Do chip dependent initialization.
3795 */
3796 (void)ncr_prepare_setting(np, nvram);
3797
3798 if (np->paddr2 && sizeof(struct script) > 4096) {
3799 np->paddr2 = 0;
3800 printk(KERN_WARNING "%s: script too large, NOT using on chip RAM.\n",
3801 ncr_name(np));
3802 }
3803
3804 /*
3805 ** Fill Linux host instance structure
3806 */
3807 instance->max_channel = 0;
3808 instance->this_id = np->myaddr;
3809 instance->max_id = np->maxwide ? 16 : 8;
3810 instance->max_lun = SCSI_NCR_MAX_LUN;
3811 #ifndef SCSI_NCR_IOMAPPED
3812 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,29)
3813 instance->base = (unsigned long) np->reg;
3814 #else
3815 instance->base = (char *) np->reg;
3816 #endif
3817 #endif
3818 instance->irq = device->slot.irq;
3819 instance->unique_id = device->slot.io_port;
3820 instance->io_port = device->slot.io_port;
3821 instance->n_io_port = 128;
3822 instance->dma_channel = 0;
3823 instance->cmd_per_lun = MAX_TAGS;
3824 instance->can_queue = (MAX_START-4);
3825 scsi_set_device(instance, device->dev);
3826
3827 #ifdef SCSI_NCR_INTEGRITY_CHECKING
3828 np->check_integrity = 0;
3829 instance->check_integrity = 0;
3830
3831 #ifdef SCSI_NCR_ENABLE_INTEGRITY_CHECK
3832 if ( !(driver_setup.bus_check & 0x04) ) {
3833 np->check_integrity = 1;
3834 instance->check_integrity = 1;
3835 }
3836 #endif
3837 #endif
3838 /*
3839 ** Patch script to physical addresses
3840 */
3841 ncr_script_fill (&script0, &scripth0);
3842
3843 np->scripth = np->scripth0;
3844 np->p_scripth = vtobus(np->scripth);
3845
3846 np->p_script = (np->paddr2) ? np->paddr2 : vtobus(np->script0);
3847
3848 ncr_script_copy_and_bind (np, (ncrcmd *) &script0, (ncrcmd *) np->script0, sizeof(struct script));
3849 ncr_script_copy_and_bind (np, (ncrcmd *) &scripth0, (ncrcmd *) np->scripth0, sizeof(struct scripth));
3850 np->ccb->p_ccb = vtobus (np->ccb);
3851
3852 /*
3853 ** Patch the script for LED support.
3854 */
3855
3856 if (np->features & FE_LED0) {
3857 np->script0->idle[0] =
3858 cpu_to_scr(SCR_REG_REG(gpreg, SCR_OR, 0x01));
3859 np->script0->reselected[0] =
3860 cpu_to_scr(SCR_REG_REG(gpreg, SCR_AND, 0xfe));
3861 np->script0->start[0] =
3862 cpu_to_scr(SCR_REG_REG(gpreg, SCR_AND, 0xfe));
3863 }
3864
3865 /*
3866 ** Look for the target control block of this nexus.
3867 ** For i = 0 to 3
3868 ** JUMP ^ IFTRUE (MASK (i, 3)), @(next_lcb)
3869 */
3870 for (i = 0 ; i < 4 ; i++) {
3871 np->jump_tcb[i].l_cmd =
3872 cpu_to_scr((SCR_JUMP ^ IFTRUE (MASK (i, 3))));
3873 np->jump_tcb[i].l_paddr =
3874 cpu_to_scr(NCB_SCRIPTH_PHYS (np, bad_target));
3875 }
3876
3877 /*
3878 ** Reset chip.
3879 */
3880 ncr_chip_reset(np, 100);
3881
3882 /*
3883 ** Now check the cache handling of the pci chipset.
3884 */
3885
3886 if (ncr_snooptest (np)) {
3887 printk (KERN_ERR "CACHE INCORRECTLY CONFIGURED.\n");
3888 goto attach_error;
3889 };
3890
3891 /*
3892 ** Install the interrupt handler.
3893 */
3894
3895 np->irq = device->slot.irq;
3896
3897 /*
3898 ** Initialize the fixed part of the default ccb.
3899 */
3900 ncr_init_ccb(np, np->ccb);
3901
3902 /*
3903 ** After SCSI devices have been opened, we cannot
3904 ** reset the bus safely, so we do it here.
3905 ** Interrupt handler does the real work.
3906 ** Process the reset exception,
3907 ** if interrupts are not enabled yet.
3908 ** Then enable disconnects.
3909 */
3910 NCR_LOCK_NCB(np, flags);
3911 if (ncr_reset_scsi_bus(np, 0, driver_setup.settle_delay) != 0) {
3912 printk(KERN_ERR "%s: FATAL ERROR: CHECK SCSI BUS - CABLES, TERMINATION, DEVICE POWER etc.!\n", ncr_name(np));
3913
3914 NCR_UNLOCK_NCB(np, flags);
3915 goto attach_error;
3916 }
3917 ncr_exception (np);
3918
3919 np->disc = 1;
3920
3921 /*
3922 ** The middle-level SCSI driver does not
3923 ** wait for devices to settle.
3924 ** Wait synchronously if more than 2 seconds.
3925 */
3926 if (driver_setup.settle_delay > 2) {
3927 printk(KERN_INFO "%s: waiting %d seconds for scsi devices to settle...\n",
3928 ncr_name(np), driver_setup.settle_delay);
3929 MDELAY (1000 * driver_setup.settle_delay);
3930 }
3931
3932 /*
3933 ** Now let the generic SCSI driver
3934 ** look for the SCSI devices on the bus ..
3935 */
3936
3937 /*
3938 ** start the timeout daemon
3939 */
3940 np->lasttime=0;
3941 ncr_timeout (np);
3942
3943 /*
3944 ** use SIMPLE TAG messages by default
3945 */
3946 #ifdef SCSI_NCR_ALWAYS_SIMPLE_TAG
3947 np->order = M_SIMPLE_TAG;
3948 #endif
3949
3950 /*
3951 ** Done.
3952 */
3953 if (!the_template) {
3954 the_template = instance->hostt;
3955 first_host = instance;
3956 }
3957
3958 NCR_UNLOCK_NCB(np, flags);
3959
3960 return instance;
3961
3962 attach_error:
3963 if (!instance) return NULL;
3964 printk(KERN_INFO "%s: detaching...\n", ncr_name(np));
3965 if (!np)
3966 goto unregister;
3967 if (np->scripth0)
3968 m_free_dma(np->scripth0, sizeof(struct scripth), "SCRIPTH");
3969 if (np->script0)
3970 m_free_dma(np->script0, sizeof(struct script), "SCRIPT");
3971 if (np->ccb)
3972 m_free_dma(np->ccb, sizeof(struct ccb), "CCB");
3973 m_free_dma(np, sizeof(struct ncb), "NCB");
3974
3975 unregister:
3976 scsi_host_put(instance);
3977
3978 return NULL;
3979 }
3980
3981
3982 /*==========================================================
3983 **
3984 **
3985 ** Done SCSI commands list management.
3986 **
3987 ** We donnot enter the scsi_done() callback immediately
3988 ** after a command has been seen as completed but we
3989 ** insert it into a list which is flushed outside any kind
3990 ** of driver critical section.
3991 ** This allows to do minimal stuff under interrupt and
3992 ** inside critical sections and to also avoid locking up
3993 ** on recursive calls to driver entry points under SMP.
3994 ** In fact, the only kernel point which is entered by the
3995 ** driver with a driver lock set is kmalloc(GFP_ATOMIC)
3996 ** that shall not reenter the driver under any circumstances,
3997 ** AFAIK.
3998 **
3999 **==========================================================
4000 */
4001 static inline void ncr_queue_done_cmd(ncb_p np, Scsi_Cmnd *cmd)
4002 {
4003 unmap_scsi_data(np, cmd);
4004 cmd->host_scribble = (char *) np->done_list;
4005 np->done_list = cmd;
4006 }
4007
4008 static inline void ncr_flush_done_cmds(Scsi_Cmnd *lcmd)
4009 {
4010 Scsi_Cmnd *cmd;
4011
4012 while (lcmd) {
4013 cmd = lcmd;
4014 lcmd = (Scsi_Cmnd *) cmd->host_scribble;
4015 cmd->scsi_done(cmd);
4016 }
4017 }
4018
4019 /*==========================================================
4020 **
4021 **
4022 ** Prepare the next negotiation message for integrity check,
4023 ** if needed.
4024 **
4025 ** Fill in the part of message buffer that contains the
4026 ** negotiation and the nego_status field of the CCB.
4027 ** Returns the size of the message in bytes.
4028 **
4029 **
4030 **==========================================================
4031 */
4032
4033 #ifdef SCSI_NCR_INTEGRITY_CHECKING
4034 static int ncr_ic_nego(ncb_p np, ccb_p cp, Scsi_Cmnd *cmd, u_char *msgptr)
4035 {
4036 tcb_p tp = &np->target[cp->target];
4037 int msglen = 0;
4038 int nego = 0;
4039 u_char no_increase;
4040
4041 if (tp->inq_done) {
4042
4043 if (!tp->ic_maximums_set) {
4044 tp->ic_maximums_set = 1;
4045
4046 /* check target and host adapter capabilities */
4047 if ( (tp->inq_byte7 & INQ7_WIDE16) &&
4048 np->maxwide && tp->usrwide )
4049 tp->ic_max_width = 1;
4050 else
4051 tp->ic_max_width = 0;
4052
4053 if ((tp->inq_byte7 & INQ7_SYNC) && tp->maxoffs) {
4054 tp->ic_min_sync = (tp->minsync < np->minsync) ?
4055 np->minsync : tp->minsync;
4056 }
4057 else
4058 tp->ic_min_sync = 255;
4059
4060 tp->period = 1;
4061 tp->widedone = 1;
4062 }
4063
4064 if (DEBUG_FLAGS & DEBUG_IC) {
4065 printk("%s: cmd->ic_nego %d, 1st byte 0x%2X\n",
4066 ncr_name(np), cmd->ic_nego, cmd->cmnd[0]);
4067 }
4068
4069 /* First command from integrity check routine will request
4070 * a PPR message. Disable.
4071 */
4072 if ((cmd->ic_nego & NS_PPR) == NS_PPR)
4073 cmd->ic_nego &= ~NS_PPR;
4074 /* Previous command recorded a parity or an initiator
4075 * detected error condition. Force bus to narrow for this
4076 * target. Clear flag. Negotation on request sense.
4077 * Note: kernel forces 2 bus resets :o( but clears itself out.
4078 * Minor bug? in scsi_obsolete.c (ugly)
4079 */
4080 if (np->check_integ_par) {
4081 printk("%s: Parity Error. Target set to narrow.\n",
4082 ncr_name(np));
4083 tp->ic_max_width = 0;
4084 tp->widedone = tp->period = 0;
4085 }
4086
4087 /* In case of a bus reset, ncr_negotiate will reset
4088 * the flags tp->widedone and tp->period to 0, forcing
4089 * a new negotiation.
4090 */
4091 no_increase = 0;
4092 if (tp->widedone == 0) {
4093 cmd->ic_nego = NS_WIDE;
4094 tp->widedone = 1;
4095 no_increase = 1;
4096 }
4097 else if (tp->period == 0) {
4098 cmd->ic_nego = NS_SYNC;
4099 tp->period = 1;
4100 no_increase = 1;
4101 }
4102
4103 switch (cmd->ic_nego) {
4104 case NS_WIDE:
4105 /*
4106 ** negotiate wide transfers ?
4107 ** Do NOT negotiate if device only supports
4108 ** narrow.
4109 */
4110 if (tp->ic_max_width | np->check_integ_par) {
4111 nego = NS_WIDE;
4112
4113 msgptr[msglen++] = M_EXTENDED;
4114 msgptr[msglen++] = 2;
4115 msgptr[msglen++] = M_X_WIDE_REQ;
4116 msgptr[msglen++] = cmd->ic_nego_width & tp->ic_max_width;
4117 }
4118 else
4119 cmd->ic_nego_width &= tp->ic_max_width;
4120
4121 break;
4122
4123 case NS_SYNC:
4124 /*
4125 ** negotiate synchronous transfers?
4126 ** Target must support sync transfers.
4127 **
4128 ** If period becomes longer than max, reset to async
4129 */
4130
4131 if (tp->inq_byte7 & INQ7_SYNC) {
4132
4133 nego = NS_SYNC;
4134
4135 msgptr[msglen++] = M_EXTENDED;
4136 msgptr[msglen++] = 3;
4137 msgptr[msglen++] = M_X_SYNC_REQ;
4138
4139 switch (cmd->ic_nego_sync) {
4140 case 2: /* increase the period */
4141 if (!no_increase) {
4142 if (tp->ic_min_sync <= 0x0A)
4143 tp->ic_min_sync = 0x0C;
4144 else if (tp->ic_min_sync <= 0x0C)
4145 tp->ic_min_sync = 0x19;
4146 else if (tp->ic_min_sync <= 0x19)
4147 tp->ic_min_sync *= 2;
4148 else {
4149 tp->ic_min_sync = 255;
4150 cmd->ic_nego_sync = 0;
4151 tp->maxoffs = 0;
4152 }
4153 }
4154 msgptr[msglen++] = tp->maxoffs?tp->ic_min_sync:0;
4155 msgptr[msglen++] = tp->maxoffs;
4156 break;
4157
4158 case 1: /* nego. to maximum */
4159 msgptr[msglen++] = tp->maxoffs?tp->ic_min_sync:0;
4160 msgptr[msglen++] = tp->maxoffs;
4161 break;
4162
4163 case 0: /* nego to async */
4164 default:
4165 msgptr[msglen++] = 0;
4166 msgptr[msglen++] = 0;
4167 break;
4168 };
4169 }
4170 else
4171 cmd->ic_nego_sync = 0;
4172 break;
4173
4174 case NS_NOCHANGE:
4175 default:
4176 break;
4177 };
4178 };
4179
4180 cp->nego_status = nego;
4181 np->check_integ_par = 0;
4182
4183 if (nego) {
4184 tp->nego_cp = cp;
4185 if (DEBUG_FLAGS & DEBUG_NEGO) {
4186 ncr_print_msg(cp, nego == NS_WIDE ?
4187 "wide/narrow msgout": "sync/async msgout", msgptr);
4188 };
4189 };
4190
4191 return msglen;
4192 }
4193 #endif /* SCSI_NCR_INTEGRITY_CHECKING */
4194
4195 /*==========================================================
4196 **
4197 **
4198 ** Prepare the next negotiation message if needed.
4199 **
4200 ** Fill in the part of message buffer that contains the
4201 ** negotiation and the nego_status field of the CCB.
4202 ** Returns the size of the message in bytes.
4203 **
4204 **
4205 **==========================================================
4206 */
4207
4208
4209 static int ncr_prepare_nego(ncb_p np, ccb_p cp, u_char *msgptr)
4210 {
4211 tcb_p tp = &np->target[cp->target];
4212 int msglen = 0;
4213 int nego = 0;
4214
4215 if (tp->inq_done) {
4216
4217 /*
4218 ** negotiate wide transfers ?
4219 */
4220
4221 if (!tp->widedone) {
4222 if (tp->inq_byte7 & INQ7_WIDE16) {
4223 nego = NS_WIDE;
4224 #ifdef SCSI_NCR_INTEGRITY_CHECKING
4225 if (tp->ic_done)
4226 tp->usrwide &= tp->ic_max_width;
4227 #endif
4228 } else
4229 tp->widedone=1;
4230
4231 };
4232
4233 /*
4234 ** negotiate synchronous transfers?
4235 */
4236
4237 if (!nego && !tp->period) {
4238 if (tp->inq_byte7 & INQ7_SYNC) {
4239 nego = NS_SYNC;
4240 #ifdef SCSI_NCR_INTEGRITY_CHECKING
4241 if ((tp->ic_done) &&
4242 (tp->minsync < tp->ic_min_sync))
4243 tp->minsync = tp->ic_min_sync;
4244 #endif
4245 } else {
4246 tp->period =0xffff;
4247 PRINT_TARGET(np, cp->target);
4248 printk ("target did not report SYNC.\n");
4249 };
4250 };
4251 };
4252
4253 switch (nego) {
4254 case NS_SYNC:
4255 msgptr[msglen++] = M_EXTENDED;
4256 msgptr[msglen++] = 3;
4257 msgptr[msglen++] = M_X_SYNC_REQ;
4258 msgptr[msglen++] = tp->maxoffs ? tp->minsync : 0;
4259 msgptr[msglen++] = tp->maxoffs;
4260 break;
4261 case NS_WIDE:
4262 msgptr[msglen++] = M_EXTENDED;
4263 msgptr[msglen++] = 2;
4264 msgptr[msglen++] = M_X_WIDE_REQ;
4265 msgptr[msglen++] = tp->usrwide;
4266 break;
4267 };
4268
4269 cp->nego_status = nego;
4270
4271 if (nego) {
4272 tp->nego_cp = cp;
4273 if (DEBUG_FLAGS & DEBUG_NEGO) {
4274 ncr_print_msg(cp, nego == NS_WIDE ?
4275 "wide msgout":"sync_msgout", msgptr);
4276 };
4277 };
4278
4279 return msglen;
4280 }
4281
4282
4283
4284 /*==========================================================
4285 **
4286 **
4287 ** Start execution of a SCSI command.
4288 ** This is called from the generic SCSI driver.
4289 **
4290 **
4291 **==========================================================
4292 */
4293 static int ncr_queue_command (ncb_p np, Scsi_Cmnd *cmd)
4294 {
4295 /* Scsi_Device *device = cmd->device; */
4296 tcb_p tp = &np->target[cmd->device->id];
4297 lcb_p lp = tp->lp[cmd->device->lun];
4298 ccb_p cp;
4299
4300 int segments;
4301 u_char idmsg, *msgptr;
4302 u_int msglen;
4303 int direction;
4304 u_int32 lastp, goalp;
4305
4306 /*---------------------------------------------
4307 **
4308 ** Some shortcuts ...
4309 **
4310 **---------------------------------------------
4311 */
4312 if ((cmd->device->id == np->myaddr ) ||
4313 (cmd->device->id >= MAX_TARGET) ||
4314 (cmd->device->lun >= MAX_LUN )) {
4315 return(DID_BAD_TARGET);
4316 }
4317
4318 /*---------------------------------------------
4319 **
4320 ** Complete the 1st TEST UNIT READY command
4321 ** with error condition if the device is
4322 ** flagged NOSCAN, in order to speed up
4323 ** the boot.
4324 **
4325 **---------------------------------------------
4326 */
4327 if ((cmd->cmnd[0] == 0 || cmd->cmnd[0] == 0x12) &&
4328 (tp->usrflag & UF_NOSCAN)) {
4329 tp->usrflag &= ~UF_NOSCAN;
4330 return DID_BAD_TARGET;
4331 }
4332
4333 if (DEBUG_FLAGS & DEBUG_TINY) {
4334 PRINT_ADDR(cmd);
4335 printk ("CMD=%x ", cmd->cmnd[0]);
4336 }
4337
4338 /*---------------------------------------------------
4339 **
4340 ** Assign a ccb / bind cmd.
4341 ** If resetting, shorten settle_time if necessary
4342 ** in order to avoid spurious timeouts.
4343 ** If resetting or no free ccb,
4344 ** insert cmd into the waiting list.
4345 **
4346 **----------------------------------------------------
4347 */
4348 if (np->settle_time && cmd->timeout_per_command >= HZ) {
4349 u_long tlimit = ktime_get(cmd->timeout_per_command - HZ);
4350 if (ktime_dif(np->settle_time, tlimit) > 0)
4351 np->settle_time = tlimit;
4352 }
4353
4354 if (np->settle_time || !(cp=ncr_get_ccb (np, cmd->device->id, cmd->device->lun))) {
4355 insert_into_waiting_list(np, cmd);
4356 return(DID_OK);
4357 }
4358 cp->cmd = cmd;
4359
4360 /*---------------------------------------------------
4361 **
4362 ** Enable tagged queue if asked by scsi ioctl
4363 **
4364 **----------------------------------------------------
4365 */
4366 #if 0 /* This stuff was only useful for linux-1.2.13 */
4367 if (lp && !lp->numtags && cmd->device && cmd->device->tagged_queue) {
4368 lp->numtags = tp->usrtags;
4369 ncr_setup_tags (np, cmd->device->id, cmd->device->lun);
4370 }
4371 #endif
4372
4373 /*----------------------------------------------------
4374 **
4375 ** Build the identify / tag / sdtr message
4376 **
4377 **----------------------------------------------------
4378 */
4379
4380 idmsg = M_IDENTIFY | cmd->device->lun;
4381
4382 if (cp ->tag != NO_TAG ||
4383 (cp != np->ccb && np->disc && !(tp->usrflag & UF_NODISC)))
4384 idmsg |= 0x40;
4385
4386 msgptr = cp->scsi_smsg;
4387 msglen = 0;
4388 msgptr[msglen++] = idmsg;
4389
4390 if (cp->tag != NO_TAG) {
4391 char order = np->order;
4392
4393 /*
4394 ** Force ordered tag if necessary to avoid timeouts
4395 ** and to preserve interactivity.
4396 */
4397 if (lp && ktime_exp(lp->tags_stime)) {
4398 if (lp->tags_smap) {
4399 order = M_ORDERED_TAG;
4400 if ((DEBUG_FLAGS & DEBUG_TAGS)||bootverbose>2){
4401 PRINT_ADDR(cmd);
4402 printk("ordered tag forced.\n");
4403 }
4404 }
4405 lp->tags_stime = ktime_get(3*HZ);
4406 lp->tags_smap = lp->tags_umap;
4407 }
4408
4409 if (order == 0) {
4410 /*
4411 ** Ordered write ops, unordered read ops.
4412 */
4413 switch (cmd->cmnd[0]) {
4414 case 0x08: /* READ_SMALL (6) */
4415 case 0x28: /* READ_BIG (10) */
4416 case 0xa8: /* READ_HUGE (12) */
4417 order = M_SIMPLE_TAG;
4418 break;
4419 default:
4420 order = M_ORDERED_TAG;
4421 }
4422 }
4423 msgptr[msglen++] = order;
4424 /*
4425 ** Actual tags are numbered 1,3,5,..2*MAXTAGS+1,
4426 ** since we may have to deal with devices that have
4427 ** problems with #TAG 0 or too great #TAG numbers.
4428 */
4429 msgptr[msglen++] = (cp->tag << 1) + 1;
4430 }
4431
4432 /*----------------------------------------------------
4433 **
4434 ** Build the data descriptors
4435 **
4436 **----------------------------------------------------
4437 */
4438
4439 direction = scsi_data_direction(cmd);
4440 if (direction != SCSI_DATA_NONE) {
4441 segments = ncr_scatter (np, cp, cp->cmd);
4442 if (segments < 0) {
4443 ncr_free_ccb(np, cp);
4444 return(DID_ERROR);
4445 }
4446 }
4447 else {
4448 cp->data_len = 0;
4449 segments = 0;
4450 }
4451
4452 /*---------------------------------------------------
4453 **
4454 ** negotiation required?
4455 **
4456 ** (nego_status is filled by ncr_prepare_nego())
4457 **
4458 **---------------------------------------------------
4459 */
4460
4461 cp->nego_status = 0;
4462
4463 #ifdef SCSI_NCR_INTEGRITY_CHECKING
4464 if ((np->check_integrity && tp->ic_done) || !np->check_integrity) {
4465 if ((!tp->widedone || !tp->period) && !tp->nego_cp && lp) {
4466 msglen += ncr_prepare_nego (np, cp, msgptr + msglen);
4467 }
4468 }
4469 else if (np->check_integrity && (cmd->ic_in_progress)) {
4470 msglen += ncr_ic_nego (np, cp, cmd, msgptr + msglen);
4471 }
4472 else if (np->check_integrity && cmd->ic_complete) {
4473 /*
4474 * Midlayer signal to the driver that all of the scsi commands
4475 * for the integrity check have completed. Save the negotiated
4476 * parameters (extracted from sval and wval).
4477 */
4478
4479 {
4480 u_char idiv;
4481 idiv = (tp->wval>>4) & 0x07;
4482 if ((tp->sval&0x1f) && idiv )
4483 tp->period = (((tp->sval>>5)+4)
4484 *div_10M[idiv-1])/np->clock_khz;
4485 else
4486 tp->period = 0xffff;
4487 }
4488 /*
4489 * tp->period contains 10 times the transfer period,
4490 * which itself is 4 * the requested negotiation rate.
4491 */
4492 if (tp->period <= 250) tp->ic_min_sync = 10;
4493 else if (tp->period <= 303) tp->ic_min_sync = 11;
4494 else if (tp->period <= 500) tp->ic_min_sync = 12;
4495 else
4496 tp->ic_min_sync = (tp->period + 40 - 1) / 40;
4497
4498
4499 /*
4500 * Negotiation for this target it complete.
4501 */
4502 tp->ic_max_width = (tp->wval & EWS) ? 1: 0;
4503 tp->ic_done = 1;
4504 tp->widedone = 1;
4505
4506 printk("%s: Integrity Check Complete: \n", ncr_name(np));
4507
4508 printk("%s: %s %s SCSI", ncr_name(np),
4509 (tp->sval&0x1f)?"SYNC":"ASYNC",
4510 tp->ic_max_width?"WIDE":"NARROW");
4511
4512 if (tp->sval&0x1f) {
4513 u_long mbs = 10000 * (tp->ic_max_width + 1);
4514
4515 printk(" %d.%d MB/s",
4516 (int) (mbs / tp->period), (int) (mbs % tp->period));
4517
4518 printk(" (%d ns, %d offset)\n",
4519 tp->period/10, tp->sval&0x1f);
4520 }
4521 else
4522 printk(" %d MB/s. \n ", (tp->ic_max_width+1)*5);
4523 }
4524 #else
4525 if ((!tp->widedone || !tp->period) && !tp->nego_cp && lp) {
4526 msglen += ncr_prepare_nego (np, cp, msgptr + msglen);
4527 }
4528 #endif /* SCSI_NCR_INTEGRITY_CHECKING */
4529
4530 /*----------------------------------------------------
4531 **
4532 ** Determine xfer direction.
4533 **
4534 **----------------------------------------------------
4535 */
4536 if (!cp->data_len)
4537 direction = SCSI_DATA_NONE;
4538
4539 /*
4540 ** If data direction is UNKNOWN, speculate DATA_READ
4541 ** but prepare alternate pointers for WRITE in case
4542 ** of our speculation will be just wrong.
4543 ** SCRIPTS will swap values if needed.
4544 */
4545 switch(direction) {
4546 case SCSI_DATA_UNKNOWN:
4547 case SCSI_DATA_WRITE:
4548 goalp = NCB_SCRIPT_PHYS (np, data_out2) + 8;
4549 if (segments <= MAX_SCATTERL)
4550 lastp = goalp - 8 - (segments * 16);
4551 else {
4552 lastp = NCB_SCRIPTH_PHYS (np, hdata_out2);
4553 lastp -= (segments - MAX_SCATTERL) * 16;
4554 }
4555 if (direction != SCSI_DATA_UNKNOWN)
4556 break;
4557 cp->phys.header.wgoalp = cpu_to_scr(goalp);
4558 cp->phys.header.wlastp = cpu_to_scr(lastp);
4559 /* fall through */
4560 case SCSI_DATA_READ:
4561 goalp = NCB_SCRIPT_PHYS (np, data_in2) + 8;
4562 if (segments <= MAX_SCATTERL)
4563 lastp = goalp - 8 - (segments * 16);
4564 else {
4565 lastp = NCB_SCRIPTH_PHYS (np, hdata_in2);
4566 lastp -= (segments - MAX_SCATTERL) * 16;
4567 }
4568 break;
4569 default:
4570 case SCSI_DATA_NONE:
4571 lastp = goalp = NCB_SCRIPT_PHYS (np, no_data);
4572 break;
4573 }
4574
4575 /*
4576 ** Set all pointers values needed by SCRIPTS.
4577 ** If direction is unknown, start at data_io.
4578 */
4579 cp->phys.header.lastp = cpu_to_scr(lastp);
4580 cp->phys.header.goalp = cpu_to_scr(goalp);
4581
4582 if (direction == SCSI_DATA_UNKNOWN)
4583 cp->phys.header.savep =
4584 cpu_to_scr(NCB_SCRIPTH_PHYS (np, data_io));
4585 else
4586 cp->phys.header.savep= cpu_to_scr(lastp);
4587
4588 /*
4589 ** Save the initial data pointer in order to be able
4590 ** to redo the command.
4591 */
4592 cp->startp = cp->phys.header.savep;
4593
4594 /*----------------------------------------------------
4595 **
4596 ** fill in ccb
4597 **
4598 **----------------------------------------------------
4599 **
4600 **
4601 ** physical -> virtual backlink
4602 ** Generic SCSI command
4603 */
4604
4605 /*
4606 ** Startqueue
4607 */
4608 cp->start.schedule.l_paddr = cpu_to_scr(NCB_SCRIPT_PHYS (np, select));
4609 cp->restart.schedule.l_paddr = cpu_to_scr(NCB_SCRIPT_PHYS (np, resel_dsa));
4610 /*
4611 ** select
4612 */
4613 cp->phys.select.sel_id = cmd->device->id;
4614 cp->phys.select.sel_scntl3 = tp->wval;
4615 cp->phys.select.sel_sxfer = tp->sval;
4616 /*
4617 ** message
4618 */
4619 cp->phys.smsg.addr = cpu_to_scr(CCB_PHYS (cp, scsi_smsg));
4620 cp->phys.smsg.size = cpu_to_scr(msglen);
4621
4622 /*
4623 ** command
4624 */
4625 memcpy(cp->cdb_buf, cmd->cmnd, MIN(cmd->cmd_len, sizeof(cp->cdb_buf)));
4626 cp->phys.cmd.addr = cpu_to_scr(CCB_PHYS (cp, cdb_buf[0]));
4627 cp->phys.cmd.size = cpu_to_scr(cmd->cmd_len);
4628
4629 /*
4630 ** status
4631 */
4632 cp->actualquirks = tp->quirks;
4633 cp->host_status = cp->nego_status ? HS_NEGOTIATE : HS_BUSY;
4634 cp->scsi_status = S_ILLEGAL;
4635 cp->parity_status = 0;
4636
4637 cp->xerr_status = XE_OK;
4638 #if 0
4639 cp->sync_status = tp->sval;
4640 cp->wide_status = tp->wval;
4641 #endif
4642
4643 /*----------------------------------------------------
4644 **
4645 ** Critical region: start this job.
4646 **
4647 **----------------------------------------------------
4648 */
4649
4650 /*
4651 ** activate this job.
4652 */
4653 cp->magic = CCB_MAGIC;
4654
4655 /*
4656 ** insert next CCBs into start queue.
4657 ** 2 max at a time is enough to flush the CCB wait queue.
4658 */
4659 cp->auto_sense = 0;
4660 if (lp)
4661 ncr_start_next_ccb(np, lp, 2);
4662 else
4663 ncr_put_start_queue(np, cp);
4664
4665 /*
4666 ** Command is successfully queued.
4667 */
4668
4669 return(DID_OK);
4670 }
4671
4672
4673 /*==========================================================
4674 **
4675 **
4676 ** Insert a CCB into the start queue and wake up the
4677 ** SCRIPTS processor.
4678 **
4679 **
4680 **==========================================================
4681 */
4682
4683 static void ncr_start_next_ccb(ncb_p np, lcb_p lp, int maxn)
4684 {
4685 XPT_QUEHEAD *qp;
4686 ccb_p cp;
4687
4688 if (lp->held_ccb)
4689 return;
4690
4691 while (maxn-- && lp->queuedccbs < lp->queuedepth) {
4692 qp = xpt_remque_head(&lp->wait_ccbq);
4693 if (!qp)
4694 break;
4695 ++lp->queuedccbs;
4696 cp = xpt_que_entry(qp, struct ccb, link_ccbq);
4697 xpt_insque_tail(qp, &lp->busy_ccbq);
4698 lp->jump_ccb[cp->tag == NO_TAG ? 0 : cp->tag] =
4699 cpu_to_scr(CCB_PHYS (cp, restart));
4700 ncr_put_start_queue(np, cp);
4701 }
4702 }
4703
4704 static void ncr_put_start_queue(ncb_p np, ccb_p cp)
4705 {
4706 u_short qidx;
4707
4708 /*
4709 ** insert into start queue.
4710 */
4711 if (!np->squeueput) np->squeueput = 1;
4712 qidx = np->squeueput + 2;
4713 if (qidx >= MAX_START + MAX_START) qidx = 1;
4714
4715 np->scripth->tryloop [qidx] = cpu_to_scr(NCB_SCRIPT_PHYS (np, idle));
4716 MEMORY_BARRIER();
4717 np->scripth->tryloop [np->squeueput] = cpu_to_scr(CCB_PHYS (cp, start));
4718
4719 np->squeueput = qidx;
4720 ++np->queuedccbs;
4721 cp->queued = 1;
4722
4723 if (DEBUG_FLAGS & DEBUG_QUEUE)
4724 printk ("%s: queuepos=%d.\n", ncr_name (np), np->squeueput);
4725
4726 /*
4727 ** Script processor may be waiting for reselect.
4728 ** Wake it up.
4729 */
4730 MEMORY_BARRIER();
4731 OUTB (nc_istat, SIGP);
4732 }
4733
4734
4735 /*==========================================================
4736 **
4737 **
4738 ** Start reset process.
4739 ** If reset in progress do nothing.
4740 ** The interrupt handler will reinitialize the chip.
4741 ** The timeout handler will wait for settle_time before
4742 ** clearing it and so resuming command processing.
4743 **
4744 **
4745 **==========================================================
4746 */
4747 static void ncr_start_reset(ncb_p np)
4748 {
4749 if (!np->settle_time) {
4750 (void) ncr_reset_scsi_bus(np, 1, driver_setup.settle_delay);
4751 }
4752 }
4753
4754 static int ncr_reset_scsi_bus(ncb_p np, int enab_int, int settle_delay)
4755 {
4756 u_int32 term;
4757 int retv = 0;
4758
4759 np->settle_time = ktime_get(settle_delay * HZ);
4760
4761 if (bootverbose > 1)
4762 printk("%s: resetting, "
4763 "command processing suspended for %d seconds\n",
4764 ncr_name(np), settle_delay);
4765
4766 ncr_chip_reset(np, 100);
4767 UDELAY (2000); /* The 895 needs time for the bus mode to settle */
4768 if (enab_int)
4769 OUTW (nc_sien, RST);
4770 /*
4771 ** Enable Tolerant, reset IRQD if present and
4772 ** properly set IRQ mode, prior to resetting the bus.
4773 */
4774 OUTB (nc_stest3, TE);
4775 if (np->device_id != PSEUDO_720_ID)
4776 OUTB (nc_dcntl, (np->rv_dcntl & IRQM));
4777 OUTB (nc_scntl1, CRST);
4778 UDELAY (200);
4779
4780 if (!driver_setup.bus_check)
4781 goto out;
4782 /*
4783 ** Check for no terminators or SCSI bus shorts to ground.
4784 ** Read SCSI data bus, data parity bits and control signals.
4785 ** We are expecting RESET to be TRUE and other signals to be
4786 ** FALSE.
4787 */
4788
4789 term = INB(nc_sstat0);
4790 term = ((term & 2) << 7) + ((term & 1) << 17); /* rst sdp0 */
4791 term |= ((INB(nc_sstat2) & 0x01) << 26) | /* sdp1 */
4792 ((INW(nc_sbdl) & 0xff) << 9) | /* d7-0 */
4793 ((INW(nc_sbdl) & 0xff00) << 10) | /* d15-8 */
4794 INB(nc_sbcl); /* req ack bsy sel atn msg cd io */
4795
4796 if (!(np->features & FE_WIDE))
4797 term &= 0x3ffff;
4798
4799 if (term != (2<<7)) {
4800 printk("%s: suspicious SCSI data while resetting the BUS.\n",
4801 ncr_name(np));
4802 printk("%s: %sdp0,d7-0,rst,req,ack,bsy,sel,atn,msg,c/d,i/o = "
4803 "0x%lx, expecting 0x%lx\n",
4804 ncr_name(np),
4805 (np->features & FE_WIDE) ? "dp1,d15-8," : "",
4806 (u_long)term, (u_long)(2<<7));
4807 if (driver_setup.bus_check == 1)
4808 retv = 1;
4809 }
4810 out:
4811 OUTB (nc_scntl1, 0);
4812 return retv;
4813 }
4814
4815 /*==========================================================
4816 **
4817 **
4818 ** Reset the SCSI BUS.
4819 ** This is called from the generic SCSI driver.
4820 **
4821 **
4822 **==========================================================
4823 */
4824 static int ncr_reset_bus (ncb_p np, Scsi_Cmnd *cmd, int sync_reset)
4825 {
4826 /* Scsi_Device *device = cmd->device; */
4827 ccb_p cp;
4828 int found;
4829
4830 /*
4831 * Return immediately if reset is in progress.
4832 */
4833 if (np->settle_time) {
4834 return FAILED;
4835 }
4836 /*
4837 * Start the reset process.
4838 * The script processor is then assumed to be stopped.
4839 * Commands will now be queued in the waiting list until a settle
4840 * delay of 2 seconds will be completed.
4841 */
4842 ncr_start_reset(np);
4843 /*
4844 * First, look in the wakeup list
4845 */
4846 for (found=0, cp=np->ccb; cp; cp=cp->link_ccb) {
4847 /*
4848 ** look for the ccb of this command.
4849 */
4850 if (cp->host_status == HS_IDLE) continue;
4851 if (cp->cmd == cmd) {
4852 found = 1;
4853 break;
4854 }
4855 }
4856 /*
4857 * Then, look in the waiting list
4858 */
4859 if (!found && retrieve_from_waiting_list(0, np, cmd))
4860 found = 1;
4861 /*
4862 * Wake-up all awaiting commands with DID_RESET.
4863 */
4864 reset_waiting_list(np);
4865 /*
4866 * Wake-up all pending commands with HS_RESET -> DID_RESET.
4867 */
4868 ncr_wakeup(np, HS_RESET);
4869 /*
4870 * If the involved command was not in a driver queue, and the
4871 * scsi driver told us reset is synchronous, and the command is not
4872 * currently in the waiting list, complete it with DID_RESET status,
4873 * in order to keep it alive.
4874 */
4875 if (!found && sync_reset && !retrieve_from_waiting_list(0, np, cmd)) {
4876 cmd->result = ScsiResult(DID_RESET, 0);
4877 ncr_queue_done_cmd(np, cmd);
4878 }
4879
4880 return SUCCESS;
4881 }
4882
4883 /*==========================================================
4884 **
4885 **
4886 ** Abort an SCSI command.
4887 ** This is called from the generic SCSI driver.
4888 **
4889 **
4890 **==========================================================
4891 */
4892 static int ncr_abort_command (ncb_p np, Scsi_Cmnd *cmd)
4893 {
4894 /* Scsi_Device *device = cmd->device; */
4895 ccb_p cp;
4896 int found;
4897 int retv;
4898
4899 /*
4900 * First, look for the scsi command in the waiting list
4901 */
4902 if (remove_from_waiting_list(np, cmd)) {
4903 cmd->result = ScsiResult(DID_ABORT, 0);
4904 ncr_queue_done_cmd(np, cmd);
4905 return SCSI_ABORT_SUCCESS;
4906 }
4907
4908 /*
4909 * Then, look in the wakeup list
4910 */
4911 for (found=0, cp=np->ccb; cp; cp=cp->link_ccb) {
4912 /*
4913 ** look for the ccb of this command.
4914 */
4915 if (cp->host_status == HS_IDLE) continue;
4916 if (cp->cmd == cmd) {
4917 found = 1;
4918 break;
4919 }
4920 }
4921
4922 if (!found) {
4923 return SCSI_ABORT_NOT_RUNNING;
4924 }
4925
4926 if (np->settle_time) {
4927 return SCSI_ABORT_SNOOZE;
4928 }
4929
4930 /*
4931 ** If the CCB is active, patch schedule jumps for the
4932 ** script to abort the command.
4933 */
4934
4935 switch(cp->host_status) {
4936 case HS_BUSY:
4937 case HS_NEGOTIATE:
4938 printk ("%s: abort ccb=%p (cancel)\n", ncr_name (np), cp);
4939 cp->start.schedule.l_paddr =
4940 cpu_to_scr(NCB_SCRIPTH_PHYS (np, cancel));
4941 retv = SCSI_ABORT_PENDING;
4942 break;
4943 case HS_DISCONNECT:
4944 cp->restart.schedule.l_paddr =
4945 cpu_to_scr(NCB_SCRIPTH_PHYS (np, abort));
4946 retv = SCSI_ABORT_PENDING;
4947 break;
4948 default:
4949 retv = SCSI_ABORT_NOT_RUNNING;
4950 break;
4951
4952 }
4953
4954 /*
4955 ** If there are no requests, the script
4956 ** processor will sleep on SEL_WAIT_RESEL.
4957 ** Let's wake it up, since it may have to work.
4958 */
4959 OUTB (nc_istat, SIGP);
4960
4961 return retv;
4962 }
4963
4964 /*==========================================================
4965 **
4966 ** Linux release module stuff.
4967 **
4968 ** Called before unloading the module
4969 ** Detach the host.
4970 ** We have to free resources and halt the NCR chip
4971 **
4972 **==========================================================
4973 */
4974
4975 static int ncr_detach(ncb_p np)
4976 {
4977 ccb_p cp;
4978 tcb_p tp;
4979 lcb_p lp;
4980 int target, lun;
4981 int i;
4982 char inst_name[16];
4983
4984 /* Local copy so we don't access np after freeing it! */
4985 strlcpy(inst_name, ncr_name(np), sizeof(inst_name));
4986
4987 printk("%s: releasing host resources\n", ncr_name(np));
4988
4989 /*
4990 ** Stop the ncr_timeout process
4991 ** Set release_stage to 1 and wait that ncr_timeout() set it to 2.
4992 */
4993
4994 #ifdef DEBUG_NCR53C8XX
4995 printk("%s: stopping the timer\n", ncr_name(np));
4996 #endif
4997 np->release_stage = 1;
4998 for (i = 50 ; i && np->release_stage != 2 ; i--) MDELAY (100);
4999 if (np->release_stage != 2)
5000 printk("%s: the timer seems to be already stopped\n", ncr_name(np));
5001 else np->release_stage = 2;
5002
5003 /*
5004 ** Disable chip interrupts
5005 */
5006
5007 #ifdef DEBUG_NCR53C8XX
5008 printk("%s: disabling chip interrupts\n", ncr_name(np));
5009 #endif
5010 OUTW (nc_sien , 0);
5011 OUTB (nc_dien , 0);
5012
5013 /*
5014 ** Reset NCR chip
5015 ** Restore bios setting for automatic clock detection.
5016 */
5017
5018 printk("%s: resetting chip\n", ncr_name(np));
5019 ncr_chip_reset(np, 100);
5020
5021 OUTB(nc_dmode, np->sv_dmode);
5022 OUTB(nc_dcntl, np->sv_dcntl);
5023 OUTB(nc_ctest0, np->sv_ctest0);
5024 OUTB(nc_ctest3, np->sv_ctest3);
5025 OUTB(nc_ctest4, np->sv_ctest4);
5026 OUTB(nc_ctest5, np->sv_ctest5);
5027 OUTB(nc_gpcntl, np->sv_gpcntl);
5028 OUTB(nc_stest2, np->sv_stest2);
5029
5030 ncr_selectclock(np, np->sv_scntl3);
5031
5032 /*
5033 ** Free allocated ccb(s)
5034 */
5035
5036 while ((cp=np->ccb->link_ccb) != NULL) {
5037 np->ccb->link_ccb = cp->link_ccb;
5038 if (cp->host_status) {
5039 printk("%s: shall free an active ccb (host_status=%d)\n",
5040 ncr_name(np), cp->host_status);
5041 }
5042 #ifdef DEBUG_NCR53C8XX
5043 printk("%s: freeing ccb (%lx)\n", ncr_name(np), (u_long) cp);
5044 #endif
5045 m_free_dma(cp, sizeof(*cp), "CCB");
5046 }
5047
5048 /*
5049 ** Free allocated tp(s)
5050 */
5051
5052 for (target = 0; target < MAX_TARGET ; target++) {
5053 tp=&np->target[target];
5054 for (lun = 0 ; lun < MAX_LUN ; lun++) {
5055 lp = tp->lp[lun];
5056 if (lp) {
5057 #ifdef DEBUG_NCR53C8XX
5058 printk("%s: freeing lp (%lx)\n", ncr_name(np), (u_long) lp);
5059 #endif
5060 if (lp->jump_ccb != &lp->jump_ccb_0)
5061 m_free_dma(lp->jump_ccb,256,"JUMP_CCB");
5062 m_free_dma(lp, sizeof(*lp), "LCB");
5063 }
5064 }
5065 }
5066
5067 if (np->scripth0)
5068 m_free_dma(np->scripth0, sizeof(struct scripth), "SCRIPTH");
5069 if (np->script0)
5070 m_free_dma(np->script0, sizeof(struct script), "SCRIPT");
5071 if (np->ccb)
5072 m_free_dma(np->ccb, sizeof(struct ccb), "CCB");
5073 m_free_dma(np, sizeof(struct ncb), "NCB");
5074
5075 printk("%s: host resources successfully released\n", inst_name);
5076
5077 return 1;
5078 }
5079
5080 /*==========================================================
5081 **
5082 **
5083 ** Complete execution of a SCSI command.
5084 ** Signal completion to the generic SCSI driver.
5085 **
5086 **
5087 **==========================================================
5088 */
5089
5090 void ncr_complete (ncb_p np, ccb_p cp)
5091 {
5092 Scsi_Cmnd *cmd;
5093 tcb_p tp;
5094 lcb_p lp;
5095
5096 /*
5097 ** Sanity check
5098 */
5099
5100 if (!cp || cp->magic != CCB_MAGIC || !cp->cmd)
5101 return;
5102
5103 /*
5104 ** Print minimal debug information.
5105 */
5106
5107 if (DEBUG_FLAGS & DEBUG_TINY)
5108 printk ("CCB=%lx STAT=%x/%x\n", (unsigned long)cp,
5109 cp->host_status,cp->scsi_status);
5110
5111 /*
5112 ** Get command, target and lun pointers.
5113 */
5114
5115 cmd = cp->cmd;
5116 cp->cmd = NULL;
5117 tp = &np->target[cmd->device->id];
5118 lp = tp->lp[cmd->device->lun];
5119
5120 /*
5121 ** We donnot queue more than 1 ccb per target
5122 ** with negotiation at any time. If this ccb was
5123 ** used for negotiation, clear this info in the tcb.
5124 */
5125
5126 if (cp == tp->nego_cp)
5127 tp->nego_cp = 0;
5128
5129 /*
5130 ** If auto-sense performed, change scsi status.
5131 */
5132 if (cp->auto_sense) {
5133 cp->scsi_status = cp->auto_sense;
5134 }
5135
5136 /*
5137 ** If we were recovering from queue full or performing
5138 ** auto-sense, requeue skipped CCBs to the wait queue.
5139 */
5140
5141 if (lp && lp->held_ccb) {
5142 if (cp == lp->held_ccb) {
5143 xpt_que_splice(&lp->skip_ccbq, &lp->wait_ccbq);
5144 xpt_que_init(&lp->skip_ccbq);
5145 lp->held_ccb = 0;
5146 }
5147 }
5148
5149 /*
5150 ** Check for parity errors.
5151 */
5152
5153 if (cp->parity_status > 1) {
5154 PRINT_ADDR(cmd);
5155 printk ("%d parity error(s).\n",cp->parity_status);
5156 }
5157
5158 /*
5159 ** Check for extended errors.
5160 */
5161
5162 if (cp->xerr_status != XE_OK) {
5163 PRINT_ADDR(cmd);
5164 switch (cp->xerr_status) {
5165 case XE_EXTRA_DATA:
5166 printk ("extraneous data discarded.\n");
5167 break;
5168 case XE_BAD_PHASE:
5169 printk ("illegal scsi phase (4/5).\n");
5170 break;
5171 default:
5172 printk ("extended error %d.\n", cp->xerr_status);
5173 break;
5174 }
5175 if (cp->host_status==HS_COMPLETE)
5176 cp->host_status = HS_FAIL;
5177 }
5178
5179 /*
5180 ** Print out any error for debugging purpose.
5181 */
5182 if (DEBUG_FLAGS & (DEBUG_RESULT|DEBUG_TINY)) {
5183 if (cp->host_status!=HS_COMPLETE || cp->scsi_status!=S_GOOD) {
5184 PRINT_ADDR(cmd);
5185 printk ("ERROR: cmd=%x host_status=%x scsi_status=%x\n",
5186 cmd->cmnd[0], cp->host_status, cp->scsi_status);
5187 }
5188 }
5189
5190 /*
5191 ** Check the status.
5192 */
5193 if ( (cp->host_status == HS_COMPLETE)
5194 && (cp->scsi_status == S_GOOD ||
5195 cp->scsi_status == S_COND_MET)) {
5196 /*
5197 ** All went well (GOOD status).
5198 ** CONDITION MET status is returned on
5199 ** `Pre-Fetch' or `Search data' success.
5200 */
5201 cmd->result = ScsiResult(DID_OK, cp->scsi_status);
5202
5203 /*
5204 ** @RESID@
5205 ** Could dig out the correct value for resid,
5206 ** but it would be quite complicated.
5207 */
5208 /* if (cp->phys.header.lastp != cp->phys.header.goalp) */
5209
5210 /*
5211 ** Allocate the lcb if not yet.
5212 */
5213 if (!lp)
5214 ncr_alloc_lcb (np, cmd->device->id, cmd->device->lun);
5215
5216 /*
5217 ** On standard INQUIRY response (EVPD and CmDt
5218 ** not set), setup logical unit according to
5219 ** announced capabilities (we need the 1rst 7 bytes).
5220 */
5221 if (cmd->cmnd[0] == 0x12 && !(cmd->cmnd[1] & 0x3) &&
5222 cmd->cmnd[4] >= 7 && !cmd->use_sg) {
5223 sync_scsi_data(np, cmd); /* SYNC the data */
5224 ncr_setup_lcb (np, cmd->device->id, cmd->device->lun,
5225 (char *) cmd->request_buffer);
5226 }
5227
5228 tp->bytes += cp->data_len;
5229 tp->transfers ++;
5230
5231 /*
5232 ** If tags was reduced due to queue full,
5233 ** increase tags if 1000 good status received.
5234 */
5235 if (lp && lp->usetags && lp->numtags < lp->maxtags) {
5236 ++lp->num_good;
5237 if (lp->num_good >= 1000) {
5238 lp->num_good = 0;
5239 ++lp->numtags;
5240 ncr_setup_tags (np, cmd->device->id, cmd->device->lun);
5241 }
5242 }
5243 } else if ((cp->host_status == HS_COMPLETE)
5244 && (cp->scsi_status == S_CHECK_COND)) {
5245 /*
5246 ** Check condition code
5247 */
5248 cmd->result = ScsiResult(DID_OK, S_CHECK_COND);
5249
5250 /*
5251 ** Copy back sense data to caller's buffer.
5252 */
5253 memcpy(cmd->sense_buffer, cp->sense_buf,
5254 MIN(sizeof(cmd->sense_buffer), sizeof(cp->sense_buf)));
5255
5256 if (DEBUG_FLAGS & (DEBUG_RESULT|DEBUG_TINY)) {
5257 u_char * p = (u_char*) & cmd->sense_buffer;
5258 int i;
5259 PRINT_ADDR(cmd);
5260 printk ("sense data:");
5261 for (i=0; i<14; i++) printk (" %x", *p++);
5262 printk (".\n");
5263 }
5264 } else if ((cp->host_status == HS_COMPLETE)
5265 && (cp->scsi_status == S_CONFLICT)) {
5266 /*
5267 ** Reservation Conflict condition code
5268 */
5269 cmd->result = ScsiResult(DID_OK, S_CONFLICT);
5270
5271 } else if ((cp->host_status == HS_COMPLETE)
5272 && (cp->scsi_status == S_BUSY ||
5273 cp->scsi_status == S_QUEUE_FULL)) {
5274
5275 /*
5276 ** Target is busy.
5277 */
5278 cmd->result = ScsiResult(DID_OK, cp->scsi_status);
5279
5280 } else if ((cp->host_status == HS_SEL_TIMEOUT)
5281 || (cp->host_status == HS_TIMEOUT)) {
5282
5283 /*
5284 ** No response
5285 */
5286 cmd->result = ScsiResult(DID_TIME_OUT, cp->scsi_status);
5287
5288 } else if (cp->host_status == HS_RESET) {
5289
5290 /*
5291 ** SCSI bus reset
5292 */
5293 cmd->result = ScsiResult(DID_RESET, cp->scsi_status);
5294
5295 } else if (cp->host_status == HS_ABORTED) {
5296
5297 /*
5298 ** Transfer aborted
5299 */
5300 cmd->result = ScsiResult(DID_ABORT, cp->scsi_status);
5301
5302 } else {
5303
5304 /*
5305 ** Other protocol messes
5306 */
5307 PRINT_ADDR(cmd);
5308 printk ("COMMAND FAILED (%x %x) @%p.\n",
5309 cp->host_status, cp->scsi_status, cp);
5310
5311 cmd->result = ScsiResult(DID_ERROR, cp->scsi_status);
5312 }
5313
5314 /*
5315 ** trace output
5316 */
5317
5318 if (tp->usrflag & UF_TRACE) {
5319 u_char * p;
5320 int i;
5321 PRINT_ADDR(cmd);
5322 printk (" CMD:");
5323 p = (u_char*) &cmd->cmnd[0];
5324 for (i=0; i<cmd->cmd_len; i++) printk (" %x", *p++);
5325
5326 if (cp->host_status==HS_COMPLETE) {
5327 switch (cp->scsi_status) {
5328 case S_GOOD:
5329 printk (" GOOD");
5330 break;
5331 case S_CHECK_COND:
5332 printk (" SENSE:");
5333 p = (u_char*) &cmd->sense_buffer;
5334 for (i=0; i<14; i++)
5335 printk (" %x", *p++);
5336 break;
5337 default:
5338 printk (" STAT: %x\n", cp->scsi_status);
5339 break;
5340 }
5341 } else printk (" HOSTERROR: %x", cp->host_status);
5342 printk ("\n");
5343 }
5344
5345 /*
5346 ** Free this ccb
5347 */
5348 ncr_free_ccb (np, cp);
5349
5350 /*
5351 ** requeue awaiting scsi commands for this lun.
5352 */
5353 if (lp && lp->queuedccbs < lp->queuedepth &&
5354 !xpt_que_empty(&lp->wait_ccbq))
5355 ncr_start_next_ccb(np, lp, 2);
5356
5357 /*
5358 ** requeue awaiting scsi commands for this controller.
5359 */
5360 if (np->waiting_list)
5361 requeue_waiting_list(np);
5362
5363 /*
5364 ** signal completion to generic driver.
5365 */
5366 ncr_queue_done_cmd(np, cmd);
5367 }
5368
5369 /*==========================================================
5370 **
5371 **
5372 ** Signal all (or one) control block done.
5373 **
5374 **
5375 **==========================================================
5376 */
5377
5378 /*
5379 ** This CCB has been skipped by the NCR.
5380 ** Queue it in the correponding unit queue.
5381 */
5382 static void ncr_ccb_skipped(ncb_p np, ccb_p cp)
5383 {
5384 tcb_p tp = &np->target[cp->target];
5385 lcb_p lp = tp->lp[cp->lun];
5386
5387 if (lp && cp != np->ccb) {
5388 cp->host_status &= ~HS_SKIPMASK;
5389 cp->start.schedule.l_paddr =
5390 cpu_to_scr(NCB_SCRIPT_PHYS (np, select));
5391 xpt_remque(&cp->link_ccbq);
5392 xpt_insque_tail(&cp->link_ccbq, &lp->skip_ccbq);
5393 if (cp->queued) {
5394 --lp->queuedccbs;
5395 }
5396 }
5397 if (cp->queued) {
5398 --np->queuedccbs;
5399 cp->queued = 0;
5400 }
5401 }
5402
5403 /*
5404 ** The NCR has completed CCBs.
5405 ** Look at the DONE QUEUE if enabled, otherwise scan all CCBs
5406 */
5407 void ncr_wakeup_done (ncb_p np)
5408 {
5409 ccb_p cp;
5410 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
5411 int i, j;
5412
5413 i = np->ccb_done_ic;
5414 while (1) {
5415 j = i+1;
5416 if (j >= MAX_DONE)
5417 j = 0;
5418
5419 cp = np->ccb_done[j];
5420 if (!CCB_DONE_VALID(cp))
5421 break;
5422
5423 np->ccb_done[j] = (ccb_p) CCB_DONE_EMPTY;
5424 np->scripth->done_queue[5*j + 4] =
5425 cpu_to_scr(NCB_SCRIPT_PHYS (np, done_plug));
5426 MEMORY_BARRIER();
5427 np->scripth->done_queue[5*i + 4] =
5428 cpu_to_scr(NCB_SCRIPT_PHYS (np, done_end));
5429
5430 if (cp->host_status & HS_DONEMASK)
5431 ncr_complete (np, cp);
5432 else if (cp->host_status & HS_SKIPMASK)
5433 ncr_ccb_skipped (np, cp);
5434
5435 i = j;
5436 }
5437 np->ccb_done_ic = i;
5438 #else
5439 cp = np->ccb;
5440 while (cp) {
5441 if (cp->host_status & HS_DONEMASK)
5442 ncr_complete (np, cp);
5443 else if (cp->host_status & HS_SKIPMASK)
5444 ncr_ccb_skipped (np, cp);
5445 cp = cp->link_ccb;
5446 }
5447 #endif
5448 }
5449
5450 /*
5451 ** Complete all active CCBs.
5452 */
5453 void ncr_wakeup (ncb_p np, u_long code)
5454 {
5455 ccb_p cp = np->ccb;
5456
5457 while (cp) {
5458 if (cp->host_status != HS_IDLE) {
5459 cp->host_status = code;
5460 ncr_complete (np, cp);
5461 }
5462 cp = cp->link_ccb;
5463 }
5464 }
5465
5466 /*
5467 ** Reset ncr chip.
5468 */
5469
5470 /* Some initialisation must be done immediately following reset, for 53c720,
5471 * at least. EA (dcntl bit 5) isn't set here as it is set once only in
5472 * the _detect function.
5473 */
5474 static void ncr_chip_reset(ncb_p np, int delay)
5475 {
5476 OUTB (nc_istat, SRST);
5477 UDELAY (delay);
5478 OUTB (nc_istat, 0 );
5479
5480 if (np->features & FE_EHP)
5481 OUTB (nc_ctest0, EHP);
5482 if (np->features & FE_MUX)
5483 OUTB (nc_ctest4, MUX);
5484 }
5485
5486
5487 /*==========================================================
5488 **
5489 **
5490 ** Start NCR chip.
5491 **
5492 **
5493 **==========================================================
5494 */
5495
5496 void ncr_init (ncb_p np, int reset, char * msg, u_long code)
5497 {
5498 int i;
5499
5500 /*
5501 ** Reset chip if asked, otherwise just clear fifos.
5502 */
5503
5504 if (reset) {
5505 OUTB (nc_istat, SRST);
5506 UDELAY (100);
5507 }
5508 else {
5509 OUTB (nc_stest3, TE|CSF);
5510 OUTONB (nc_ctest3, CLF);
5511 }
5512
5513 /*
5514 ** Message.
5515 */
5516
5517 if (msg) printk (KERN_INFO "%s: restart (%s).\n", ncr_name (np), msg);
5518
5519 /*
5520 ** Clear Start Queue
5521 */
5522 np->queuedepth = MAX_START - 1; /* 1 entry needed as end marker */
5523 for (i = 1; i < MAX_START + MAX_START; i += 2)
5524 np->scripth0->tryloop[i] =
5525 cpu_to_scr(NCB_SCRIPT_PHYS (np, idle));
5526
5527 /*
5528 ** Start at first entry.
5529 */
5530 np->squeueput = 0;
5531 np->script0->startpos[0] = cpu_to_scr(NCB_SCRIPTH_PHYS (np, tryloop));
5532
5533 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
5534 /*
5535 ** Clear Done Queue
5536 */
5537 for (i = 0; i < MAX_DONE; i++) {
5538 np->ccb_done[i] = (ccb_p) CCB_DONE_EMPTY;
5539 np->scripth0->done_queue[5*i + 4] =
5540 cpu_to_scr(NCB_SCRIPT_PHYS (np, done_end));
5541 }
5542 #endif
5543
5544 /*
5545 ** Start at first entry.
5546 */
5547 np->script0->done_pos[0] = cpu_to_scr(NCB_SCRIPTH_PHYS (np,done_queue));
5548 np->ccb_done_ic = MAX_DONE-1;
5549 np->scripth0->done_queue[5*(MAX_DONE-1) + 4] =
5550 cpu_to_scr(NCB_SCRIPT_PHYS (np, done_plug));
5551
5552 /*
5553 ** Wakeup all pending jobs.
5554 */
5555 ncr_wakeup (np, code);
5556
5557 /*
5558 ** Init chip.
5559 */
5560
5561 /*
5562 ** Remove reset; big delay because the 895 needs time for the
5563 ** bus mode to settle
5564 */
5565 ncr_chip_reset(np, 2000);
5566
5567 OUTB (nc_scntl0, np->rv_scntl0 | 0xc0);
5568 /* full arb., ena parity, par->ATN */
5569 OUTB (nc_scntl1, 0x00); /* odd parity, and remove CRST!! */
5570
5571 ncr_selectclock(np, np->rv_scntl3); /* Select SCSI clock */
5572
5573 OUTB (nc_scid , RRE|np->myaddr); /* Adapter SCSI address */
5574 OUTW (nc_respid, 1ul<<np->myaddr); /* Id to respond to */
5575 OUTB (nc_istat , SIGP ); /* Signal Process */
5576 OUTB (nc_dmode , np->rv_dmode); /* Burst length, dma mode */
5577 OUTB (nc_ctest5, np->rv_ctest5); /* Large fifo + large burst */
5578
5579 OUTB (nc_dcntl , NOCOM|np->rv_dcntl); /* Protect SFBR */
5580 OUTB (nc_ctest0, np->rv_ctest0); /* 720: CDIS and EHP */
5581 OUTB (nc_ctest3, np->rv_ctest3); /* Write and invalidate */
5582 OUTB (nc_ctest4, np->rv_ctest4); /* Master parity checking */
5583
5584 OUTB (nc_stest2, EXT|np->rv_stest2); /* Extended Sreq/Sack filtering */
5585 OUTB (nc_stest3, TE); /* TolerANT enable */
5586 OUTB (nc_stime0, 0x0c ); /* HTH disabled STO 0.25 sec */
5587
5588 /*
5589 ** Disable disconnects.
5590 */
5591
5592 np->disc = 0;
5593
5594 /*
5595 ** Enable GPIO0 pin for writing if LED support.
5596 */
5597
5598 if (np->features & FE_LED0) {
5599 OUTOFFB (nc_gpcntl, 0x01);
5600 }
5601
5602 /*
5603 ** enable ints
5604 */
5605
5606 OUTW (nc_sien , STO|HTH|MA|SGE|UDC|RST|PAR);
5607 OUTB (nc_dien , MDPE|BF|ABRT|SSI|SIR|IID);
5608
5609 /*
5610 ** For 895/6 enable SBMC interrupt and save current SCSI bus mode.
5611 */
5612 if (np->features & FE_ULTRA2) {
5613 OUTONW (nc_sien, SBMC);
5614 np->scsi_mode = INB (nc_stest4) & SMODE;
5615 }
5616
5617 /*
5618 ** DEL 441 - 53C876 Rev 5 - Part Number 609-0392787/2788 - ITEM 2.
5619 ** Disable overlapped arbitration.
5620 ** All 896 chips are also affected by this errata.
5621 */
5622 if (np->device_id == PCI_DEVICE_ID_NCR_53C875)
5623 OUTB (nc_ctest0, (1<<5));
5624 else if (np->device_id == PCI_DEVICE_ID_NCR_53C896)
5625 OUTB (nc_ccntl0, DPR);
5626
5627 /*
5628 ** Fill in target structure.
5629 ** Reinitialize usrsync.
5630 ** Reinitialize usrwide.
5631 ** Prepare sync negotiation according to actual SCSI bus mode.
5632 */
5633
5634 for (i=0;i<MAX_TARGET;i++) {
5635 tcb_p tp = &np->target[i];
5636
5637 tp->sval = 0;
5638 tp->wval = np->rv_scntl3;
5639
5640 if (tp->usrsync != 255) {
5641 if (tp->usrsync <= np->maxsync) {
5642 if (tp->usrsync < np->minsync) {
5643 tp->usrsync = np->minsync;
5644 }
5645 }
5646 else
5647 tp->usrsync = 255;
5648 };
5649
5650 if (tp->usrwide > np->maxwide)
5651 tp->usrwide = np->maxwide;
5652
5653 ncr_negotiate (np, tp);
5654 }
5655
5656 /*
5657 ** Start script processor.
5658 */
5659 if (np->paddr2) {
5660 if (bootverbose)
5661 printk ("%s: Downloading SCSI SCRIPTS.\n",
5662 ncr_name(np));
5663 OUTL (nc_scratcha, vtobus(np->script0));
5664 OUTL_DSP (NCB_SCRIPTH_PHYS (np, start_ram));
5665 }
5666 else
5667 OUTL_DSP (NCB_SCRIPT_PHYS (np, start));
5668 }
5669
5670 /*==========================================================
5671 **
5672 ** Prepare the negotiation values for wide and
5673 ** synchronous transfers.
5674 **
5675 **==========================================================
5676 */
5677
5678 static void ncr_negotiate (struct ncb* np, struct tcb* tp)
5679 {
5680 /*
5681 ** minsync unit is 4ns !
5682 */
5683
5684 u_long minsync = tp->usrsync;
5685
5686 /*
5687 ** SCSI bus mode limit
5688 */
5689
5690 if (np->scsi_mode && np->scsi_mode == SMODE_SE) {
5691 if (minsync < 12) minsync = 12;
5692 }
5693
5694 /*
5695 ** our limit ..
5696 */
5697
5698 if (minsync < np->minsync)
5699 minsync = np->minsync;
5700
5701 /*
5702 ** divider limit
5703 */
5704
5705 if (minsync > np->maxsync)
5706 minsync = 255;
5707
5708 tp->minsync = minsync;
5709 tp->maxoffs = (minsync<255 ? np->maxoffs : 0);
5710
5711 /*
5712 ** period=0: has to negotiate sync transfer
5713 */
5714
5715 tp->period=0;
5716
5717 /*
5718 ** widedone=0: has to negotiate wide transfer
5719 */
5720 tp->widedone=0;
5721 }
5722
5723 /*==========================================================
5724 **
5725 ** Get clock factor and sync divisor for a given
5726 ** synchronous factor period.
5727 ** Returns the clock factor (in sxfer) and scntl3
5728 ** synchronous divisor field.
5729 **
5730 **==========================================================
5731 */
5732
5733 static void ncr_getsync(ncb_p np, u_char sfac, u_char *fakp, u_char *scntl3p)
5734 {
5735 u_long clk = np->clock_khz; /* SCSI clock frequency in kHz */
5736 int div = np->clock_divn; /* Number of divisors supported */
5737 u_long fak; /* Sync factor in sxfer */
5738 u_long per; /* Period in tenths of ns */
5739 u_long kpc; /* (per * clk) */
5740
5741 /*
5742 ** Compute the synchronous period in tenths of nano-seconds
5743 */
5744 if (sfac <= 10) per = 250;
5745 else if (sfac == 11) per = 303;
5746 else if (sfac == 12) per = 500;
5747 else per = 40 * sfac;
5748
5749 /*
5750 ** Look for the greatest clock divisor that allows an
5751 ** input speed faster than the period.
5752 */
5753 kpc = per * clk;
5754 while (--div >= 0)
5755 if (kpc >= (div_10M[div] << 2)) break;
5756
5757 /*
5758 ** Calculate the lowest clock factor that allows an output
5759 ** speed not faster than the period.
5760 */
5761 fak = (kpc - 1) / div_10M[div] + 1;
5762
5763 #if 0 /* This optimization does not seem very useful */
5764
5765 per = (fak * div_10M[div]) / clk;
5766
5767 /*
5768 ** Why not to try the immediate lower divisor and to choose
5769 ** the one that allows the fastest output speed ?
5770 ** We don't want input speed too much greater than output speed.
5771 */
5772 if (div >= 1 && fak < 8) {
5773 u_long fak2, per2;
5774 fak2 = (kpc - 1) / div_10M[div-1] + 1;
5775 per2 = (fak2 * div_10M[div-1]) / clk;
5776 if (per2 < per && fak2 <= 8) {
5777 fak = fak2;
5778 per = per2;
5779 --div;
5780 }
5781 }
5782 #endif
5783
5784 if (fak < 4) fak = 4; /* Should never happen, too bad ... */
5785
5786 /*
5787 ** Compute and return sync parameters for the ncr
5788 */
5789 *fakp = fak - 4;
5790 *scntl3p = ((div+1) << 4) + (sfac < 25 ? 0x80 : 0);
5791 }
5792
5793
5794 /*==========================================================
5795 **
5796 ** Set actual values, sync status and patch all ccbs of
5797 ** a target according to new sync/wide agreement.
5798 **
5799 **==========================================================
5800 */
5801
5802 static void ncr_set_sync_wide_status (ncb_p np, u_char target)
5803 {
5804 ccb_p cp;
5805 tcb_p tp = &np->target[target];
5806
5807 /*
5808 ** set actual value and sync_status
5809 */
5810 OUTB (nc_sxfer, tp->sval);
5811 np->sync_st = tp->sval;
5812 OUTB (nc_scntl3, tp->wval);
5813 np->wide_st = tp->wval;
5814
5815 /*
5816 ** patch ALL ccbs of this target.
5817 */
5818 for (cp = np->ccb; cp; cp = cp->link_ccb) {
5819 if (!cp->cmd) continue;
5820 if (cp->cmd->device->id != target) continue;
5821 #if 0
5822 cp->sync_status = tp->sval;
5823 cp->wide_status = tp->wval;
5824 #endif
5825 cp->phys.select.sel_scntl3 = tp->wval;
5826 cp->phys.select.sel_sxfer = tp->sval;
5827 };
5828 }
5829
5830 /*==========================================================
5831 **
5832 ** Switch sync mode for current job and it's target
5833 **
5834 **==========================================================
5835 */
5836
5837 static void ncr_setsync (ncb_p np, ccb_p cp, u_char scntl3, u_char sxfer)
5838 {
5839 Scsi_Cmnd *cmd;
5840 tcb_p tp;
5841 u_char target = INB (nc_sdid) & 0x0f;
5842 u_char idiv;
5843
5844 assert (cp && cp->cmd);
5845 if (!cp) return;
5846
5847 cmd = cp->cmd;
5848 if (!cmd) return;
5849
5850 assert (target == (cmd->device->id & 0xf));
5851
5852 tp = &np->target[target];
5853
5854 if (!scntl3 || !(sxfer & 0x1f))
5855 scntl3 = np->rv_scntl3;
5856 scntl3 = (scntl3 & 0xf0) | (tp->wval & EWS) | (np->rv_scntl3 & 0x07);
5857
5858 /*
5859 ** Deduce the value of controller sync period from scntl3.
5860 ** period is in tenths of nano-seconds.
5861 */
5862
5863 idiv = ((scntl3 >> 4) & 0x7);
5864 if ((sxfer & 0x1f) && idiv)
5865 tp->period = (((sxfer>>5)+4)*div_10M[idiv-1])/np->clock_khz;
5866 else
5867 tp->period = 0xffff;
5868
5869 /*
5870 ** Stop there if sync parameters are unchanged
5871 */
5872 if (tp->sval == sxfer && tp->wval == scntl3) return;
5873 tp->sval = sxfer;
5874 tp->wval = scntl3;
5875
5876 /*
5877 ** Bells and whistles ;-)
5878 */
5879 PRINT_TARGET(np, target);
5880 if (sxfer & 0x01f) {
5881 unsigned f10 = 100000 << (tp->widedone ? tp->widedone -1 : 0);
5882 unsigned mb10 = (f10 + tp->period/2) / tp->period;
5883 char *scsi;
5884
5885 /*
5886 ** Disable extended Sreq/Sack filtering
5887 */
5888 if (tp->period <= 2000) OUTOFFB (nc_stest2, EXT);
5889
5890 /*
5891 ** Bells and whistles ;-)
5892 */
5893 if (tp->period < 500) scsi = "FAST-40";
5894 else if (tp->period < 1000) scsi = "FAST-20";
5895 else if (tp->period < 2000) scsi = "FAST-10";
5896 else scsi = "FAST-5";
5897
5898 printk ("%s %sSCSI %d.%d MB/s (%d ns, offset %d)\n", scsi,
5899 tp->widedone > 1 ? "WIDE " : "",
5900 mb10 / 10, mb10 % 10, tp->period / 10, sxfer & 0x1f);
5901 } else
5902 printk ("%sasynchronous.\n", tp->widedone > 1 ? "wide " : "");
5903
5904 /*
5905 ** set actual value and sync_status
5906 ** patch ALL ccbs of this target.
5907 */
5908 ncr_set_sync_wide_status(np, target);
5909 }
5910
5911 /*==========================================================
5912 **
5913 ** Switch wide mode for current job and it's target
5914 ** SCSI specs say: a SCSI device that accepts a WDTR
5915 ** message shall reset the synchronous agreement to
5916 ** asynchronous mode.
5917 **
5918 **==========================================================
5919 */
5920
5921 static void ncr_setwide (ncb_p np, ccb_p cp, u_char wide, u_char ack)
5922 {
5923 Scsi_Cmnd *cmd;
5924 u_short target = INB (nc_sdid) & 0x0f;
5925 tcb_p tp;
5926 u_char scntl3;
5927 u_char sxfer;
5928
5929 assert (cp && cp->cmd);
5930 if (!cp) return;
5931
5932 cmd = cp->cmd;
5933 if (!cmd) return;
5934
5935 assert (target == (cmd->device->id & 0xf));
5936
5937 tp = &np->target[target];
5938 tp->widedone = wide+1;
5939 scntl3 = (tp->wval & (~EWS)) | (wide ? EWS : 0);
5940
5941 sxfer = ack ? 0 : tp->sval;
5942
5943 /*
5944 ** Stop there if sync/wide parameters are unchanged
5945 */
5946 if (tp->sval == sxfer && tp->wval == scntl3) return;
5947 tp->sval = sxfer;
5948 tp->wval = scntl3;
5949
5950 /*
5951 ** Bells and whistles ;-)
5952 */
5953 if (bootverbose >= 2) {
5954 PRINT_TARGET(np, target);
5955 if (scntl3 & EWS)
5956 printk ("WIDE SCSI (16 bit) enabled.\n");
5957 else
5958 printk ("WIDE SCSI disabled.\n");
5959 }
5960
5961 /*
5962 ** set actual value and sync_status
5963 ** patch ALL ccbs of this target.
5964 */
5965 ncr_set_sync_wide_status(np, target);
5966 }
5967
5968 /*==========================================================
5969 **
5970 ** Switch tagged mode for a target.
5971 **
5972 **==========================================================
5973 */
5974
5975 static void ncr_setup_tags (ncb_p np, u_char tn, u_char ln)
5976 {
5977 tcb_p tp = &np->target[tn];
5978 lcb_p lp = tp->lp[ln];
5979 u_char reqtags, maxdepth;
5980
5981 /*
5982 ** Just in case ...
5983 */
5984 if ((!tp) || (!lp))
5985 return;
5986
5987 /*
5988 ** If SCSI device queue depth is not yet set, leave here.
5989 */
5990 if (!lp->scdev_depth)
5991 return;
5992
5993 /*
5994 ** Donnot allow more tags than the SCSI driver can queue
5995 ** for this device.
5996 ** Donnot allow more tags than we can handle.
5997 */
5998 maxdepth = lp->scdev_depth;
5999 if (maxdepth > lp->maxnxs) maxdepth = lp->maxnxs;
6000 if (lp->maxtags > maxdepth) lp->maxtags = maxdepth;
6001 if (lp->numtags > maxdepth) lp->numtags = maxdepth;
6002
6003 /*
6004 ** only devices conformant to ANSI Version >= 2
6005 ** only devices capable of tagged commands
6006 ** only if enabled by user ..
6007 */
6008 if ((lp->inq_byte7 & INQ7_QUEUE) && lp->numtags > 1) {
6009 reqtags = lp->numtags;
6010 } else {
6011 reqtags = 1;
6012 };
6013
6014 /*
6015 ** Update max number of tags
6016 */
6017 lp->numtags = reqtags;
6018 if (lp->numtags > lp->maxtags)
6019 lp->maxtags = lp->numtags;
6020
6021 /*
6022 ** If we want to switch tag mode, we must wait
6023 ** for no CCB to be active.
6024 */
6025 if (reqtags > 1 && lp->usetags) { /* Stay in tagged mode */
6026 if (lp->queuedepth == reqtags) /* Already announced */
6027 return;
6028 lp->queuedepth = reqtags;
6029 }
6030 else if (reqtags <= 1 && !lp->usetags) { /* Stay in untagged mode */
6031 lp->queuedepth = reqtags;
6032 return;
6033 }
6034 else { /* Want to switch tag mode */
6035 if (lp->busyccbs) /* If not yet safe, return */
6036 return;
6037 lp->queuedepth = reqtags;
6038 lp->usetags = reqtags > 1 ? 1 : 0;
6039 }
6040
6041 /*
6042 ** Patch the lun mini-script, according to tag mode.
6043 */
6044 lp->jump_tag.l_paddr = lp->usetags?
6045 cpu_to_scr(NCB_SCRIPT_PHYS(np, resel_tag)) :
6046 cpu_to_scr(NCB_SCRIPT_PHYS(np, resel_notag));
6047
6048 /*
6049 ** Announce change to user.
6050 */
6051 if (bootverbose) {
6052 PRINT_LUN(np, tn, ln);
6053 if (lp->usetags) {
6054 printk("tagged command queue depth set to %d\n", reqtags);
6055 }
6056 else {
6057 printk("tagged command queueing disabled\n");
6058 }
6059 }
6060 }
6061
6062 /*----------------------------------------------------
6063 **
6064 ** handle user commands
6065 **
6066 **----------------------------------------------------
6067 */
6068
6069 #ifdef SCSI_NCR_USER_COMMAND_SUPPORT
6070
6071 static void ncr_usercmd (ncb_p np)
6072 {
6073 u_char t;
6074 tcb_p tp;
6075
6076 switch (np->user.cmd) {
6077
6078 case 0: return;
6079
6080 case UC_SETSYNC:
6081 for (t=0; t<MAX_TARGET; t++) {
6082 if (!((np->user.target>>t)&1)) continue;
6083 tp = &np->target[t];
6084 tp->usrsync = np->user.data;
6085 ncr_negotiate (np, tp);
6086 };
6087 break;
6088
6089 case UC_SETTAGS:
6090 for (t=0; t<MAX_TARGET; t++) {
6091 int ln;
6092 if (!((np->user.target>>t)&1)) continue;
6093 np->target[t].usrtags = np->user.data;
6094 for (ln = 0; ln < MAX_LUN; ln++) {
6095 lcb_p lp = np->target[t].lp[ln];
6096 if (!lp)
6097 continue;
6098 lp->maxtags = lp->numtags = np->user.data;
6099 ncr_setup_tags (np, t, ln);
6100 }
6101 };
6102 break;
6103
6104 case UC_SETDEBUG:
6105 #ifdef SCSI_NCR_DEBUG_INFO_SUPPORT
6106 ncr_debug = np->user.data;
6107 #endif
6108 break;
6109
6110 case UC_SETORDER:
6111 np->order = np->user.data;
6112 break;
6113
6114 case UC_SETVERBOSE:
6115 np->verbose = np->user.data;
6116 break;
6117
6118 case UC_SETWIDE:
6119 for (t=0; t<MAX_TARGET; t++) {
6120 u_long size;
6121 if (!((np->user.target>>t)&1)) continue;
6122 tp = &np->target[t];
6123 size = np->user.data;
6124 if (size > np->maxwide) size=np->maxwide;
6125 tp->usrwide = size;
6126 ncr_negotiate (np, tp);
6127 };
6128 break;
6129
6130 case UC_SETFLAG:
6131 for (t=0; t<MAX_TARGET; t++) {
6132 if (!((np->user.target>>t)&1)) continue;
6133 tp = &np->target[t];
6134 tp->usrflag = np->user.data;
6135 };
6136 break;
6137 }
6138 np->user.cmd=0;
6139 }
6140 #endif
6141
6142 /*==========================================================
6143 **
6144 **
6145 ** ncr timeout handler.
6146 **
6147 **
6148 **==========================================================
6149 **
6150 ** Misused to keep the driver running when
6151 ** interrupts are not configured correctly.
6152 **
6153 **----------------------------------------------------------
6154 */
6155
6156 static void ncr_timeout (ncb_p np)
6157 {
6158 u_long thistime = ktime_get(0);
6159
6160 /*
6161 ** If release process in progress, let's go
6162 ** Set the release stage from 1 to 2 to synchronize
6163 ** with the release process.
6164 */
6165
6166 if (np->release_stage) {
6167 if (np->release_stage == 1) np->release_stage = 2;
6168 return;
6169 }
6170
6171 np->timer.expires = ktime_get(SCSI_NCR_TIMER_INTERVAL);
6172 add_timer(&np->timer);
6173
6174 /*
6175 ** If we are resetting the ncr, wait for settle_time before
6176 ** clearing it. Then command processing will be resumed.
6177 */
6178 if (np->settle_time) {
6179 if (np->settle_time <= thistime) {
6180 if (bootverbose > 1)
6181 printk("%s: command processing resumed\n", ncr_name(np));
6182 np->settle_time = 0;
6183 np->disc = 1;
6184 requeue_waiting_list(np);
6185 }
6186 return;
6187 }
6188
6189 /*
6190 ** Since the generic scsi driver only allows us 0.5 second
6191 ** to perform abort of a command, we must look at ccbs about
6192 ** every 0.25 second.
6193 */
6194 if (np->lasttime + 4*HZ < thistime) {
6195 /*
6196 ** block ncr interrupts
6197 */
6198 np->lasttime = thistime;
6199 }
6200
6201 #ifdef SCSI_NCR_BROKEN_INTR
6202 if (INB(nc_istat) & (INTF|SIP|DIP)) {
6203
6204 /*
6205 ** Process pending interrupts.
6206 */
6207 if (DEBUG_FLAGS & DEBUG_TINY) printk ("{");
6208 ncr_exception (np);
6209 if (DEBUG_FLAGS & DEBUG_TINY) printk ("}");
6210 }
6211 #endif /* SCSI_NCR_BROKEN_INTR */
6212 }
6213
6214 /*==========================================================
6215 **
6216 ** log message for real hard errors
6217 **
6218 ** "ncr0 targ 0?: ERROR (ds:si) (so-si-sd) (sxfer/scntl3) @ name (dsp:dbc)."
6219 ** " reg: r0 r1 r2 r3 r4 r5 r6 ..... rf."
6220 **
6221 ** exception register:
6222 ** ds: dstat
6223 ** si: sist
6224 **
6225 ** SCSI bus lines:
6226 ** so: control lines as driver by NCR.
6227 ** si: control lines as seen by NCR.
6228 ** sd: scsi data lines as seen by NCR.
6229 **
6230 ** wide/fastmode:
6231 ** sxfer: (see the manual)
6232 ** scntl3: (see the manual)
6233 **
6234 ** current script command:
6235 ** dsp: script address (relative to start of script).
6236 ** dbc: first word of script command.
6237 **
6238 ** First 16 register of the chip:
6239 ** r0..rf
6240 **
6241 **==========================================================
6242 */
6243
6244 static void ncr_log_hard_error(ncb_p np, u_short sist, u_char dstat)
6245 {
6246 u_int32 dsp;
6247 int script_ofs;
6248 int script_size;
6249 char *script_name;
6250 u_char *script_base;
6251 int i;
6252
6253 dsp = INL (nc_dsp);
6254
6255 if (dsp > np->p_script && dsp <= np->p_script + sizeof(struct script)) {
6256 script_ofs = dsp - np->p_script;
6257 script_size = sizeof(struct script);
6258 script_base = (u_char *) np->script0;
6259 script_name = "script";
6260 }
6261 else if (np->p_scripth < dsp &&
6262 dsp <= np->p_scripth + sizeof(struct scripth)) {
6263 script_ofs = dsp - np->p_scripth;
6264 script_size = sizeof(struct scripth);
6265 script_base = (u_char *) np->scripth0;
6266 script_name = "scripth";
6267 } else {
6268 script_ofs = dsp;
6269 script_size = 0;
6270 script_base = 0;
6271 script_name = "mem";
6272 }
6273
6274 printk ("%s:%d: ERROR (%x:%x) (%x-%x-%x) (%x/%x) @ (%s %x:%08x).\n",
6275 ncr_name (np), (unsigned)INB (nc_sdid)&0x0f, dstat, sist,
6276 (unsigned)INB (nc_socl), (unsigned)INB (nc_sbcl), (unsigned)INB (nc_sbdl),
6277 (unsigned)INB (nc_sxfer),(unsigned)INB (nc_scntl3), script_name, script_ofs,
6278 (unsigned)INL (nc_dbc));
6279
6280 if (((script_ofs & 3) == 0) &&
6281 (unsigned)script_ofs < script_size) {
6282 printk ("%s: script cmd = %08x\n", ncr_name(np),
6283 scr_to_cpu((int) *(ncrcmd *)(script_base + script_ofs)));
6284 }
6285
6286 printk ("%s: regdump:", ncr_name(np));
6287 for (i=0; i<16;i++)
6288 printk (" %02x", (unsigned)INB_OFF(i));
6289 printk (".\n");
6290 }
6291
6292 /*============================================================
6293 **
6294 ** ncr chip exception handler.
6295 **
6296 **============================================================
6297 **
6298 ** In normal cases, interrupt conditions occur one at a
6299 ** time. The ncr is able to stack in some extra registers
6300 ** other interrupts that will occurs after the first one.
6301 ** But severall interrupts may occur at the same time.
6302 **
6303 ** We probably should only try to deal with the normal
6304 ** case, but it seems that multiple interrupts occur in
6305 ** some cases that are not abnormal at all.
6306 **
6307 ** The most frequent interrupt condition is Phase Mismatch.
6308 ** We should want to service this interrupt quickly.
6309 ** A SCSI parity error may be delivered at the same time.
6310 ** The SIR interrupt is not very frequent in this driver,
6311 ** since the INTFLY is likely used for command completion
6312 ** signaling.
6313 ** The Selection Timeout interrupt may be triggered with
6314 ** IID and/or UDC.
6315 ** The SBMC interrupt (SCSI Bus Mode Change) may probably
6316 ** occur at any time.
6317 **
6318 ** This handler try to deal as cleverly as possible with all
6319 ** the above.
6320 **
6321 **============================================================
6322 */
6323
6324 void ncr_exception (ncb_p np)
6325 {
6326 u_char istat, dstat;
6327 u_short sist;
6328 int i;
6329
6330 /*
6331 ** interrupt on the fly ?
6332 ** Since the global header may be copied back to a CCB
6333 ** using a posted PCI memory write, the last operation on
6334 ** the istat register is a READ in order to flush posted
6335 ** PCI write commands.
6336 */
6337 istat = INB (nc_istat);
6338 if (istat & INTF) {
6339 OUTB (nc_istat, (istat & SIGP) | INTF);
6340 istat = INB (nc_istat);
6341 if (DEBUG_FLAGS & DEBUG_TINY) printk ("F ");
6342 ncr_wakeup_done (np);
6343 };
6344
6345 if (!(istat & (SIP|DIP)))
6346 return;
6347
6348 if (istat & CABRT)
6349 OUTB (nc_istat, CABRT);
6350
6351 /*
6352 ** Steinbach's Guideline for Systems Programming:
6353 ** Never test for an error condition you don't know how to handle.
6354 */
6355
6356 sist = (istat & SIP) ? INW (nc_sist) : 0;
6357 dstat = (istat & DIP) ? INB (nc_dstat) : 0;
6358
6359 if (DEBUG_FLAGS & DEBUG_TINY)
6360 printk ("<%d|%x:%x|%x:%x>",
6361 (int)INB(nc_scr0),
6362 dstat,sist,
6363 (unsigned)INL(nc_dsp),
6364 (unsigned)INL(nc_dbc));
6365
6366 /*========================================================
6367 ** First, interrupts we want to service cleanly.
6368 **
6369 ** Phase mismatch is the most frequent interrupt, and
6370 ** so we have to service it as quickly and as cleanly
6371 ** as possible.
6372 ** Programmed interrupts are rarely used in this driver,
6373 ** but we must handle them cleanly anyway.
6374 ** We try to deal with PAR and SBMC combined with
6375 ** some other interrupt(s).
6376 **=========================================================
6377 */
6378
6379 if (!(sist & (STO|GEN|HTH|SGE|UDC|RST)) &&
6380 !(dstat & (MDPE|BF|ABRT|IID))) {
6381 if ((sist & SBMC) && ncr_int_sbmc (np))
6382 return;
6383 if ((sist & PAR) && ncr_int_par (np))
6384 return;
6385 if (sist & MA) {
6386 ncr_int_ma (np);
6387 return;
6388 }
6389 if (dstat & SIR) {
6390 ncr_int_sir (np);
6391 return;
6392 }
6393 /*
6394 ** DEL 397 - 53C875 Rev 3 - Part Number 609-0392410 - ITEM 2.
6395 */
6396 if (!(sist & (SBMC|PAR)) && !(dstat & SSI)) {
6397 printk( "%s: unknown interrupt(s) ignored, "
6398 "ISTAT=%x DSTAT=%x SIST=%x\n",
6399 ncr_name(np), istat, dstat, sist);
6400 return;
6401 }
6402 OUTONB_STD ();
6403 return;
6404 };
6405
6406 /*========================================================
6407 ** Now, interrupts that need some fixing up.
6408 ** Order and multiple interrupts is so less important.
6409 **
6410 ** If SRST has been asserted, we just reset the chip.
6411 **
6412 ** Selection is intirely handled by the chip. If the
6413 ** chip says STO, we trust it. Seems some other
6414 ** interrupts may occur at the same time (UDC, IID), so
6415 ** we ignore them. In any case we do enough fix-up
6416 ** in the service routine.
6417 ** We just exclude some fatal dma errors.
6418 **=========================================================
6419 */
6420
6421 if (sist & RST) {
6422 ncr_init (np, 1, bootverbose ? "scsi reset" : NULL, HS_RESET);
6423 return;
6424 };
6425
6426 if ((sist & STO) &&
6427 !(dstat & (MDPE|BF|ABRT))) {
6428 /*
6429 ** DEL 397 - 53C875 Rev 3 - Part Number 609-0392410 - ITEM 1.
6430 */
6431 OUTONB (nc_ctest3, CLF);
6432
6433 ncr_int_sto (np);
6434 return;
6435 };
6436
6437 /*=========================================================
6438 ** Now, interrupts we are not able to recover cleanly.
6439 ** (At least for the moment).
6440 **
6441 ** Do the register dump.
6442 ** Log message for real hard errors.
6443 ** Clear all fifos.
6444 ** For MDPE, BF, ABORT, IID, SGE and HTH we reset the
6445 ** BUS and the chip.
6446 ** We are more soft for UDC.
6447 **=========================================================
6448 */
6449
6450 if (ktime_exp(np->regtime)) {
6451 np->regtime = ktime_get(10*HZ);
6452 for (i = 0; i<sizeof(np->regdump); i++)
6453 ((char*)&np->regdump)[i] = INB_OFF(i);
6454 np->regdump.nc_dstat = dstat;
6455 np->regdump.nc_sist = sist;
6456 };
6457
6458 ncr_log_hard_error(np, sist, dstat);
6459
6460 printk ("%s: have to clear fifos.\n", ncr_name (np));
6461 OUTB (nc_stest3, TE|CSF);
6462 OUTONB (nc_ctest3, CLF);
6463
6464 if ((sist & (SGE)) ||
6465 (dstat & (MDPE|BF|ABRT|IID))) {
6466 ncr_start_reset(np);
6467 return;
6468 };
6469
6470 if (sist & HTH) {
6471 printk ("%s: handshake timeout\n", ncr_name(np));
6472 ncr_start_reset(np);
6473 return;
6474 };
6475
6476 if (sist & UDC) {
6477 printk ("%s: unexpected disconnect\n", ncr_name(np));
6478 OUTB (HS_PRT, HS_UNEXPECTED);
6479 OUTL_DSP (NCB_SCRIPT_PHYS (np, cleanup));
6480 return;
6481 };
6482
6483 /*=========================================================
6484 ** We just miss the cause of the interrupt. :(
6485 ** Print a message. The timeout will do the real work.
6486 **=========================================================
6487 */
6488 printk ("%s: unknown interrupt\n", ncr_name(np));
6489 }
6490
6491 /*==========================================================
6492 **
6493 ** ncr chip exception handler for selection timeout
6494 **
6495 **==========================================================
6496 **
6497 ** There seems to be a bug in the 53c810.
6498 ** Although a STO-Interrupt is pending,
6499 ** it continues executing script commands.
6500 ** But it will fail and interrupt (IID) on
6501 ** the next instruction where it's looking
6502 ** for a valid phase.
6503 **
6504 **----------------------------------------------------------
6505 */
6506
6507 void ncr_int_sto (ncb_p np)
6508 {
6509 u_long dsa;
6510 ccb_p cp;
6511 if (DEBUG_FLAGS & DEBUG_TINY) printk ("T");
6512
6513 /*
6514 ** look for ccb and set the status.
6515 */
6516
6517 dsa = INL (nc_dsa);
6518 cp = np->ccb;
6519 while (cp && (CCB_PHYS (cp, phys) != dsa))
6520 cp = cp->link_ccb;
6521
6522 if (cp) {
6523 cp-> host_status = HS_SEL_TIMEOUT;
6524 ncr_complete (np, cp);
6525 };
6526
6527 /*
6528 ** repair start queue and jump to start point.
6529 */
6530
6531 OUTL_DSP (NCB_SCRIPTH_PHYS (np, sto_restart));
6532 return;
6533 }
6534
6535 /*==========================================================
6536 **
6537 ** ncr chip exception handler for SCSI bus mode change
6538 **
6539 **==========================================================
6540 **
6541 ** spi2-r12 11.2.3 says a transceiver mode change must
6542 ** generate a reset event and a device that detects a reset
6543 ** event shall initiate a hard reset. It says also that a
6544 ** device that detects a mode change shall set data transfer
6545 ** mode to eight bit asynchronous, etc...
6546 ** So, just resetting should be enough.
6547 **
6548 **
6549 **----------------------------------------------------------
6550 */
6551
6552 static int ncr_int_sbmc (ncb_p np)
6553 {
6554 u_char scsi_mode = INB (nc_stest4) & SMODE;
6555
6556 if (scsi_mode != np->scsi_mode) {
6557 printk("%s: SCSI bus mode change from %x to %x.\n",
6558 ncr_name(np), np->scsi_mode, scsi_mode);
6559
6560 np->scsi_mode = scsi_mode;
6561
6562
6563 /*
6564 ** Suspend command processing for 1 second and
6565 ** reinitialize all except the chip.
6566 */
6567 np->settle_time = ktime_get(1*HZ);
6568 ncr_init (np, 0, bootverbose ? "scsi mode change" : NULL, HS_RESET);
6569 return 1;
6570 }
6571 return 0;
6572 }
6573
6574 /*==========================================================
6575 **
6576 ** ncr chip exception handler for SCSI parity error.
6577 **
6578 **==========================================================
6579 **
6580 **
6581 **----------------------------------------------------------
6582 */
6583
6584 static int ncr_int_par (ncb_p np)
6585 {
6586 u_char hsts = INB (HS_PRT);
6587 u_int32 dbc = INL (nc_dbc);
6588 u_char sstat1 = INB (nc_sstat1);
6589 int phase = -1;
6590 int msg = -1;
6591 u_int32 jmp;
6592
6593 printk("%s: SCSI parity error detected: SCR1=%d DBC=%x SSTAT1=%x\n",
6594 ncr_name(np), hsts, dbc, sstat1);
6595
6596 /*
6597 * Ignore the interrupt if the NCR is not connected
6598 * to the SCSI bus, since the right work should have
6599 * been done on unexpected disconnection handling.
6600 */
6601 if (!(INB (nc_scntl1) & ISCON))
6602 return 0;
6603
6604 /*
6605 * If the nexus is not clearly identified, reset the bus.
6606 * We will try to do better later.
6607 */
6608 if (hsts & HS_INVALMASK)
6609 goto reset_all;
6610
6611 /*
6612 * If the SCSI parity error occurs in MSG IN phase, prepare a
6613 * MSG PARITY message. Otherwise, prepare a INITIATOR DETECTED
6614 * ERROR message and let the device decide to retry the command
6615 * or to terminate with check condition. If we were in MSG IN
6616 * phase waiting for the response of a negotiation, we will
6617 * get SIR_NEGO_FAILED at dispatch.
6618 */
6619 if (!(dbc & 0xc0000000))
6620 phase = (dbc >> 24) & 7;
6621 if (phase == 7)
6622 msg = M_PARITY;
6623 else
6624 msg = M_ID_ERROR;
6625
6626 #ifdef SCSI_NCR_INTEGRITY_CHECKING
6627 /*
6628 ** Save error message. For integrity check use only.
6629 */
6630 if (np->check_integrity)
6631 np->check_integ_par = msg;
6632 #endif
6633
6634 /*
6635 * If the NCR stopped on a MOVE ^ DATA_IN, we jump to a
6636 * script that will ignore all data in bytes until phase
6637 * change, since we are not sure the chip will wait the phase
6638 * change prior to delivering the interrupt.
6639 */
6640 if (phase == 1)
6641 jmp = NCB_SCRIPTH_PHYS (np, par_err_data_in);
6642 else
6643 jmp = NCB_SCRIPTH_PHYS (np, par_err_other);
6644
6645 OUTONB (nc_ctest3, CLF ); /* clear dma fifo */
6646 OUTB (nc_stest3, TE|CSF); /* clear scsi fifo */
6647
6648 np->msgout[0] = msg;
6649 OUTL_DSP (jmp);
6650 return 1;
6651
6652 reset_all:
6653 ncr_start_reset(np);
6654 return 1;
6655 }
6656
6657 /*==========================================================
6658 **
6659 **
6660 ** ncr chip exception handler for phase errors.
6661 **
6662 **
6663 **==========================================================
6664 **
6665 ** We have to construct a new transfer descriptor,
6666 ** to transfer the rest of the current block.
6667 **
6668 **----------------------------------------------------------
6669 */
6670
6671 static void ncr_int_ma (ncb_p np)
6672 {
6673 u_int32 dbc;
6674 u_int32 rest;
6675 u_int32 dsp;
6676 u_int32 dsa;
6677 u_int32 nxtdsp;
6678 u_int32 newtmp;
6679 u_int32 *vdsp;
6680 u_int32 oadr, olen;
6681 u_int32 *tblp;
6682 ncrcmd *newcmd;
6683 u_char cmd, sbcl;
6684 ccb_p cp;
6685
6686 dsp = INL (nc_dsp);
6687 dbc = INL (nc_dbc);
6688 sbcl = INB (nc_sbcl);
6689
6690 cmd = dbc >> 24;
6691 rest = dbc & 0xffffff;
6692
6693 /*
6694 ** Take into account dma fifo and various buffers and latches,
6695 ** only if the interrupted phase is an OUTPUT phase.
6696 */
6697
6698 if ((cmd & 1) == 0) {
6699 u_char ctest5, ss0, ss2;
6700 u_short delta;
6701
6702 ctest5 = (np->rv_ctest5 & DFS) ? INB (nc_ctest5) : 0;
6703 if (ctest5 & DFS)
6704 delta=(((ctest5 << 8) | (INB (nc_dfifo) & 0xff)) - rest) & 0x3ff;
6705 else
6706 delta=(INB (nc_dfifo) - rest) & 0x7f;
6707
6708 /*
6709 ** The data in the dma fifo has not been transferred to
6710 ** the target -> add the amount to the rest
6711 ** and clear the data.
6712 ** Check the sstat2 register in case of wide transfer.
6713 */
6714
6715 rest += delta;
6716 ss0 = INB (nc_sstat0);
6717 if (ss0 & OLF) rest++;
6718 if (ss0 & ORF) rest++;
6719 if (INB(nc_scntl3) & EWS) {
6720 ss2 = INB (nc_sstat2);
6721 if (ss2 & OLF1) rest++;
6722 if (ss2 & ORF1) rest++;
6723 };
6724
6725 if (DEBUG_FLAGS & (DEBUG_TINY|DEBUG_PHASE))
6726 printk ("P%x%x RL=%d D=%d SS0=%x ", cmd&7, sbcl&7,
6727 (unsigned) rest, (unsigned) delta, ss0);
6728
6729 } else {
6730 if (DEBUG_FLAGS & (DEBUG_TINY|DEBUG_PHASE))
6731 printk ("P%x%x RL=%d ", cmd&7, sbcl&7, rest);
6732 }
6733
6734 /*
6735 ** Clear fifos.
6736 */
6737 OUTONB (nc_ctest3, CLF ); /* clear dma fifo */
6738 OUTB (nc_stest3, TE|CSF); /* clear scsi fifo */
6739
6740 /*
6741 ** locate matching cp.
6742 ** if the interrupted phase is DATA IN or DATA OUT,
6743 ** trust the global header.
6744 */
6745 dsa = INL (nc_dsa);
6746 if (!(cmd & 6)) {
6747 cp = np->header.cp;
6748 if (CCB_PHYS(cp, phys) != dsa)
6749 cp = 0;
6750 } else {
6751 cp = np->ccb;
6752 while (cp && (CCB_PHYS (cp, phys) != dsa))
6753 cp = cp->link_ccb;
6754 }
6755
6756 /*
6757 ** try to find the interrupted script command,
6758 ** and the address at which to continue.
6759 */
6760 vdsp = 0;
6761 nxtdsp = 0;
6762 if (dsp > np->p_script &&
6763 dsp <= np->p_script + sizeof(struct script)) {
6764 vdsp = (u_int32 *)((char*)np->script0 + (dsp-np->p_script-8));
6765 nxtdsp = dsp;
6766 }
6767 else if (dsp > np->p_scripth &&
6768 dsp <= np->p_scripth + sizeof(struct scripth)) {
6769 vdsp = (u_int32 *)((char*)np->scripth0 + (dsp-np->p_scripth-8));
6770 nxtdsp = dsp;
6771 }
6772 else if (cp) {
6773 if (dsp == CCB_PHYS (cp, patch[2])) {
6774 vdsp = &cp->patch[0];
6775 nxtdsp = scr_to_cpu(vdsp[3]);
6776 }
6777 else if (dsp == CCB_PHYS (cp, patch[6])) {
6778 vdsp = &cp->patch[4];
6779 nxtdsp = scr_to_cpu(vdsp[3]);
6780 }
6781 }
6782
6783 /*
6784 ** log the information
6785 */
6786
6787 if (DEBUG_FLAGS & DEBUG_PHASE) {
6788 printk ("\nCP=%p CP2=%p DSP=%x NXT=%x VDSP=%p CMD=%x ",
6789 cp, np->header.cp,
6790 (unsigned)dsp,
6791 (unsigned)nxtdsp, vdsp, cmd);
6792 };
6793
6794 /*
6795 ** cp=0 means that the DSA does not point to a valid control
6796 ** block. This should not happen since we donnot use multi-byte
6797 ** move while we are being reselected ot after command complete.
6798 ** We are not able to recover from such a phase error.
6799 */
6800 if (!cp) {
6801 printk ("%s: SCSI phase error fixup: "
6802 "CCB already dequeued (0x%08lx)\n",
6803 ncr_name (np), (u_long) np->header.cp);
6804 goto reset_all;
6805 }
6806
6807 /*
6808 ** get old startaddress and old length.
6809 */
6810
6811 oadr = scr_to_cpu(vdsp[1]);
6812
6813 if (cmd & 0x10) { /* Table indirect */
6814 tblp = (u_int32 *) ((char*) &cp->phys + oadr);
6815 olen = scr_to_cpu(tblp[0]);
6816 oadr = scr_to_cpu(tblp[1]);
6817 } else {
6818 tblp = (u_int32 *) 0;
6819 olen = scr_to_cpu(vdsp[0]) & 0xffffff;
6820 };
6821
6822 if (DEBUG_FLAGS & DEBUG_PHASE) {
6823 printk ("OCMD=%x\nTBLP=%p OLEN=%x OADR=%x\n",
6824 (unsigned) (scr_to_cpu(vdsp[0]) >> 24),
6825 tblp,
6826 (unsigned) olen,
6827 (unsigned) oadr);
6828 };
6829
6830 /*
6831 ** check cmd against assumed interrupted script command.
6832 */
6833
6834 if (cmd != (scr_to_cpu(vdsp[0]) >> 24)) {
6835 PRINT_ADDR(cp->cmd);
6836 printk ("internal error: cmd=%02x != %02x=(vdsp[0] >> 24)\n",
6837 (unsigned)cmd, (unsigned)scr_to_cpu(vdsp[0]) >> 24);
6838
6839 goto reset_all;
6840 }
6841
6842 /*
6843 ** cp != np->header.cp means that the header of the CCB
6844 ** currently being processed has not yet been copied to
6845 ** the global header area. That may happen if the device did
6846 ** not accept all our messages after having been selected.
6847 */
6848 if (cp != np->header.cp) {
6849 printk ("%s: SCSI phase error fixup: "
6850 "CCB address mismatch (0x%08lx != 0x%08lx)\n",
6851 ncr_name (np), (u_long) cp, (u_long) np->header.cp);
6852 }
6853
6854 /*
6855 ** if old phase not dataphase, leave here.
6856 */
6857
6858 if (cmd & 0x06) {
6859 PRINT_ADDR(cp->cmd);
6860 printk ("phase change %x-%x %d@%08x resid=%d.\n",
6861 cmd&7, sbcl&7, (unsigned)olen,
6862 (unsigned)oadr, (unsigned)rest);
6863 goto unexpected_phase;
6864 };
6865
6866 /*
6867 ** choose the correct patch area.
6868 ** if savep points to one, choose the other.
6869 */
6870
6871 newcmd = cp->patch;
6872 newtmp = CCB_PHYS (cp, patch);
6873 if (newtmp == scr_to_cpu(cp->phys.header.savep)) {
6874 newcmd = &cp->patch[4];
6875 newtmp = CCB_PHYS (cp, patch[4]);
6876 }
6877
6878 /*
6879 ** fillin the commands
6880 */
6881
6882 newcmd[0] = cpu_to_scr(((cmd & 0x0f) << 24) | rest);
6883 newcmd[1] = cpu_to_scr(oadr + olen - rest);
6884 newcmd[2] = cpu_to_scr(SCR_JUMP);
6885 newcmd[3] = cpu_to_scr(nxtdsp);
6886
6887 if (DEBUG_FLAGS & DEBUG_PHASE) {
6888 PRINT_ADDR(cp->cmd);
6889 printk ("newcmd[%d] %x %x %x %x.\n",
6890 (int) (newcmd - cp->patch),
6891 (unsigned)scr_to_cpu(newcmd[0]),
6892 (unsigned)scr_to_cpu(newcmd[1]),
6893 (unsigned)scr_to_cpu(newcmd[2]),
6894 (unsigned)scr_to_cpu(newcmd[3]));
6895 }
6896 /*
6897 ** fake the return address (to the patch).
6898 ** and restart script processor at dispatcher.
6899 */
6900 OUTL (nc_temp, newtmp);
6901 OUTL_DSP (NCB_SCRIPT_PHYS (np, dispatch));
6902 return;
6903
6904 /*
6905 ** Unexpected phase changes that occurs when the current phase
6906 ** is not a DATA IN or DATA OUT phase are due to error conditions.
6907 ** Such event may only happen when the SCRIPTS is using a
6908 ** multibyte SCSI MOVE.
6909 **
6910 ** Phase change Some possible cause
6911 **
6912 ** COMMAND --> MSG IN SCSI parity error detected by target.
6913 ** COMMAND --> STATUS Bad command or refused by target.
6914 ** MSG OUT --> MSG IN Message rejected by target.
6915 ** MSG OUT --> COMMAND Bogus target that discards extended
6916 ** negotiation messages.
6917 **
6918 ** The code below does not care of the new phase and so
6919 ** trusts the target. Why to annoy it ?
6920 ** If the interrupted phase is COMMAND phase, we restart at
6921 ** dispatcher.
6922 ** If a target does not get all the messages after selection,
6923 ** the code assumes blindly that the target discards extended
6924 ** messages and clears the negotiation status.
6925 ** If the target does not want all our response to negotiation,
6926 ** we force a SIR_NEGO_PROTO interrupt (it is a hack that avoids
6927 ** bloat for such a should_not_happen situation).
6928 ** In all other situation, we reset the BUS.
6929 ** Are these assumptions reasonnable ? (Wait and see ...)
6930 */
6931 unexpected_phase:
6932 dsp -= 8;
6933 nxtdsp = 0;
6934
6935 switch (cmd & 7) {
6936 case 2: /* COMMAND phase */
6937 nxtdsp = NCB_SCRIPT_PHYS (np, dispatch);
6938 break;
6939 #if 0
6940 case 3: /* STATUS phase */
6941 nxtdsp = NCB_SCRIPT_PHYS (np, dispatch);
6942 break;
6943 #endif
6944 case 6: /* MSG OUT phase */
6945 np->scripth->nxtdsp_go_on[0] = cpu_to_scr(dsp + 8);
6946 if (dsp == NCB_SCRIPT_PHYS (np, send_ident)) {
6947 cp->host_status = HS_BUSY;
6948 nxtdsp = NCB_SCRIPTH_PHYS (np, clratn_go_on);
6949 }
6950 else if (dsp == NCB_SCRIPTH_PHYS (np, send_wdtr) ||
6951 dsp == NCB_SCRIPTH_PHYS (np, send_sdtr)) {
6952 nxtdsp = NCB_SCRIPTH_PHYS (np, nego_bad_phase);
6953 }
6954 break;
6955 #if 0
6956 case 7: /* MSG IN phase */
6957 nxtdsp = NCB_SCRIPT_PHYS (np, clrack);
6958 break;
6959 #endif
6960 }
6961
6962 if (nxtdsp) {
6963 OUTL_DSP (nxtdsp);
6964 return;
6965 }
6966
6967 reset_all:
6968 ncr_start_reset(np);
6969 }
6970
6971
6972 static void ncr_sir_to_redo(ncb_p np, int num, ccb_p cp)
6973 {
6974 Scsi_Cmnd *cmd = cp->cmd;
6975 tcb_p tp = &np->target[cmd->device->id];
6976 lcb_p lp = tp->lp[cmd->device->lun];
6977 XPT_QUEHEAD *qp;
6978 ccb_p cp2;
6979 int disc_cnt = 0;
6980 int busy_cnt = 0;
6981 u_int32 startp;
6982 u_char s_status = INB (SS_PRT);
6983
6984 /*
6985 ** Let the SCRIPTS processor skip all not yet started CCBs,
6986 ** and count disconnected CCBs. Since the busy queue is in
6987 ** the same order as the chip start queue, disconnected CCBs
6988 ** are before cp and busy ones after.
6989 */
6990 if (lp) {
6991 qp = lp->busy_ccbq.blink;
6992 while (qp != &lp->busy_ccbq) {
6993 cp2 = xpt_que_entry(qp, struct ccb, link_ccbq);
6994 qp = qp->blink;
6995 ++busy_cnt;
6996 if (cp2 == cp)
6997 break;
6998 cp2->start.schedule.l_paddr =
6999 cpu_to_scr(NCB_SCRIPTH_PHYS (np, skip));
7000 }
7001 lp->held_ccb = cp; /* Requeue when this one completes */
7002 disc_cnt = lp->queuedccbs - busy_cnt;
7003 }
7004
7005 switch(s_status) {
7006 default: /* Just for safety, should never happen */
7007 case S_QUEUE_FULL:
7008 /*
7009 ** Decrease number of tags to the number of
7010 ** disconnected commands.
7011 */
7012 if (!lp)
7013 goto out;
7014 if (bootverbose >= 1) {
7015 PRINT_ADDR(cmd);
7016 printk ("QUEUE FULL! %d busy, %d disconnected CCBs\n",
7017 busy_cnt, disc_cnt);
7018 }
7019 if (disc_cnt < lp->numtags) {
7020 lp->numtags = disc_cnt > 2 ? disc_cnt : 2;
7021 lp->num_good = 0;
7022 ncr_setup_tags (np, cmd->device->id, cmd->device->lun);
7023 }
7024 /*
7025 ** Requeue the command to the start queue.
7026 ** If any disconnected commands,
7027 ** Clear SIGP.
7028 ** Jump to reselect.
7029 */
7030 cp->phys.header.savep = cp->startp;
7031 cp->host_status = HS_BUSY;
7032 cp->scsi_status = S_ILLEGAL;
7033
7034 ncr_put_start_queue(np, cp);
7035 if (disc_cnt)
7036 INB (nc_ctest2); /* Clear SIGP */
7037 OUTL_DSP (NCB_SCRIPT_PHYS (np, reselect));
7038 return;
7039 case S_TERMINATED:
7040 case S_CHECK_COND:
7041 /*
7042 ** If we were requesting sense, give up.
7043 */
7044 if (cp->auto_sense)
7045 goto out;
7046
7047 /*
7048 ** Device returned CHECK CONDITION status.
7049 ** Prepare all needed data strutures for getting
7050 ** sense data.
7051 **
7052 ** identify message
7053 */
7054 cp->scsi_smsg2[0] = M_IDENTIFY | cmd->device->lun;
7055 cp->phys.smsg.addr = cpu_to_scr(CCB_PHYS (cp, scsi_smsg2));
7056 cp->phys.smsg.size = cpu_to_scr(1);
7057
7058 /*
7059 ** sense command
7060 */
7061 cp->phys.cmd.addr = cpu_to_scr(CCB_PHYS (cp, sensecmd));
7062 cp->phys.cmd.size = cpu_to_scr(6);
7063
7064 /*
7065 ** patch requested size into sense command
7066 */
7067 cp->sensecmd[0] = 0x03;
7068 cp->sensecmd[1] = cmd->device->lun << 5;
7069 cp->sensecmd[4] = sizeof(cp->sense_buf);
7070
7071 /*
7072 ** sense data
7073 */
7074 bzero(cp->sense_buf, sizeof(cp->sense_buf));
7075 cp->phys.sense.addr = cpu_to_scr(CCB_PHYS(cp,sense_buf[0]));
7076 cp->phys.sense.size = cpu_to_scr(sizeof(cp->sense_buf));
7077
7078 /*
7079 ** requeue the command.
7080 */
7081 startp = cpu_to_scr(NCB_SCRIPTH_PHYS (np, sdata_in));
7082
7083 cp->phys.header.savep = startp;
7084 cp->phys.header.goalp = startp + 24;
7085 cp->phys.header.lastp = startp;
7086 cp->phys.header.wgoalp = startp + 24;
7087 cp->phys.header.wlastp = startp;
7088
7089 cp->host_status = HS_BUSY;
7090 cp->scsi_status = S_ILLEGAL;
7091 cp->auto_sense = s_status;
7092
7093 cp->start.schedule.l_paddr =
7094 cpu_to_scr(NCB_SCRIPT_PHYS (np, select));
7095
7096 /*
7097 ** Select without ATN for quirky devices.
7098 */
7099 if (tp->quirks & QUIRK_NOMSG)
7100 cp->start.schedule.l_paddr =
7101 cpu_to_scr(NCB_SCRIPTH_PHYS (np, select_no_atn));
7102
7103 ncr_put_start_queue(np, cp);
7104
7105 OUTL_DSP (NCB_SCRIPT_PHYS (np, start));
7106 return;
7107 }
7108
7109 out:
7110 OUTONB_STD ();
7111 return;
7112 }
7113
7114
7115 /*==========================================================
7116 **
7117 **
7118 ** ncr chip exception handler for programmed interrupts.
7119 **
7120 **
7121 **==========================================================
7122 */
7123
7124 static int ncr_show_msg (u_char * msg)
7125 {
7126 u_char i;
7127 printk ("%x",*msg);
7128 if (*msg==M_EXTENDED) {
7129 for (i=1;i<8;i++) {
7130 if (i-1>msg[1]) break;
7131 printk ("-%x",msg[i]);
7132 };
7133 return (i+1);
7134 } else if ((*msg & 0xf0) == 0x20) {
7135 printk ("-%x",msg[1]);
7136 return (2);
7137 };
7138 return (1);
7139 }
7140
7141 static void ncr_print_msg ( ccb_p cp, char *label, u_char *msg)
7142 {
7143 if (cp)
7144 PRINT_ADDR(cp->cmd);
7145 if (label)
7146 printk("%s: ", label);
7147
7148 (void) ncr_show_msg (msg);
7149 printk(".\n");
7150 }
7151
7152 void ncr_int_sir (ncb_p np)
7153 {
7154 u_char scntl3;
7155 u_char chg, ofs, per, fak, wide;
7156 u_char num = INB (nc_dsps);
7157 ccb_p cp=0;
7158 u_long dsa = INL (nc_dsa);
7159 u_char target = INB (nc_sdid) & 0x0f;
7160 tcb_p tp = &np->target[target];
7161
7162 if (DEBUG_FLAGS & DEBUG_TINY) printk ("I#%d", num);
7163
7164 switch (num) {
7165 case SIR_INTFLY:
7166 /*
7167 ** This is used for HP Zalon/53c720 where INTFLY
7168 ** operation is currently broken.
7169 */
7170 ncr_wakeup_done(np);
7171 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
7172 OUTL(nc_dsp, NCB_SCRIPT_PHYS (np, done_end) + 8);
7173 #else
7174 OUTL(nc_dsp, NCB_SCRIPT_PHYS (np, start));
7175 #endif
7176 return;
7177 case SIR_RESEL_NO_MSG_IN:
7178 case SIR_RESEL_NO_IDENTIFY:
7179 /*
7180 ** If devices reselecting without sending an IDENTIFY
7181 ** message still exist, this should help.
7182 ** We just assume lun=0, 1 CCB, no tag.
7183 */
7184 if (tp->lp[0]) {
7185 OUTL_DSP (scr_to_cpu(tp->lp[0]->jump_ccb[0]));
7186 return;
7187 }
7188 case SIR_RESEL_BAD_TARGET: /* Will send a TARGET RESET message */
7189 case SIR_RESEL_BAD_LUN: /* Will send a TARGET RESET message */
7190 case SIR_RESEL_BAD_I_T_L_Q: /* Will send an ABORT TAG message */
7191 case SIR_RESEL_BAD_I_T_L: /* Will send an ABORT message */
7192 printk ("%s:%d: SIR %d, "
7193 "incorrect nexus identification on reselection\n",
7194 ncr_name (np), target, num);
7195 goto out;
7196 case SIR_DONE_OVERFLOW:
7197 printk ("%s:%d: SIR %d, "
7198 "CCB done queue overflow\n",
7199 ncr_name (np), target, num);
7200 goto out;
7201 case SIR_BAD_STATUS:
7202 cp = np->header.cp;
7203 if (!cp || CCB_PHYS (cp, phys) != dsa)
7204 goto out;
7205 ncr_sir_to_redo(np, num, cp);
7206 return;
7207 default:
7208 /*
7209 ** lookup the ccb
7210 */
7211 cp = np->ccb;
7212 while (cp && (CCB_PHYS (cp, phys) != dsa))
7213 cp = cp->link_ccb;
7214
7215 assert (cp && cp == np->header.cp);
7216
7217 if (!cp || cp != np->header.cp)
7218 goto out;
7219 }
7220
7221 switch (num) {
7222 /*-----------------------------------------------------------------------------
7223 **
7224 ** Was Sie schon immer ueber transfermode negotiation wissen wollten ...
7225 **
7226 ** We try to negotiate sync and wide transfer only after
7227 ** a successful inquire command. We look at byte 7 of the
7228 ** inquire data to determine the capabilities of the target.
7229 **
7230 ** When we try to negotiate, we append the negotiation message
7231 ** to the identify and (maybe) simple tag message.
7232 ** The host status field is set to HS_NEGOTIATE to mark this
7233 ** situation.
7234 **
7235 ** If the target doesn't answer this message immidiately
7236 ** (as required by the standard), the SIR_NEGO_FAIL interrupt
7237 ** will be raised eventually.
7238 ** The handler removes the HS_NEGOTIATE status, and sets the
7239 ** negotiated value to the default (async / nowide).
7240 **
7241 ** If we receive a matching answer immediately, we check it
7242 ** for validity, and set the values.
7243 **
7244 ** If we receive a Reject message immediately, we assume the
7245 ** negotiation has failed, and fall back to standard values.
7246 **
7247 ** If we receive a negotiation message while not in HS_NEGOTIATE
7248 ** state, it's a target initiated negotiation. We prepare a
7249 ** (hopefully) valid answer, set our parameters, and send back
7250 ** this answer to the target.
7251 **
7252 ** If the target doesn't fetch the answer (no message out phase),
7253 ** we assume the negotiation has failed, and fall back to default
7254 ** settings.
7255 **
7256 ** When we set the values, we adjust them in all ccbs belonging
7257 ** to this target, in the controller's register, and in the "phys"
7258 ** field of the controller's struct ncb.
7259 **
7260 ** Possible cases: hs sir msg_in value send goto
7261 ** We try to negotiate:
7262 ** -> target doesn't msgin NEG FAIL noop defa. - dispatch
7263 ** -> target rejected our msg NEG FAIL reject defa. - dispatch
7264 ** -> target answered (ok) NEG SYNC sdtr set - clrack
7265 ** -> target answered (!ok) NEG SYNC sdtr defa. REJ--->msg_bad
7266 ** -> target answered (ok) NEG WIDE wdtr set - clrack
7267 ** -> target answered (!ok) NEG WIDE wdtr defa. REJ--->msg_bad
7268 ** -> any other msgin NEG FAIL noop defa. - dispatch
7269 **
7270 ** Target tries to negotiate:
7271 ** -> incoming message --- SYNC sdtr set SDTR -
7272 ** -> incoming message --- WIDE wdtr set WDTR -
7273 ** We sent our answer:
7274 ** -> target doesn't msgout --- PROTO ? defa. - dispatch
7275 **
7276 **-----------------------------------------------------------------------------
7277 */
7278
7279 case SIR_NEGO_FAILED:
7280 /*-------------------------------------------------------
7281 **
7282 ** Negotiation failed.
7283 ** Target doesn't send an answer message,
7284 ** or target rejected our message.
7285 **
7286 ** Remove negotiation request.
7287 **
7288 **-------------------------------------------------------
7289 */
7290 OUTB (HS_PRT, HS_BUSY);
7291
7292 /* fall through */
7293
7294 case SIR_NEGO_PROTO:
7295 /*-------------------------------------------------------
7296 **
7297 ** Negotiation failed.
7298 ** Target doesn't fetch the answer message.
7299 **
7300 **-------------------------------------------------------
7301 */
7302
7303 if (DEBUG_FLAGS & DEBUG_NEGO) {
7304 PRINT_ADDR(cp->cmd);
7305 printk ("negotiation failed sir=%x status=%x.\n",
7306 num, cp->nego_status);
7307 };
7308
7309 /*
7310 ** any error in negotiation:
7311 ** fall back to default mode.
7312 */
7313 switch (cp->nego_status) {
7314
7315 case NS_SYNC:
7316 ncr_setsync (np, cp, 0, 0xe0);
7317 break;
7318
7319 case NS_WIDE:
7320 ncr_setwide (np, cp, 0, 0);
7321 break;
7322
7323 };
7324 np->msgin [0] = M_NOOP;
7325 np->msgout[0] = M_NOOP;
7326 cp->nego_status = 0;
7327 break;
7328
7329 case SIR_NEGO_SYNC:
7330 /*
7331 ** Synchronous request message received.
7332 */
7333
7334 if (DEBUG_FLAGS & DEBUG_NEGO) {
7335 PRINT_ADDR(cp->cmd);
7336 printk ("sync msgin: ");
7337 (void) ncr_show_msg (np->msgin);
7338 printk (".\n");
7339 };
7340
7341 /*
7342 ** get requested values.
7343 */
7344
7345 chg = 0;
7346 per = np->msgin[3];
7347 ofs = np->msgin[4];
7348 if (ofs==0) per=255;
7349
7350 /*
7351 ** if target sends SDTR message,
7352 ** it CAN transfer synch.
7353 */
7354
7355 if (ofs)
7356 tp->inq_byte7 |= INQ7_SYNC;
7357
7358 /*
7359 ** check values against driver limits.
7360 */
7361
7362 if (per < np->minsync)
7363 {chg = 1; per = np->minsync;}
7364 if (per < tp->minsync)
7365 {chg = 1; per = tp->minsync;}
7366 if (ofs > tp->maxoffs)
7367 {chg = 1; ofs = tp->maxoffs;}
7368
7369 /*
7370 ** Check against controller limits.
7371 */
7372 fak = 7;
7373 scntl3 = 0;
7374 if (ofs != 0) {
7375 ncr_getsync(np, per, &fak, &scntl3);
7376 if (fak > 7) {
7377 chg = 1;
7378 ofs = 0;
7379 }
7380 }
7381 if (ofs == 0) {
7382 fak = 7;
7383 per = 0;
7384 scntl3 = 0;
7385 tp->minsync = 0;
7386 }
7387
7388 if (DEBUG_FLAGS & DEBUG_NEGO) {
7389 PRINT_ADDR(cp->cmd);
7390 printk ("sync: per=%d scntl3=0x%x ofs=%d fak=%d chg=%d.\n",
7391 per, scntl3, ofs, fak, chg);
7392 }
7393
7394 if (INB (HS_PRT) == HS_NEGOTIATE) {
7395 OUTB (HS_PRT, HS_BUSY);
7396 switch (cp->nego_status) {
7397
7398 case NS_SYNC:
7399 /*
7400 ** This was an answer message
7401 */
7402 if (chg) {
7403 /*
7404 ** Answer wasn't acceptable.
7405 */
7406 ncr_setsync (np, cp, 0, 0xe0);
7407 OUTL_DSP (NCB_SCRIPT_PHYS (np, msg_bad));
7408 } else {
7409 /*
7410 ** Answer is ok.
7411 */
7412 ncr_setsync (np, cp, scntl3, (fak<<5)|ofs);
7413 OUTL_DSP (NCB_SCRIPT_PHYS (np, clrack));
7414 };
7415 return;
7416
7417 case NS_WIDE:
7418 ncr_setwide (np, cp, 0, 0);
7419 break;
7420 };
7421 };
7422
7423 /*
7424 ** It was a request. Set value and
7425 ** prepare an answer message
7426 */
7427
7428 ncr_setsync (np, cp, scntl3, (fak<<5)|ofs);
7429
7430 np->msgout[0] = M_EXTENDED;
7431 np->msgout[1] = 3;
7432 np->msgout[2] = M_X_SYNC_REQ;
7433 np->msgout[3] = per;
7434 np->msgout[4] = ofs;
7435
7436 cp->nego_status = NS_SYNC;
7437
7438 if (DEBUG_FLAGS & DEBUG_NEGO) {
7439 PRINT_ADDR(cp->cmd);
7440 printk ("sync msgout: ");
7441 (void) ncr_show_msg (np->msgout);
7442 printk (".\n");
7443 }
7444
7445 if (!ofs) {
7446 OUTL_DSP (NCB_SCRIPT_PHYS (np, msg_bad));
7447 return;
7448 }
7449 np->msgin [0] = M_NOOP;
7450
7451 break;
7452
7453 case SIR_NEGO_WIDE:
7454 /*
7455 ** Wide request message received.
7456 */
7457 if (DEBUG_FLAGS & DEBUG_NEGO) {
7458 PRINT_ADDR(cp->cmd);
7459 printk ("wide msgin: ");
7460 (void) ncr_show_msg (np->msgin);
7461 printk (".\n");
7462 };
7463
7464 /*
7465 ** get requested values.
7466 */
7467
7468 chg = 0;
7469 wide = np->msgin[3];
7470
7471 /*
7472 ** if target sends WDTR message,
7473 ** it CAN transfer wide.
7474 */
7475
7476 if (wide)
7477 tp->inq_byte7 |= INQ7_WIDE16;
7478
7479 /*
7480 ** check values against driver limits.
7481 */
7482
7483 if (wide > tp->usrwide)
7484 {chg = 1; wide = tp->usrwide;}
7485
7486 if (DEBUG_FLAGS & DEBUG_NEGO) {
7487 PRINT_ADDR(cp->cmd);
7488 printk ("wide: wide=%d chg=%d.\n", wide, chg);
7489 }
7490
7491 if (INB (HS_PRT) == HS_NEGOTIATE) {
7492 OUTB (HS_PRT, HS_BUSY);
7493 switch (cp->nego_status) {
7494
7495 case NS_WIDE:
7496 /*
7497 ** This was an answer message
7498 */
7499 if (chg) {
7500 /*
7501 ** Answer wasn't acceptable.
7502 */
7503 ncr_setwide (np, cp, 0, 1);
7504 OUTL_DSP (NCB_SCRIPT_PHYS (np, msg_bad));
7505 } else {
7506 /*
7507 ** Answer is ok.
7508 */
7509 ncr_setwide (np, cp, wide, 1);
7510 OUTL_DSP (NCB_SCRIPT_PHYS (np, clrack));
7511 };
7512 return;
7513
7514 case NS_SYNC:
7515 ncr_setsync (np, cp, 0, 0xe0);
7516 break;
7517 };
7518 };
7519
7520 /*
7521 ** It was a request, set value and
7522 ** prepare an answer message
7523 */
7524
7525 ncr_setwide (np, cp, wide, 1);
7526
7527 np->msgout[0] = M_EXTENDED;
7528 np->msgout[1] = 2;
7529 np->msgout[2] = M_X_WIDE_REQ;
7530 np->msgout[3] = wide;
7531
7532 np->msgin [0] = M_NOOP;
7533
7534 cp->nego_status = NS_WIDE;
7535
7536 if (DEBUG_FLAGS & DEBUG_NEGO) {
7537 PRINT_ADDR(cp->cmd);
7538 printk ("wide msgout: ");
7539 (void) ncr_show_msg (np->msgin);
7540 printk (".\n");
7541 }
7542 break;
7543
7544 /*--------------------------------------------------------------------
7545 **
7546 ** Processing of special messages
7547 **
7548 **--------------------------------------------------------------------
7549 */
7550
7551 case SIR_REJECT_RECEIVED:
7552 /*-----------------------------------------------
7553 **
7554 ** We received a M_REJECT message.
7555 **
7556 **-----------------------------------------------
7557 */
7558
7559 PRINT_ADDR(cp->cmd);
7560 printk ("M_REJECT received (%x:%x).\n",
7561 (unsigned)scr_to_cpu(np->lastmsg), np->msgout[0]);
7562 break;
7563
7564 case SIR_REJECT_SENT:
7565 /*-----------------------------------------------
7566 **
7567 ** We received an unknown message
7568 **
7569 **-----------------------------------------------
7570 */
7571
7572 PRINT_ADDR(cp->cmd);
7573 printk ("M_REJECT sent for ");
7574 (void) ncr_show_msg (np->msgin);
7575 printk (".\n");
7576 break;
7577
7578 /*--------------------------------------------------------------------
7579 **
7580 ** Processing of special messages
7581 **
7582 **--------------------------------------------------------------------
7583 */
7584
7585 case SIR_IGN_RESIDUE:
7586 /*-----------------------------------------------
7587 **
7588 ** We received an IGNORE RESIDUE message,
7589 ** which couldn't be handled by the script.
7590 **
7591 **-----------------------------------------------
7592 */
7593
7594 PRINT_ADDR(cp->cmd);
7595 printk ("M_IGN_RESIDUE received, but not yet implemented.\n");
7596 break;
7597 #if 0
7598 case SIR_MISSING_SAVE:
7599 /*-----------------------------------------------
7600 **
7601 ** We received an DISCONNECT message,
7602 ** but the datapointer wasn't saved before.
7603 **
7604 **-----------------------------------------------
7605 */
7606
7607 PRINT_ADDR(cp->cmd);
7608 printk ("M_DISCONNECT received, but datapointer not saved: "
7609 "data=%x save=%x goal=%x.\n",
7610 (unsigned) INL (nc_temp),
7611 (unsigned) scr_to_cpu(np->header.savep),
7612 (unsigned) scr_to_cpu(np->header.goalp));
7613 break;
7614 #endif
7615 };
7616
7617 out:
7618 OUTONB_STD ();
7619 }
7620
7621 /*==========================================================
7622 **
7623 **
7624 ** Acquire a control block
7625 **
7626 **
7627 **==========================================================
7628 */
7629
7630 static ccb_p ncr_get_ccb (ncb_p np, u_char tn, u_char ln)
7631 {
7632 tcb_p tp = &np->target[tn];
7633 lcb_p lp = tp->lp[ln];
7634 u_char tag = NO_TAG;
7635 ccb_p cp = (ccb_p) 0;
7636
7637 /*
7638 ** Lun structure available ?
7639 */
7640 if (lp) {
7641 XPT_QUEHEAD *qp;
7642 /*
7643 ** Keep from using more tags than we can handle.
7644 */
7645 if (lp->usetags && lp->busyccbs >= lp->maxnxs)
7646 return (ccb_p) 0;
7647
7648 /*
7649 ** Allocate a new CCB if needed.
7650 */
7651 if (xpt_que_empty(&lp->free_ccbq))
7652 ncr_alloc_ccb(np, tn, ln);
7653
7654 /*
7655 ** Tune tag mode if asked by user.
7656 */
7657 if (lp->queuedepth != lp->numtags) {
7658 ncr_setup_tags(np, tn, ln);
7659 }
7660
7661 /*
7662 ** Look for free CCB
7663 */
7664 qp = xpt_remque_head(&lp->free_ccbq);
7665 if (qp) {
7666 cp = xpt_que_entry(qp, struct ccb, link_ccbq);
7667 if (cp->magic) {
7668 PRINT_LUN(np, tn, ln);
7669 printk ("ccb free list corrupted (@%p)\n", cp);
7670 cp = 0;
7671 }
7672 else {
7673 xpt_insque_tail(qp, &lp->wait_ccbq);
7674 ++lp->busyccbs;
7675 }
7676 }
7677
7678 /*
7679 ** If a CCB is available,
7680 ** Get a tag for this nexus if required.
7681 */
7682 if (cp) {
7683 if (lp->usetags)
7684 tag = lp->cb_tags[lp->ia_tag];
7685 }
7686 else if (lp->actccbs > 0)
7687 return (ccb_p) 0;
7688 }
7689
7690 /*
7691 ** if nothing available, take the default.
7692 */
7693 if (!cp)
7694 cp = np->ccb;
7695
7696 /*
7697 ** Wait until available.
7698 */
7699 #if 0
7700 while (cp->magic) {
7701 if (flags & SCSI_NOSLEEP) break;
7702 if (tsleep ((caddr_t)cp, PRIBIO|PCATCH, "ncr", 0))
7703 break;
7704 };
7705 #endif
7706
7707 if (cp->magic)
7708 return ((ccb_p) 0);
7709
7710 cp->magic = 1;
7711
7712 /*
7713 ** Move to next available tag if tag used.
7714 */
7715 if (lp) {
7716 if (tag != NO_TAG) {
7717 ++lp->ia_tag;
7718 if (lp->ia_tag == MAX_TAGS)
7719 lp->ia_tag = 0;
7720 lp->tags_umap |= (((tagmap_t) 1) << tag);
7721 }
7722 }
7723
7724 /*
7725 ** Remember all informations needed to free this CCB.
7726 */
7727 cp->tag = tag;
7728 cp->target = tn;
7729 cp->lun = ln;
7730
7731 if (DEBUG_FLAGS & DEBUG_TAGS) {
7732 PRINT_LUN(np, tn, ln);
7733 printk ("ccb @%p using tag %d.\n", cp, tag);
7734 }
7735
7736 return cp;
7737 }
7738
7739 /*==========================================================
7740 **
7741 **
7742 ** Release one control block
7743 **
7744 **
7745 **==========================================================
7746 */
7747
7748 static void ncr_free_ccb (ncb_p np, ccb_p cp)
7749 {
7750 tcb_p tp = &np->target[cp->target];
7751 lcb_p lp = tp->lp[cp->lun];
7752
7753 if (DEBUG_FLAGS & DEBUG_TAGS) {
7754 PRINT_LUN(np, cp->target, cp->lun);
7755 printk ("ccb @%p freeing tag %d.\n", cp, cp->tag);
7756 }
7757
7758 /*
7759 ** If lun control block available,
7760 ** decrement active commands and increment credit,
7761 ** free the tag if any and remove the JUMP for reselect.
7762 */
7763 if (lp) {
7764 if (cp->tag != NO_TAG) {
7765 lp->cb_tags[lp->if_tag++] = cp->tag;
7766 if (lp->if_tag == MAX_TAGS)
7767 lp->if_tag = 0;
7768 lp->tags_umap &= ~(((tagmap_t) 1) << cp->tag);
7769 lp->tags_smap &= lp->tags_umap;
7770 lp->jump_ccb[cp->tag] =
7771 cpu_to_scr(NCB_SCRIPTH_PHYS(np, bad_i_t_l_q));
7772 } else {
7773 lp->jump_ccb[0] =
7774 cpu_to_scr(NCB_SCRIPTH_PHYS(np, bad_i_t_l));
7775 }
7776 }
7777
7778 /*
7779 ** Make this CCB available.
7780 */
7781
7782 if (lp) {
7783 if (cp != np->ccb) {
7784 xpt_remque(&cp->link_ccbq);
7785 xpt_insque_head(&cp->link_ccbq, &lp->free_ccbq);
7786 }
7787 --lp->busyccbs;
7788 if (cp->queued) {
7789 --lp->queuedccbs;
7790 }
7791 }
7792 cp -> host_status = HS_IDLE;
7793 cp -> magic = 0;
7794 if (cp->queued) {
7795 --np->queuedccbs;
7796 cp->queued = 0;
7797 }
7798
7799 #if 0
7800 if (cp == np->ccb)
7801 wakeup ((caddr_t) cp);
7802 #endif
7803 }
7804
7805
7806 #define ncr_reg_bus_addr(r) (np->paddr + offsetof (struct ncr_reg, r))
7807
7808 /*------------------------------------------------------------------------
7809 ** Initialize the fixed part of a CCB structure.
7810 **------------------------------------------------------------------------
7811 **------------------------------------------------------------------------
7812 */
7813 static void ncr_init_ccb(ncb_p np, ccb_p cp)
7814 {
7815 ncrcmd copy_4 = np->features & FE_PFEN ? SCR_COPY(4) : SCR_COPY_F(4);
7816
7817 /*
7818 ** Remember virtual and bus address of this ccb.
7819 */
7820 cp->p_ccb = vtobus(cp);
7821 cp->phys.header.cp = cp;
7822
7823 /*
7824 ** This allows xpt_remque to work for the default ccb.
7825 */
7826 xpt_que_init(&cp->link_ccbq);
7827
7828 /*
7829 ** Initialyze the start and restart launch script.
7830 **
7831 ** COPY(4) @(...p_phys), @(dsa)
7832 ** JUMP @(sched_point)
7833 */
7834 cp->start.setup_dsa[0] = cpu_to_scr(copy_4);
7835 cp->start.setup_dsa[1] = cpu_to_scr(CCB_PHYS(cp, start.p_phys));
7836 cp->start.setup_dsa[2] = cpu_to_scr(ncr_reg_bus_addr(nc_dsa));
7837 cp->start.schedule.l_cmd = cpu_to_scr(SCR_JUMP);
7838 cp->start.p_phys = cpu_to_scr(CCB_PHYS(cp, phys));
7839
7840 bcopy(&cp->start, &cp->restart, sizeof(cp->restart));
7841
7842 cp->start.schedule.l_paddr = cpu_to_scr(NCB_SCRIPT_PHYS (np, idle));
7843 cp->restart.schedule.l_paddr = cpu_to_scr(NCB_SCRIPTH_PHYS (np, abort));
7844 }
7845
7846
7847 /*------------------------------------------------------------------------
7848 ** Allocate a CCB and initialize its fixed part.
7849 **------------------------------------------------------------------------
7850 **------------------------------------------------------------------------
7851 */
7852 static void ncr_alloc_ccb(ncb_p np, u_char tn, u_char ln)
7853 {
7854 tcb_p tp = &np->target[tn];
7855 lcb_p lp = tp->lp[ln];
7856 ccb_p cp = 0;
7857
7858 /*
7859 ** Allocate memory for this CCB.
7860 */
7861 cp = m_calloc_dma(sizeof(struct ccb), "CCB");
7862 if (!cp)
7863 return;
7864
7865 /*
7866 ** Count it and initialyze it.
7867 */
7868 lp->actccbs++;
7869 np->actccbs++;
7870 bzero (cp, sizeof (*cp));
7871 ncr_init_ccb(np, cp);
7872
7873 /*
7874 ** Chain into wakeup list and free ccb queue and take it
7875 ** into account for tagged commands.
7876 */
7877 cp->link_ccb = np->ccb->link_ccb;
7878 np->ccb->link_ccb = cp;
7879
7880 xpt_insque_head(&cp->link_ccbq, &lp->free_ccbq);
7881 ncr_setup_tags (np, tn, ln);
7882 }
7883
7884 /*==========================================================
7885 **
7886 **
7887 ** Allocation of resources for Targets/Luns/Tags.
7888 **
7889 **
7890 **==========================================================
7891 */
7892
7893
7894 /*------------------------------------------------------------------------
7895 ** Target control block initialisation.
7896 **------------------------------------------------------------------------
7897 ** This data structure is fully initialized after a SCSI command
7898 ** has been successfully completed for this target.
7899 ** It contains a SCRIPT that is called on target reselection.
7900 **------------------------------------------------------------------------
7901 */
7902 static void ncr_init_tcb (ncb_p np, u_char tn)
7903 {
7904 tcb_p tp = &np->target[tn];
7905 ncrcmd copy_1 = np->features & FE_PFEN ? SCR_COPY(1) : SCR_COPY_F(1);
7906 int th = tn & 3;
7907 int i;
7908
7909 /*
7910 ** Jump to next tcb if SFBR does not match this target.
7911 ** JUMP IF (SFBR != #target#), @(next tcb)
7912 */
7913 tp->jump_tcb.l_cmd =
7914 cpu_to_scr((SCR_JUMP ^ IFFALSE (DATA (0x80 + tn))));
7915 tp->jump_tcb.l_paddr = np->jump_tcb[th].l_paddr;
7916
7917 /*
7918 ** Load the synchronous transfer register.
7919 ** COPY @(tp->sval), @(sxfer)
7920 */
7921 tp->getscr[0] = cpu_to_scr(copy_1);
7922 tp->getscr[1] = cpu_to_scr(vtobus (&tp->sval));
7923 #ifdef SCSI_NCR_BIG_ENDIAN
7924 tp->getscr[2] = cpu_to_scr(ncr_reg_bus_addr(nc_sxfer) ^ 3);
7925 #else
7926 tp->getscr[2] = cpu_to_scr(ncr_reg_bus_addr(nc_sxfer));
7927 #endif
7928
7929 /*
7930 ** Load the timing register.
7931 ** COPY @(tp->wval), @(scntl3)
7932 */
7933 tp->getscr[3] = cpu_to_scr(copy_1);
7934 tp->getscr[4] = cpu_to_scr(vtobus (&tp->wval));
7935 #ifdef SCSI_NCR_BIG_ENDIAN
7936 tp->getscr[5] = cpu_to_scr(ncr_reg_bus_addr(nc_scntl3) ^ 3);
7937 #else
7938 tp->getscr[5] = cpu_to_scr(ncr_reg_bus_addr(nc_scntl3));
7939 #endif
7940
7941 /*
7942 ** Get the IDENTIFY message and the lun.
7943 ** CALL @script(resel_lun)
7944 */
7945 tp->call_lun.l_cmd = cpu_to_scr(SCR_CALL);
7946 tp->call_lun.l_paddr = cpu_to_scr(NCB_SCRIPT_PHYS (np, resel_lun));
7947
7948 /*
7949 ** Look for the lun control block of this nexus.
7950 ** For i = 0 to 3
7951 ** JUMP ^ IFTRUE (MASK (i, 3)), @(next_lcb)
7952 */
7953 for (i = 0 ; i < 4 ; i++) {
7954 tp->jump_lcb[i].l_cmd =
7955 cpu_to_scr((SCR_JUMP ^ IFTRUE (MASK (i, 3))));
7956 tp->jump_lcb[i].l_paddr =
7957 cpu_to_scr(NCB_SCRIPTH_PHYS (np, bad_identify));
7958 }
7959
7960 /*
7961 ** Link this target control block to the JUMP chain.
7962 */
7963 np->jump_tcb[th].l_paddr = cpu_to_scr(vtobus (&tp->jump_tcb));
7964
7965 /*
7966 ** These assert's should be moved at driver initialisations.
7967 */
7968 #ifdef SCSI_NCR_BIG_ENDIAN
7969 assert (( (offsetof(struct ncr_reg, nc_sxfer) ^
7970 offsetof(struct tcb , sval )) &3) == 3);
7971 assert (( (offsetof(struct ncr_reg, nc_scntl3) ^
7972 offsetof(struct tcb , wval )) &3) == 3);
7973 #else
7974 assert (( (offsetof(struct ncr_reg, nc_sxfer) ^
7975 offsetof(struct tcb , sval )) &3) == 0);
7976 assert (( (offsetof(struct ncr_reg, nc_scntl3) ^
7977 offsetof(struct tcb , wval )) &3) == 0);
7978 #endif
7979 }
7980
7981
7982 /*------------------------------------------------------------------------
7983 ** Lun control block allocation and initialization.
7984 **------------------------------------------------------------------------
7985 ** This data structure is allocated and initialized after a SCSI
7986 ** command has been successfully completed for this target/lun.
7987 **------------------------------------------------------------------------
7988 */
7989 static lcb_p ncr_alloc_lcb (ncb_p np, u_char tn, u_char ln)
7990 {
7991 tcb_p tp = &np->target[tn];
7992 lcb_p lp = tp->lp[ln];
7993 ncrcmd copy_4 = np->features & FE_PFEN ? SCR_COPY(4) : SCR_COPY_F(4);
7994 int lh = ln & 3;
7995
7996 /*
7997 ** Already done, return.
7998 */
7999 if (lp)
8000 return lp;
8001
8002 /*
8003 ** Allocate the lcb.
8004 */
8005 lp = m_calloc_dma(sizeof(struct lcb), "LCB");
8006 if (!lp)
8007 goto fail;
8008 bzero(lp, sizeof(*lp));
8009 tp->lp[ln] = lp;
8010
8011 /*
8012 ** Initialize the target control block if not yet.
8013 */
8014 if (!tp->jump_tcb.l_cmd)
8015 ncr_init_tcb(np, tn);
8016
8017 /*
8018 ** Initialize the CCB queue headers.
8019 */
8020 xpt_que_init(&lp->free_ccbq);
8021 xpt_que_init(&lp->busy_ccbq);
8022 xpt_que_init(&lp->wait_ccbq);
8023 xpt_que_init(&lp->skip_ccbq);
8024
8025 /*
8026 ** Set max CCBs to 1 and use the default 1 entry
8027 ** jump table by default.
8028 */
8029 lp->maxnxs = 1;
8030 lp->jump_ccb = &lp->jump_ccb_0;
8031 lp->p_jump_ccb = cpu_to_scr(vtobus(lp->jump_ccb));
8032
8033 /*
8034 ** Initilialyze the reselect script:
8035 **
8036 ** Jump to next lcb if SFBR does not match this lun.
8037 ** Load TEMP with the CCB direct jump table bus address.
8038 ** Get the SIMPLE TAG message and the tag.
8039 **
8040 ** JUMP IF (SFBR != #lun#), @(next lcb)
8041 ** COPY @(lp->p_jump_ccb), @(temp)
8042 ** JUMP @script(resel_notag)
8043 */
8044 lp->jump_lcb.l_cmd =
8045 cpu_to_scr((SCR_JUMP ^ IFFALSE (MASK (0x80+ln, 0xff))));
8046 lp->jump_lcb.l_paddr = tp->jump_lcb[lh].l_paddr;
8047
8048 lp->load_jump_ccb[0] = cpu_to_scr(copy_4);
8049 lp->load_jump_ccb[1] = cpu_to_scr(vtobus (&lp->p_jump_ccb));
8050 lp->load_jump_ccb[2] = cpu_to_scr(ncr_reg_bus_addr(nc_temp));
8051
8052 lp->jump_tag.l_cmd = cpu_to_scr(SCR_JUMP);
8053 lp->jump_tag.l_paddr = cpu_to_scr(NCB_SCRIPT_PHYS (np, resel_notag));
8054
8055 /*
8056 ** Link this lun control block to the JUMP chain.
8057 */
8058 tp->jump_lcb[lh].l_paddr = cpu_to_scr(vtobus (&lp->jump_lcb));
8059
8060 /*
8061 ** Initialize command queuing control.
8062 */
8063 lp->busyccbs = 1;
8064 lp->queuedccbs = 1;
8065 lp->queuedepth = 1;
8066 fail:
8067 return lp;
8068 }
8069
8070
8071 /*------------------------------------------------------------------------
8072 ** Lun control block setup on INQUIRY data received.
8073 **------------------------------------------------------------------------
8074 ** We only support WIDE, SYNC for targets and CMDQ for logical units.
8075 ** This setup is done on each INQUIRY since we are expecting user
8076 ** will play with CHANGE DEFINITION commands. :-)
8077 **------------------------------------------------------------------------
8078 */
8079 static lcb_p ncr_setup_lcb (ncb_p np, u_char tn, u_char ln, u_char *inq_data)
8080 {
8081 tcb_p tp = &np->target[tn];
8082 lcb_p lp = tp->lp[ln];
8083 u_char inq_byte7;
8084
8085 /*
8086 ** If no lcb, try to allocate it.
8087 */
8088 if (!lp && !(lp = ncr_alloc_lcb(np, tn, ln)))
8089 goto fail;
8090
8091 /*
8092 ** Get device quirks from a speciality table.
8093 */
8094 tp->quirks = ncr_lookup (inq_data);
8095 if (tp->quirks && bootverbose) {
8096 PRINT_LUN(np, tn, ln);
8097 printk ("quirks=%x.\n", tp->quirks);
8098 }
8099
8100 /*
8101 ** Evaluate trustable target/unit capabilities.
8102 ** We only believe device version >= SCSI-2 that
8103 ** use appropriate response data format (2).
8104 ** But it seems that some CCS devices also
8105 ** support SYNC and I donnot want to frustrate
8106 ** anybody. ;-)
8107 */
8108 inq_byte7 = 0;
8109 if ((inq_data[2] & 0x7) >= 2 && (inq_data[3] & 0xf) == 2)
8110 inq_byte7 = inq_data[7];
8111 else if ((inq_data[2] & 0x7) == 1 && (inq_data[3] & 0xf) == 1)
8112 inq_byte7 = INQ7_SYNC;
8113
8114 /*
8115 ** Throw away announced LUN capabilities if we are told
8116 ** that there is no real device supported by the logical unit.
8117 */
8118 if ((inq_data[0] & 0xe0) > 0x20 || (inq_data[0] & 0x1f) == 0x1f)
8119 inq_byte7 &= (INQ7_SYNC | INQ7_WIDE16);
8120
8121 /*
8122 ** If user is wanting SYNC, force this feature.
8123 */
8124 if (driver_setup.force_sync_nego)
8125 inq_byte7 |= INQ7_SYNC;
8126
8127 /*
8128 ** Prepare negotiation if SIP capabilities have changed.
8129 */
8130 tp->inq_done = 1;
8131 if ((inq_byte7 ^ tp->inq_byte7) & (INQ7_SYNC | INQ7_WIDE16)) {
8132 tp->inq_byte7 = inq_byte7;
8133 ncr_negotiate(np, tp);
8134 }
8135
8136 /*
8137 ** If unit supports tagged commands, allocate the
8138 ** CCB JUMP table if not yet.
8139 */
8140 if ((inq_byte7 & INQ7_QUEUE) && lp->jump_ccb == &lp->jump_ccb_0) {
8141 int i;
8142 lp->jump_ccb = m_calloc_dma(256, "JUMP_CCB");
8143 if (!lp->jump_ccb) {
8144 lp->jump_ccb = &lp->jump_ccb_0;
8145 goto fail;
8146 }
8147 lp->p_jump_ccb = cpu_to_scr(vtobus(lp->jump_ccb));
8148 for (i = 0 ; i < 64 ; i++)
8149 lp->jump_ccb[i] =
8150 cpu_to_scr(NCB_SCRIPTH_PHYS (np, bad_i_t_l_q));
8151 for (i = 0 ; i < MAX_TAGS ; i++)
8152 lp->cb_tags[i] = i;
8153 lp->maxnxs = MAX_TAGS;
8154 lp->tags_stime = ktime_get(3*HZ);
8155 }
8156
8157 /*
8158 ** Adjust tagged queueing status if needed.
8159 */
8160 if ((inq_byte7 ^ lp->inq_byte7) & INQ7_QUEUE) {
8161 lp->inq_byte7 = inq_byte7;
8162 lp->numtags = lp->maxtags;
8163 ncr_setup_tags (np, tn, ln);
8164 }
8165
8166 fail:
8167 return lp;
8168 }
8169
8170 /*==========================================================
8171 **
8172 **
8173 ** Build Scatter Gather Block
8174 **
8175 **
8176 **==========================================================
8177 **
8178 ** The transfer area may be scattered among
8179 ** several non adjacent physical pages.
8180 **
8181 ** We may use MAX_SCATTER blocks.
8182 **
8183 **----------------------------------------------------------
8184 */
8185
8186 /*
8187 ** We try to reduce the number of interrupts caused
8188 ** by unexpected phase changes due to disconnects.
8189 ** A typical harddisk may disconnect before ANY block.
8190 ** If we wanted to avoid unexpected phase changes at all
8191 ** we had to use a break point every 512 bytes.
8192 ** Of course the number of scatter/gather blocks is
8193 ** limited.
8194 ** Under Linux, the scatter/gatter blocks are provided by
8195 ** the generic driver. We just have to copy addresses and
8196 ** sizes to the data segment array.
8197 */
8198
8199 static int ncr_scatter(ncb_p np, ccb_p cp, Scsi_Cmnd *cmd)
8200 {
8201 struct scr_tblmove *data;
8202 int segment = 0;
8203 int use_sg = (int) cmd->use_sg;
8204
8205 data = cp->phys.data;
8206 cp->data_len = 0;
8207
8208 if (!use_sg) {
8209 if (cmd->request_bufflen) {
8210 u_long baddr = map_scsi_single_data(np, cmd);
8211
8212 data = &data[MAX_SCATTER - 1];
8213 data[0].addr = cpu_to_scr(baddr);
8214 data[0].size = cpu_to_scr(cmd->request_bufflen);
8215 cp->data_len = cmd->request_bufflen;
8216 segment = 1;
8217 }
8218 }
8219 else if (use_sg <= MAX_SCATTER) {
8220 struct scatterlist *scatter = (struct scatterlist *)cmd->buffer;
8221
8222 use_sg = map_scsi_sg_data(np, cmd);
8223 data = &data[MAX_SCATTER - use_sg];
8224
8225 while (segment < use_sg) {
8226 u_long baddr = scsi_sg_dma_address(&scatter[segment]);
8227 unsigned int len = scsi_sg_dma_len(&scatter[segment]);
8228
8229 data[segment].addr = cpu_to_scr(baddr);
8230 data[segment].size = cpu_to_scr(len);
8231 cp->data_len += len;
8232 ++segment;
8233 }
8234 }
8235 else {
8236 return -1;
8237 }
8238
8239 return segment;
8240 }
8241
8242 /*==========================================================
8243 **
8244 **
8245 ** Test the pci bus snoop logic :-(
8246 **
8247 ** Has to be called with interrupts disabled.
8248 **
8249 **
8250 **==========================================================
8251 */
8252
8253 #ifndef SCSI_NCR_IOMAPPED
8254 static int __init ncr_regtest (struct ncb* np)
8255 {
8256 register volatile u_int32 data;
8257 /*
8258 ** ncr registers may NOT be cached.
8259 ** write 0xffffffff to a read only register area,
8260 ** and try to read it back.
8261 */
8262 data = 0xffffffff;
8263 OUTL_OFF(offsetof(struct ncr_reg, nc_dstat), data);
8264 data = INL_OFF(offsetof(struct ncr_reg, nc_dstat));
8265 #if 1
8266 if (data == 0xffffffff) {
8267 #else
8268 if ((data & 0xe2f0fffd) != 0x02000080) {
8269 #endif
8270 printk ("CACHE TEST FAILED: reg dstat-sstat2 readback %x.\n",
8271 (unsigned) data);
8272 return (0x10);
8273 };
8274 return (0);
8275 }
8276 #endif
8277
8278 static int __init ncr_snooptest (struct ncb* np)
8279 {
8280 u_int32 ncr_rd, ncr_wr, ncr_bk, host_rd, host_wr, pc;
8281 int i, err=0;
8282 #ifndef SCSI_NCR_IOMAPPED
8283 if (np->reg) {
8284 err |= ncr_regtest (np);
8285 if (err) return (err);
8286 }
8287 #endif
8288 /*
8289 ** init
8290 */
8291 pc = NCB_SCRIPTH_PHYS (np, snooptest);
8292 host_wr = 1;
8293 ncr_wr = 2;
8294 /*
8295 ** Set memory and register.
8296 */
8297 np->ncr_cache = cpu_to_scr(host_wr);
8298 OUTL (nc_temp, ncr_wr);
8299 /*
8300 ** Start script (exchange values)
8301 */
8302 OUTL_DSP (pc);
8303 /*
8304 ** Wait 'til done (with timeout)
8305 */
8306 for (i=0; i<NCR_SNOOP_TIMEOUT; i++)
8307 if (INB(nc_istat) & (INTF|SIP|DIP))
8308 break;
8309 /*
8310 ** Save termination position.
8311 */
8312 pc = INL (nc_dsp);
8313 /*
8314 ** Read memory and register.
8315 */
8316 host_rd = scr_to_cpu(np->ncr_cache);
8317 ncr_rd = INL (nc_scratcha);
8318 ncr_bk = INL (nc_temp);
8319 /*
8320 ** Reset ncr chip
8321 */
8322 ncr_chip_reset(np, 100);
8323 /*
8324 ** check for timeout
8325 */
8326 if (i>=NCR_SNOOP_TIMEOUT) {
8327 printk ("CACHE TEST FAILED: timeout.\n");
8328 return (0x20);
8329 };
8330 /*
8331 ** Check termination position.
8332 */
8333 if (pc != NCB_SCRIPTH_PHYS (np, snoopend)+8) {
8334 printk ("CACHE TEST FAILED: script execution failed.\n");
8335 printk ("start=%08lx, pc=%08lx, end=%08lx\n",
8336 (u_long) NCB_SCRIPTH_PHYS (np, snooptest), (u_long) pc,
8337 (u_long) NCB_SCRIPTH_PHYS (np, snoopend) +8);
8338 return (0x40);
8339 };
8340 /*
8341 ** Show results.
8342 */
8343 if (host_wr != ncr_rd) {
8344 printk ("CACHE TEST FAILED: host wrote %d, ncr read %d.\n",
8345 (int) host_wr, (int) ncr_rd);
8346 err |= 1;
8347 };
8348 if (host_rd != ncr_wr) {
8349 printk ("CACHE TEST FAILED: ncr wrote %d, host read %d.\n",
8350 (int) ncr_wr, (int) host_rd);
8351 err |= 2;
8352 };
8353 if (ncr_bk != ncr_wr) {
8354 printk ("CACHE TEST FAILED: ncr wrote %d, read back %d.\n",
8355 (int) ncr_wr, (int) ncr_bk);
8356 err |= 4;
8357 };
8358 return (err);
8359 }
8360
8361 /*==========================================================
8362 **
8363 **
8364 ** Device lookup.
8365 **
8366 ** @GENSCSI@ should be integrated to scsiconf.c
8367 **
8368 **
8369 **==========================================================
8370 */
8371
8372 struct table_entry {
8373 char * manufacturer;
8374 char * model;
8375 char * version;
8376 u_long info;
8377 };
8378
8379 static struct table_entry device_tab[] =
8380 {
8381 #if 0
8382 {"", "", "", QUIRK_NOMSG},
8383 #endif
8384 {"SONY", "SDT-5000", "3.17", QUIRK_NOMSG},
8385 {"WangDAT", "Model 2600", "01.7", QUIRK_NOMSG},
8386 {"WangDAT", "Model 3200", "02.2", QUIRK_NOMSG},
8387 {"WangDAT", "Model 1300", "02.4", QUIRK_NOMSG},
8388 {"", "", "", 0} /* catch all: must be last entry. */
8389 };
8390
8391 static u_long ncr_lookup(char * id)
8392 {
8393 struct table_entry * p = device_tab;
8394 char *d, *r, c;
8395
8396 for (;;p++) {
8397
8398 d = id+8;
8399 r = p->manufacturer;
8400 while ((c=*r++)) if (c!=*d++) break;
8401 if (c) continue;
8402
8403 d = id+16;
8404 r = p->model;
8405 while ((c=*r++)) if (c!=*d++) break;
8406 if (c) continue;
8407
8408 d = id+32;
8409 r = p->version;
8410 while ((c=*r++)) if (c!=*d++) break;
8411 if (c) continue;
8412
8413 return (p->info);
8414 }
8415 }
8416
8417 /*==========================================================
8418 **
8419 ** Determine the ncr's clock frequency.
8420 ** This is essential for the negotiation
8421 ** of the synchronous transfer rate.
8422 **
8423 **==========================================================
8424 **
8425 ** Note: we have to return the correct value.
8426 ** THERE IS NO SAVE DEFAULT VALUE.
8427 **
8428 ** Most NCR/SYMBIOS boards are delivered with a 40 Mhz clock.
8429 ** 53C860 and 53C875 rev. 1 support fast20 transfers but
8430 ** do not have a clock doubler and so are provided with a
8431 ** 80 MHz clock. All other fast20 boards incorporate a doubler
8432 ** and so should be delivered with a 40 MHz clock.
8433 ** The future fast40 chips (895/895) use a 40 Mhz base clock
8434 ** and provide a clock quadrupler (160 Mhz). The code below
8435 ** tries to deal as cleverly as possible with all this stuff.
8436 **
8437 **----------------------------------------------------------
8438 */
8439
8440 /*
8441 * Select NCR SCSI clock frequency
8442 */
8443 static void ncr_selectclock(ncb_p np, u_char scntl3)
8444 {
8445 if (np->multiplier < 2) {
8446 OUTB(nc_scntl3, scntl3);
8447 return;
8448 }
8449
8450 if (bootverbose >= 2)
8451 printk ("%s: enabling clock multiplier\n", ncr_name(np));
8452
8453 OUTB(nc_stest1, DBLEN); /* Enable clock multiplier */
8454 if (np->multiplier > 2) { /* Poll bit 5 of stest4 for quadrupler */
8455 int i = 20;
8456 while (!(INB(nc_stest4) & LCKFRQ) && --i > 0)
8457 UDELAY (20);
8458 if (!i)
8459 printk("%s: the chip cannot lock the frequency\n", ncr_name(np));
8460 } else /* Wait 20 micro-seconds for doubler */
8461 UDELAY (20);
8462 OUTB(nc_stest3, HSC); /* Halt the scsi clock */
8463 OUTB(nc_scntl3, scntl3);
8464 OUTB(nc_stest1, (DBLEN|DBLSEL));/* Select clock multiplier */
8465 OUTB(nc_stest3, 0x00); /* Restart scsi clock */
8466 }
8467
8468
8469 /*
8470 * calculate NCR SCSI clock frequency (in KHz)
8471 */
8472 static unsigned __init ncrgetfreq (ncb_p np, int gen)
8473 {
8474 unsigned ms = 0;
8475 char count = 0;
8476
8477 /*
8478 * Measure GEN timer delay in order
8479 * to calculate SCSI clock frequency
8480 *
8481 * This code will never execute too
8482 * many loop iterations (if DELAY is
8483 * reasonably correct). It could get
8484 * too low a delay (too high a freq.)
8485 * if the CPU is slow executing the
8486 * loop for some reason (an NMI, for
8487 * example). For this reason we will
8488 * if multiple measurements are to be
8489 * performed trust the higher delay
8490 * (lower frequency returned).
8491 */
8492 OUTB (nc_stest1, 0); /* make sure clock doubler is OFF */
8493 OUTW (nc_sien , 0); /* mask all scsi interrupts */
8494 (void) INW (nc_sist); /* clear pending scsi interrupt */
8495 OUTB (nc_dien , 0); /* mask all dma interrupts */
8496 (void) INW (nc_sist); /* another one, just to be sure :) */
8497 OUTB (nc_scntl3, 4); /* set pre-scaler to divide by 3 */
8498 OUTB (nc_stime1, 0); /* disable general purpose timer */
8499 OUTB (nc_stime1, gen); /* set to nominal delay of 1<<gen * 125us */
8500 while (!(INW(nc_sist) & GEN) && ms++ < 100000) {
8501 for (count = 0; count < 10; count ++)
8502 UDELAY (100); /* count ms */
8503 }
8504 OUTB (nc_stime1, 0); /* disable general purpose timer */
8505 /*
8506 * set prescaler to divide by whatever 0 means
8507 * 0 ought to choose divide by 2, but appears
8508 * to set divide by 3.5 mode in my 53c810 ...
8509 */
8510 OUTB (nc_scntl3, 0);
8511
8512 if (bootverbose >= 2)
8513 printk ("%s: Delay (GEN=%d): %u msec\n", ncr_name(np), gen, ms);
8514 /*
8515 * adjust for prescaler, and convert into KHz
8516 */
8517 return ms ? ((1 << gen) * 4340) / ms : 0;
8518 }
8519
8520 /*
8521 * Get/probe NCR SCSI clock frequency
8522 */
8523 static void __init ncr_getclock (ncb_p np, int mult)
8524 {
8525 unsigned char scntl3 = INB(nc_scntl3);
8526 unsigned char stest1 = INB(nc_stest1);
8527 unsigned f1;
8528
8529 np->multiplier = 1;
8530 f1 = 40000;
8531
8532 /*
8533 ** True with 875 or 895 with clock multiplier selected
8534 */
8535 if (mult > 1 && (stest1 & (DBLEN+DBLSEL)) == DBLEN+DBLSEL) {
8536 if (bootverbose >= 2)
8537 printk ("%s: clock multiplier found\n", ncr_name(np));
8538 np->multiplier = mult;
8539 }
8540
8541 /*
8542 ** If multiplier not found or scntl3 not 7,5,3,
8543 ** reset chip and get frequency from general purpose timer.
8544 ** Otherwise trust scntl3 BIOS setting.
8545 */
8546 if (np->multiplier != mult || (scntl3 & 7) < 3 || !(scntl3 & 1)) {
8547 unsigned f2;
8548
8549 ncr_chip_reset(np, 5);
8550
8551 (void) ncrgetfreq (np, 11); /* throw away first result */
8552 f1 = ncrgetfreq (np, 11);
8553 f2 = ncrgetfreq (np, 11);
8554
8555 if(bootverbose)
8556 printk ("%s: NCR clock is %uKHz, %uKHz\n", ncr_name(np), f1, f2);
8557
8558 if (f1 > f2) f1 = f2; /* trust lower result */
8559
8560 if (f1 < 45000) f1 = 40000;
8561 else if (f1 < 55000) f1 = 50000;
8562 else f1 = 80000;
8563
8564 if (f1 < 80000 && mult > 1) {
8565 if (bootverbose >= 2)
8566 printk ("%s: clock multiplier assumed\n", ncr_name(np));
8567 np->multiplier = mult;
8568 }
8569 } else {
8570 if ((scntl3 & 7) == 3) f1 = 40000;
8571 else if ((scntl3 & 7) == 5) f1 = 80000;
8572 else f1 = 160000;
8573
8574 f1 /= np->multiplier;
8575 }
8576
8577 /*
8578 ** Compute controller synchronous parameters.
8579 */
8580 f1 *= np->multiplier;
8581 np->clock_khz = f1;
8582 }
8583
8584 /*===================== LINUX ENTRY POINTS SECTION ==========================*/
8585
8586 /*
8587 ** Linux select queue depths function
8588 */
8589
8590 int ncr53c8xx_slave_configure(Scsi_Device *device)
8591 {
8592 struct Scsi_Host *host = device->host;
8593 ncb_p np;
8594 tcb_p tp;
8595 lcb_p lp;
8596 int numtags, depth_to_use;
8597
8598 np = ((struct host_data *) host->hostdata)->ncb;
8599 tp = &np->target[device->id];
8600 lp = tp->lp[device->lun];
8601
8602 /*
8603 ** Select queue depth from driver setup.
8604 ** Donnot use more than configured by user.
8605 ** Use at least 2.
8606 ** Donnot use more than our maximum.
8607 */
8608 numtags = device_queue_depth(np->unit, device->id, device->lun);
8609 if (numtags > tp->usrtags)
8610 numtags = tp->usrtags;
8611 if (!device->tagged_supported)
8612 numtags = 1;
8613 depth_to_use = numtags;
8614 if (depth_to_use < 2)
8615 depth_to_use = 2;
8616 if (depth_to_use > MAX_TAGS)
8617 depth_to_use = MAX_TAGS;
8618
8619 scsi_adjust_queue_depth(device,
8620 (device->tagged_supported ?
8621 MSG_SIMPLE_TAG : 0),
8622 depth_to_use);
8623
8624 /*
8625 ** Since the queue depth is not tunable under Linux,
8626 ** we need to know this value in order not to
8627 ** announce stupid things to user.
8628 */
8629 if (lp) {
8630 lp->numtags = lp->maxtags = numtags;
8631 lp->scdev_depth = depth_to_use;
8632 }
8633 ncr_setup_tags (np, device->id, device->lun);
8634
8635 #ifdef DEBUG_NCR53C8XX
8636 printk("ncr53c8xx_select_queue_depth: host=%d, id=%d, lun=%d, depth=%d\n",
8637 np->unit, device->id, device->lun, depth_to_use);
8638 #endif
8639
8640 return 0;
8641 }
8642
8643 /*
8644 ** Linux entry point of queuecommand() function
8645 */
8646
8647 int ncr53c8xx_queue_command (Scsi_Cmnd *cmd, void (* done)(Scsi_Cmnd *))
8648 {
8649 ncb_p np = ((struct host_data *) cmd->device->host->hostdata)->ncb;
8650 unsigned long flags;
8651 int sts;
8652
8653 #ifdef DEBUG_NCR53C8XX
8654 printk("ncr53c8xx_queue_command\n");
8655 #endif
8656
8657 cmd->scsi_done = done;
8658 cmd->host_scribble = NULL;
8659 #ifdef SCSI_NCR_DYNAMIC_DMA_MAPPING
8660 cmd->__data_mapped = 0;
8661 cmd->__data_mapping = 0;
8662 #endif
8663
8664 NCR_LOCK_NCB(np, flags);
8665
8666 if ((sts = ncr_queue_command(np, cmd)) != DID_OK) {
8667 cmd->result = ScsiResult(sts, 0);
8668 #ifdef DEBUG_NCR53C8XX
8669 printk("ncr53c8xx : command not queued - result=%d\n", sts);
8670 #endif
8671 }
8672 #ifdef DEBUG_NCR53C8XX
8673 else
8674 printk("ncr53c8xx : command successfully queued\n");
8675 #endif
8676
8677 NCR_UNLOCK_NCB(np, flags);
8678
8679 if (sts != DID_OK) {
8680 unmap_scsi_data(np, cmd);
8681 done(cmd);
8682 }
8683
8684 return sts;
8685 }
8686
8687 /*
8688 ** Linux entry point of the interrupt handler.
8689 ** Since linux versions > 1.3.70, we trust the kernel for
8690 ** passing the internal host descriptor as 'dev_id'.
8691 ** Otherwise, we scan the host list and call the interrupt
8692 ** routine for each host that uses this IRQ.
8693 */
8694
8695 irqreturn_t ncr53c8xx_intr(int irq, void *dev_id, struct pt_regs * regs)
8696 {
8697 unsigned long flags;
8698 struct Scsi_Host *shost = (struct Scsi_Host *)dev_id;
8699 struct host_data *host_data = (struct host_data *)shost->hostdata;
8700 ncb_p np = host_data->ncb;
8701 Scsi_Cmnd *done_list;
8702
8703 #ifdef DEBUG_NCR53C8XX
8704 printk("ncr53c8xx : interrupt received\n");
8705 #endif
8706
8707 if (DEBUG_FLAGS & DEBUG_TINY) printk ("[");
8708
8709 NCR_LOCK_NCB(np, flags);
8710 ncr_exception(np);
8711 done_list = np->done_list;
8712 np->done_list = 0;
8713 NCR_UNLOCK_NCB(np, flags);
8714
8715 if (DEBUG_FLAGS & DEBUG_TINY) printk ("]\n");
8716
8717 if (done_list) {
8718 NCR_LOCK_SCSI_DONE(done_list->device->host, flags);
8719 ncr_flush_done_cmds(done_list);
8720 NCR_UNLOCK_SCSI_DONE(done_list->device->host, flags);
8721 }
8722 return IRQ_HANDLED;
8723 }
8724
8725 /*
8726 ** Linux entry point of the timer handler
8727 */
8728
8729 static void ncr53c8xx_timeout(unsigned long npref)
8730 {
8731 ncb_p np = (ncb_p) npref;
8732 unsigned long flags;
8733 Scsi_Cmnd *done_list;
8734
8735 NCR_LOCK_NCB(np, flags);
8736 ncr_timeout((ncb_p) np);
8737 done_list = np->done_list;
8738 np->done_list = 0;
8739 NCR_UNLOCK_NCB(np, flags);
8740
8741 if (done_list) {
8742 NCR_LOCK_SCSI_DONE(done_list->device->host, flags);
8743 ncr_flush_done_cmds(done_list);
8744 NCR_UNLOCK_SCSI_DONE(done_list->device->host, flags);
8745 }
8746 }
8747
8748 /*
8749 ** Linux entry point of reset() function
8750 */
8751
8752 int ncr53c8xx_bus_reset(Scsi_Cmnd *cmd)
8753 {
8754 ncb_p np = ((struct host_data *) cmd->device->host->hostdata)->ncb;
8755 int sts;
8756 unsigned long flags;
8757 Scsi_Cmnd *done_list;
8758
8759 NCR_LOCK_NCB(np, flags);
8760
8761 /*
8762 * If the mid-level driver told us reset is synchronous, it seems
8763 * that we must call the done() callback for the involved command,
8764 * even if this command was not queued to the low-level driver,
8765 * before returning SUCCESS.
8766 */
8767
8768 sts = ncr_reset_bus(np, cmd, 1);
8769
8770 done_list = np->done_list;
8771 np->done_list = 0;
8772 NCR_UNLOCK_NCB(np, flags);
8773
8774 ncr_flush_done_cmds(done_list);
8775
8776 return sts;
8777 }
8778
8779 /*
8780 ** Linux entry point of abort() function
8781 */
8782
8783 int ncr53c8xx_abort(Scsi_Cmnd *cmd)
8784 {
8785 ncb_p np = ((struct host_data *) cmd->device->host->hostdata)->ncb;
8786 int sts;
8787 unsigned long flags;
8788 Scsi_Cmnd *done_list;
8789
8790 #if defined SCSI_RESET_SYNCHRONOUS && defined SCSI_RESET_ASYNCHRONOUS
8791 printk("ncr53c8xx_abort: pid=%lu serial_number=%ld serial_number_at_timeout=%ld\n",
8792 cmd->pid, cmd->serial_number, cmd->serial_number_at_timeout);
8793 #else
8794 printk("ncr53c8xx_abort: command pid %lu\n", cmd->pid);
8795 #endif
8796
8797 NCR_LOCK_NCB(np, flags);
8798
8799 #if defined SCSI_RESET_SYNCHRONOUS && defined SCSI_RESET_ASYNCHRONOUS
8800 /*
8801 * We have to just ignore abort requests in some situations.
8802 */
8803 if (cmd->serial_number != cmd->serial_number_at_timeout) {
8804 sts = SCSI_ABORT_NOT_RUNNING;
8805 goto out;
8806 }
8807 #endif
8808
8809 sts = ncr_abort_command(np, cmd);
8810 out:
8811 done_list = np->done_list;
8812 np->done_list = 0;
8813 NCR_UNLOCK_NCB(np, flags);
8814
8815 ncr_flush_done_cmds(done_list);
8816
8817 return sts;
8818 }
8819
8820
8821 int ncr53c8xx_release(struct Scsi_Host *host)
8822 {
8823 #ifdef DEBUG_NCR53C8XX
8824 printk("ncr53c8xx : release\n");
8825 #endif
8826 ncr_detach(((struct host_data *) host->hostdata)->ncb);
8827
8828 return 1;
8829 }
8830
8831
8832 /*
8833 ** Scsi command waiting list management.
8834 **
8835 ** It may happen that we cannot insert a scsi command into the start queue,
8836 ** in the following circumstances.
8837 ** Too few preallocated ccb(s),
8838 ** maxtags < cmd_per_lun of the Linux host control block,
8839 ** etc...
8840 ** Such scsi commands are inserted into a waiting list.
8841 ** When a scsi command complete, we try to requeue the commands of the
8842 ** waiting list.
8843 */
8844
8845 #define next_wcmd host_scribble
8846
8847 static void insert_into_waiting_list(ncb_p np, Scsi_Cmnd *cmd)
8848 {
8849 Scsi_Cmnd *wcmd;
8850
8851 #ifdef DEBUG_WAITING_LIST
8852 printk("%s: cmd %lx inserted into waiting list\n", ncr_name(np), (u_long) cmd);
8853 #endif
8854 cmd->next_wcmd = 0;
8855 if (!(wcmd = np->waiting_list)) np->waiting_list = cmd;
8856 else {
8857 while ((wcmd->next_wcmd) != 0)
8858 wcmd = (Scsi_Cmnd *) wcmd->next_wcmd;
8859 wcmd->next_wcmd = (char *) cmd;
8860 }
8861 }
8862
8863 static Scsi_Cmnd *retrieve_from_waiting_list(int to_remove, ncb_p np, Scsi_Cmnd *cmd)
8864 {
8865 Scsi_Cmnd **pcmd = &np->waiting_list;
8866
8867 while (*pcmd) {
8868 if (cmd == *pcmd) {
8869 if (to_remove) {
8870 *pcmd = (Scsi_Cmnd *) cmd->next_wcmd;
8871 cmd->next_wcmd = 0;
8872 }
8873 #ifdef DEBUG_WAITING_LIST
8874 printk("%s: cmd %lx retrieved from waiting list\n", ncr_name(np), (u_long) cmd);
8875 #endif
8876 return cmd;
8877 }
8878 pcmd = (Scsi_Cmnd **) &(*pcmd)->next_wcmd;
8879 }
8880 return 0;
8881 }
8882
8883 static void process_waiting_list(ncb_p np, int sts)
8884 {
8885 Scsi_Cmnd *waiting_list, *wcmd;
8886
8887 waiting_list = np->waiting_list;
8888 np->waiting_list = 0;
8889
8890 #ifdef DEBUG_WAITING_LIST
8891 if (waiting_list) printk("%s: waiting_list=%lx processing sts=%d\n", ncr_name(np), (u_long) waiting_list, sts);
8892 #endif
8893 while ((wcmd = waiting_list) != 0) {
8894 waiting_list = (Scsi_Cmnd *) wcmd->next_wcmd;
8895 wcmd->next_wcmd = 0;
8896 if (sts == DID_OK) {
8897 #ifdef DEBUG_WAITING_LIST
8898 printk("%s: cmd %lx trying to requeue\n", ncr_name(np), (u_long) wcmd);
8899 #endif
8900 sts = ncr_queue_command(np, wcmd);
8901 }
8902 if (sts != DID_OK) {
8903 #ifdef DEBUG_WAITING_LIST
8904 printk("%s: cmd %lx done forced sts=%d\n", ncr_name(np), (u_long) wcmd, sts);
8905 #endif
8906 wcmd->result = ScsiResult(sts, 0);
8907 ncr_queue_done_cmd(np, wcmd);
8908 }
8909 }
8910 }
8911
8912 #undef next_wcmd
8913
8914 #ifdef SCSI_NCR_PROC_INFO_SUPPORT
8915
8916 /*=========================================================================
8917 ** Proc file system stuff
8918 **
8919 ** A read operation returns profile information.
8920 ** A write operation is a control command.
8921 ** The string is parsed in the driver code and the command is passed
8922 ** to the ncr_usercmd() function.
8923 **=========================================================================
8924 */
8925
8926 #ifdef SCSI_NCR_USER_COMMAND_SUPPORT
8927
8928 #define is_digit(c) ((c) >= '0' && (c) <= '9')
8929 #define digit_to_bin(c) ((c) - '0')
8930 #define is_space(c) ((c) == ' ' || (c) == '\t')
8931
8932 static int skip_spaces(char *ptr, int len)
8933 {
8934 int cnt, c;
8935
8936 for (cnt = len; cnt > 0 && (c = *ptr++) && is_space(c); cnt--);
8937
8938 return (len - cnt);
8939 }
8940
8941 static int get_int_arg(char *ptr, int len, u_long *pv)
8942 {
8943 int cnt, c;
8944 u_long v;
8945
8946 for (v = 0, cnt = len; cnt > 0 && (c = *ptr++) && is_digit(c); cnt--) {
8947 v = (v * 10) + digit_to_bin(c);
8948 }
8949
8950 if (pv)
8951 *pv = v;
8952
8953 return (len - cnt);
8954 }
8955
8956 static int is_keyword(char *ptr, int len, char *verb)
8957 {
8958 int verb_len = strlen(verb);
8959
8960 if (len >= strlen(verb) && !memcmp(verb, ptr, verb_len))
8961 return verb_len;
8962 else
8963 return 0;
8964
8965 }
8966
8967 #define SKIP_SPACES(min_spaces) \
8968 if ((arg_len = skip_spaces(ptr, len)) < (min_spaces)) \
8969 return -EINVAL; \
8970 ptr += arg_len; len -= arg_len;
8971
8972 #define GET_INT_ARG(v) \
8973 if (!(arg_len = get_int_arg(ptr, len, &(v)))) \
8974 return -EINVAL; \
8975 ptr += arg_len; len -= arg_len;
8976
8977
8978 /*
8979 ** Parse a control command
8980 */
8981
8982 static int ncr_user_command(ncb_p np, char *buffer, int length)
8983 {
8984 char *ptr = buffer;
8985 int len = length;
8986 struct usrcmd *uc = &np->user;
8987 int arg_len;
8988 u_long target;
8989
8990 bzero(uc, sizeof(*uc));
8991
8992 if (len > 0 && ptr[len-1] == '\n')
8993 --len;
8994
8995 if ((arg_len = is_keyword(ptr, len, "setsync")) != 0)
8996 uc->cmd = UC_SETSYNC;
8997 else if ((arg_len = is_keyword(ptr, len, "settags")) != 0)
8998 uc->cmd = UC_SETTAGS;
8999 else if ((arg_len = is_keyword(ptr, len, "setorder")) != 0)
9000 uc->cmd = UC_SETORDER;
9001 else if ((arg_len = is_keyword(ptr, len, "setverbose")) != 0)
9002 uc->cmd = UC_SETVERBOSE;
9003 else if ((arg_len = is_keyword(ptr, len, "setwide")) != 0)
9004 uc->cmd = UC_SETWIDE;
9005 else if ((arg_len = is_keyword(ptr, len, "setdebug")) != 0)
9006 uc->cmd = UC_SETDEBUG;
9007 else if ((arg_len = is_keyword(ptr, len, "setflag")) != 0)
9008 uc->cmd = UC_SETFLAG;
9009 else
9010 arg_len = 0;
9011
9012 #ifdef DEBUG_PROC_INFO
9013 printk("ncr_user_command: arg_len=%d, cmd=%ld\n", arg_len, uc->cmd);
9014 #endif
9015
9016 if (!arg_len)
9017 return -EINVAL;
9018 ptr += arg_len; len -= arg_len;
9019
9020 switch(uc->cmd) {
9021 case UC_SETSYNC:
9022 case UC_SETTAGS:
9023 case UC_SETWIDE:
9024 case UC_SETFLAG:
9025 SKIP_SPACES(1);
9026 if ((arg_len = is_keyword(ptr, len, "all")) != 0) {
9027 ptr += arg_len; len -= arg_len;
9028 uc->target = ~0;
9029 } else {
9030 GET_INT_ARG(target);
9031 uc->target = (1<<target);
9032 #ifdef DEBUG_PROC_INFO
9033 printk("ncr_user_command: target=%ld\n", target);
9034 #endif
9035 }
9036 break;
9037 }
9038
9039 switch(uc->cmd) {
9040 case UC_SETVERBOSE:
9041 case UC_SETSYNC:
9042 case UC_SETTAGS:
9043 case UC_SETWIDE:
9044 SKIP_SPACES(1);
9045 GET_INT_ARG(uc->data);
9046 #ifdef DEBUG_PROC_INFO
9047 printk("ncr_user_command: data=%ld\n", uc->data);
9048 #endif
9049 break;
9050 case UC_SETORDER:
9051 SKIP_SPACES(1);
9052 if ((arg_len = is_keyword(ptr, len, "simple")))
9053 uc->data = M_SIMPLE_TAG;
9054 else if ((arg_len = is_keyword(ptr, len, "ordered")))
9055 uc->data = M_ORDERED_TAG;
9056 else if ((arg_len = is_keyword(ptr, len, "default")))
9057 uc->data = 0;
9058 else
9059 return -EINVAL;
9060 break;
9061 case UC_SETDEBUG:
9062 while (len > 0) {
9063 SKIP_SPACES(1);
9064 if ((arg_len = is_keyword(ptr, len, "alloc")))
9065 uc->data |= DEBUG_ALLOC;
9066 else if ((arg_len = is_keyword(ptr, len, "phase")))
9067 uc->data |= DEBUG_PHASE;
9068 else if ((arg_len = is_keyword(ptr, len, "queue")))
9069 uc->data |= DEBUG_QUEUE;
9070 else if ((arg_len = is_keyword(ptr, len, "result")))
9071 uc->data |= DEBUG_RESULT;
9072 else if ((arg_len = is_keyword(ptr, len, "scatter")))
9073 uc->data |= DEBUG_SCATTER;
9074 else if ((arg_len = is_keyword(ptr, len, "script")))
9075 uc->data |= DEBUG_SCRIPT;
9076 else if ((arg_len = is_keyword(ptr, len, "tiny")))
9077 uc->data |= DEBUG_TINY;
9078 else if ((arg_len = is_keyword(ptr, len, "timing")))
9079 uc->data |= DEBUG_TIMING;
9080 else if ((arg_len = is_keyword(ptr, len, "nego")))
9081 uc->data |= DEBUG_NEGO;
9082 else if ((arg_len = is_keyword(ptr, len, "tags")))
9083 uc->data |= DEBUG_TAGS;
9084 else
9085 return -EINVAL;
9086 ptr += arg_len; len -= arg_len;
9087 }
9088 #ifdef DEBUG_PROC_INFO
9089 printk("ncr_user_command: data=%ld\n", uc->data);
9090 #endif
9091 break;
9092 case UC_SETFLAG:
9093 while (len > 0) {
9094 SKIP_SPACES(1);
9095 if ((arg_len = is_keyword(ptr, len, "trace")))
9096 uc->data |= UF_TRACE;
9097 else if ((arg_len = is_keyword(ptr, len, "no_disc")))
9098 uc->data |= UF_NODISC;
9099 else
9100 return -EINVAL;
9101 ptr += arg_len; len -= arg_len;
9102 }
9103 break;
9104 default:
9105 break;
9106 }
9107
9108 if (len)
9109 return -EINVAL;
9110 else {
9111 unsigned long flags;
9112
9113 NCR_LOCK_NCB(np, flags);
9114 ncr_usercmd (np);
9115 NCR_UNLOCK_NCB(np, flags);
9116 }
9117 return length;
9118 }
9119
9120 #endif /* SCSI_NCR_USER_COMMAND_SUPPORT */
9121
9122
9123 #ifdef SCSI_NCR_USER_INFO_SUPPORT
9124 /*
9125 ** Copy formatted information into the input buffer.
9126 */
9127
9128 static int ncr_host_info(ncb_p np, char *ptr, off_t offset, int len)
9129 {
9130 struct info_str info;
9131
9132 info.buffer = ptr;
9133 info.length = len;
9134 info.offset = offset;
9135 info.pos = 0;
9136
9137 copy_info(&info, " Chip NCR53C%s, device id 0x%x, "
9138 "revision id 0x%x\n",
9139 np->chip_name, np->device_id, np->revision_id);
9140 copy_info(&info, " On PCI bus %d, device %d, function %d, "
9141 #ifdef __sparc__
9142 "IRQ %s\n",
9143 #else
9144 "IRQ %d\n",
9145 #endif
9146 np->bus, (np->device_fn & 0xf8) >> 3, np->device_fn & 7,
9147 #ifdef __sparc__
9148 __irq_itoa(np->irq));
9149 #else
9150 (int) np->irq);
9151 #endif
9152 copy_info(&info, " Synchronous period factor %d, "
9153 "max commands per lun %d\n",
9154 (int) np->minsync, MAX_TAGS);
9155
9156 if (driver_setup.debug || driver_setup.verbose > 1) {
9157 copy_info(&info, " Debug flags 0x%x, verbosity level %d\n",
9158 driver_setup.debug, driver_setup.verbose);
9159 }
9160
9161 return info.pos > info.offset? info.pos - info.offset : 0;
9162 }
9163
9164 #endif /* SCSI_NCR_USER_INFO_SUPPORT */
9165
9166 /*
9167 ** Entry point of the scsi proc fs of the driver.
9168 ** - func = 0 means read (returns profile data)
9169 ** - func = 1 means write (parse user control command)
9170 */
9171
9172 static int ncr53c8xx_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
9173 int length, int func)
9174 {
9175 struct host_data *host_data;
9176 ncb_p ncb = 0;
9177 int retv;
9178
9179 #ifdef DEBUG_PROC_INFO
9180 printk("ncr53c8xx_proc_info: hostno=%d, func=%d\n", host->host_no, func);
9181 #endif
9182
9183 host_data = (struct host_data *) host->hostdata;
9184 ncb = host_data->ncb;
9185
9186 if (func) {
9187 #ifdef SCSI_NCR_USER_COMMAND_SUPPORT
9188 retv = ncr_user_command(ncb, buffer, length);
9189 #else
9190 retv = -EINVAL;
9191 #endif
9192 }
9193 else {
9194 if (start)
9195 *start = buffer;
9196 #ifdef SCSI_NCR_USER_INFO_SUPPORT
9197 retv = ncr_host_info(ncb, buffer, offset, length);
9198 #else
9199 retv = -EINVAL;
9200 #endif
9201 }
9202
9203 return retv;
9204 }
9205
9206 /*=========================================================================
9207 ** End of proc file system stuff
9208 **=========================================================================
9209 */
9210 #endif
9211
9212
9213 /*==========================================================
9214 **
9215 ** /proc directory entry.
9216 **
9217 **==========================================================
9218 */
9219 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,27)
9220 static struct proc_dir_entry proc_scsi_ncr53c8xx = {
9221 PROC_SCSI_NCR53C8XX, 9, NAME53C8XX,
9222 S_IFDIR | S_IRUGO | S_IXUGO, 2
9223 };
9224 #endif
9225
9226 /*==========================================================
9227 **
9228 ** Boot command line.
9229 **
9230 **==========================================================
9231 */
9232 #ifdef MODULE
9233 char *ncr53c8xx = 0; /* command line passed by insmod */
9234 # if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,30)
9235 MODULE_PARM(ncr53c8xx, "s");
9236 # endif
9237 #endif
9238
9239 int __init ncr53c8xx_setup(char *str)
9240 {
9241 return sym53c8xx__setup(str);
9242 }
9243
9244 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,13)
9245 #ifndef MODULE
9246 __setup("ncr53c8xx=", ncr53c8xx_setup);
9247 #endif
9248 #endif
9249
9250 /*===================================================================
9251 **
9252 ** SYM53C8XX supported device list
9253 **
9254 **===================================================================
9255 */
9256
9257 static u_short ncr_chip_ids[] __initdata = {
9258 PSEUDO_720_ID,
9259 PCI_DEVICE_ID_NCR_53C810,
9260 PCI_DEVICE_ID_NCR_53C815,
9261 PCI_DEVICE_ID_NCR_53C820,
9262 PCI_DEVICE_ID_NCR_53C825,
9263 PCI_DEVICE_ID_NCR_53C860,
9264 PCI_DEVICE_ID_NCR_53C875,
9265 PCI_DEVICE_ID_NCR_53C875J,
9266 PCI_DEVICE_ID_NCR_53C885,
9267 PCI_DEVICE_ID_NCR_53C895,
9268 PCI_DEVICE_ID_NCR_53C896,
9269 PCI_DEVICE_ID_NCR_53C895A,
9270 PCI_DEVICE_ID_NCR_53C1510D
9271 };
9272
9273
9274 /*==========================================================
9275 **
9276 ** Chip detection entry point.
9277 **
9278 **==========================================================
9279 */
9280 int __init ncr53c8xx_detect(Scsi_Host_Template *tpnt)
9281 {
9282 #if defined(SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT) && defined(MODULE)
9283 if (ncr53c8xx)
9284 ncr53c8xx_setup(ncr53c8xx);
9285 #endif
9286
9287 return sym53c8xx__detect(tpnt, ncr_chip_ids,
9288 sizeof(ncr_chip_ids)/sizeof(ncr_chip_ids[0]));
9289 }
9290
9291 /*==========================================================
9292 **
9293 ** Entry point for info() function
9294 **
9295 **==========================================================
9296 */
9297 const char *ncr53c8xx_info (struct Scsi_Host *host)
9298 {
9299 return SCSI_NCR_DRIVER_NAME;
9300 }
Mirror of the linux-mips.org kernel tree