2 * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family
3 * of PCI-SCSI IO processors.
5 * Copyright (C) 1999-2001 Gerard Roudier <groudier@free.fr>
7 * This driver is derived from the Linux sym53c8xx driver.
8 * Copyright (C) 1998-2000 Gerard Roudier
10 * The sym53c8xx driver is derived from the ncr53c8xx driver that had been
11 * a port of the FreeBSD ncr driver to Linux-1.2.13.
13 * The original ncr driver has been written for 386bsd and FreeBSD by
14 * Wolfgang Stanglmeier <wolf@cologne.de>
15 * Stefan Esser <se@mi.Uni-Koeln.de>
16 * Copyright (C) 1994 Wolfgang Stanglmeier
18 * Other major contributions:
20 * NVRAM detection and reading.
21 * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk>
23 *-----------------------------------------------------------------------------
25 * This program is free software; you can redistribute it and/or modify
26 * it under the terms of the GNU General Public License as published by
27 * the Free Software Foundation; either version 2 of the License, or
28 * (at your option) any later version.
30 * This program is distributed in the hope that it will be useful,
31 * but WITHOUT ANY WARRANTY; without even the implied warranty of
32 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
33 * GNU General Public License for more details.
35 * You should have received a copy of the GNU General Public License
36 * along with this program; if not, write to the Free Software
37 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
40 #include <linux/gfp.h>
46 * Generic driver options.
48 * They may be defined in platform specific headers, if they
51 * SYM_OPT_HANDLE_DIR_UNKNOWN
52 * When this option is set, the SCRIPTS used by the driver
53 * are able to handle SCSI transfers with direction not
55 * (set for Linux-2.0.X)
57 * SYM_OPT_HANDLE_DEVICE_QUEUEING
58 * When this option is set, the driver will use a queue per
59 * device and handle QUEUE FULL status requeuing internally.
61 * SYM_OPT_LIMIT_COMMAND_REORDERING
62 * When this option is set, the driver tries to limit tagged
63 * command reordering to some reasonnable value.
67 #define SYM_OPT_HANDLE_DIR_UNKNOWN
68 #define SYM_OPT_HANDLE_DEVICE_QUEUEING
69 #define SYM_OPT_LIMIT_COMMAND_REORDERING
73 * Active debugging tags and verbosity.
74 * Both DEBUG_FLAGS and sym_verbose can be redefined
75 * by the platform specific code to something else.
77 #define DEBUG_ALLOC (0x0001)
78 #define DEBUG_PHASE (0x0002)
79 #define DEBUG_POLL (0x0004)
80 #define DEBUG_QUEUE (0x0008)
81 #define DEBUG_RESULT (0x0010)
82 #define DEBUG_SCATTER (0x0020)
83 #define DEBUG_SCRIPT (0x0040)
84 #define DEBUG_TINY (0x0080)
85 #define DEBUG_TIMING (0x0100)
86 #define DEBUG_NEGO (0x0200)
87 #define DEBUG_TAGS (0x0400)
88 #define DEBUG_POINTER (0x0800)
91 #define DEBUG_FLAGS (0x0000)
95 #define sym_verbose (np->verbose)
99 * These ones should have been already defined.
102 #define assert(expression) { \
103 if (!(expression)) { \
105 "assertion \"%s\" failed: file \"%s\", line %d\n", \
107 __FILE__, __LINE__); \
113 * Number of tasks per device we want to handle.
115 #if SYM_CONF_MAX_TAG_ORDER > 8
116 #error "more than 256 tags per logical unit not allowed."
118 #define SYM_CONF_MAX_TASK (1<<SYM_CONF_MAX_TAG_ORDER)
121 * Donnot use more tasks that we can handle.
123 #ifndef SYM_CONF_MAX_TAG
124 #define SYM_CONF_MAX_TAG SYM_CONF_MAX_TASK
126 #if SYM_CONF_MAX_TAG > SYM_CONF_MAX_TASK
127 #undef SYM_CONF_MAX_TAG
128 #define SYM_CONF_MAX_TAG SYM_CONF_MAX_TASK
132 * This one means 'NO TAG for this job'
137 * Number of SCSI targets.
139 #if SYM_CONF_MAX_TARGET > 16
140 #error "more than 16 targets not allowed."
144 * Number of logical units per target.
146 #if SYM_CONF_MAX_LUN > 64
147 #error "more than 64 logical units per target not allowed."
151 * Asynchronous pre-scaler (ns). Shall be 40 for
152 * the SCSI timings to be compliant.
154 #define SYM_CONF_MIN_ASYNC (40)
161 #define SYM_MEM_WARN 1 /* Warn on failed operations */
163 #define SYM_MEM_PAGE_ORDER 0 /* 1 PAGE maximum */
164 #define SYM_MEM_CLUSTER_SHIFT (PAGE_SHIFT+SYM_MEM_PAGE_ORDER)
165 #define SYM_MEM_FREE_UNUSED /* Free unused pages immediately */
167 * Shortest memory chunk is (1<<SYM_MEM_SHIFT), currently 16.
168 * Actual allocations happen as SYM_MEM_CLUSTER_SIZE sized.
169 * (1 PAGE at a time is just fine).
171 #define SYM_MEM_SHIFT 4
172 #define SYM_MEM_CLUSTER_SIZE (1UL << SYM_MEM_CLUSTER_SHIFT)
173 #define SYM_MEM_CLUSTER_MASK (SYM_MEM_CLUSTER_SIZE-1)
176 * Number of entries in the START and DONE queues.
178 * We limit to 1 PAGE in order to succeed allocation of
179 * these queues. Each entry is 8 bytes long (2 DWORDS).
181 #ifdef SYM_CONF_MAX_START
182 #define SYM_CONF_MAX_QUEUE (SYM_CONF_MAX_START+2)
184 #define SYM_CONF_MAX_QUEUE (7*SYM_CONF_MAX_TASK+2)
185 #define SYM_CONF_MAX_START (SYM_CONF_MAX_QUEUE-2)
188 #if SYM_CONF_MAX_QUEUE > SYM_MEM_CLUSTER_SIZE/8
189 #undef SYM_CONF_MAX_QUEUE
190 #define SYM_CONF_MAX_QUEUE (SYM_MEM_CLUSTER_SIZE/8)
191 #undef SYM_CONF_MAX_START
192 #define SYM_CONF_MAX_START (SYM_CONF_MAX_QUEUE-2)
196 * For this one, we want a short name :-)
198 #define MAX_QUEUE SYM_CONF_MAX_QUEUE
201 * Common definitions for both bus space based and legacy IO methods.
204 #define INB_OFF(np, o) ioread8(np->s.ioaddr + (o))
205 #define INW_OFF(np, o) ioread16(np->s.ioaddr + (o))
206 #define INL_OFF(np, o) ioread32(np->s.ioaddr + (o))
208 #define OUTB_OFF(np, o, val) iowrite8((val), np->s.ioaddr + (o))
209 #define OUTW_OFF(np, o, val) iowrite16((val), np->s.ioaddr + (o))
210 #define OUTL_OFF(np, o, val) iowrite32((val), np->s.ioaddr + (o))
212 #define INB(np, r) INB_OFF(np, offsetof(struct sym_reg, r))
213 #define INW(np, r) INW_OFF(np, offsetof(struct sym_reg, r))
214 #define INL(np, r) INL_OFF(np, offsetof(struct sym_reg, r))
216 #define OUTB(np, r, v) OUTB_OFF(np, offsetof(struct sym_reg, r), (v))
217 #define OUTW(np, r, v) OUTW_OFF(np, offsetof(struct sym_reg, r), (v))
218 #define OUTL(np, r, v) OUTL_OFF(np, offsetof(struct sym_reg, r), (v))
220 #define OUTONB(np, r, m) OUTB(np, r, INB(np, r) | (m))
221 #define OUTOFFB(np, r, m) OUTB(np, r, INB(np, r) & ~(m))
222 #define OUTONW(np, r, m) OUTW(np, r, INW(np, r) | (m))
223 #define OUTOFFW(np, r, m) OUTW(np, r, INW(np, r) & ~(m))
224 #define OUTONL(np, r, m) OUTL(np, r, INL(np, r) | (m))
225 #define OUTOFFL(np, r, m) OUTL(np, r, INL(np, r) & ~(m))
228 * We normally want the chip to have a consistent view
229 * of driver internal data structures when we restart it.
232 #define OUTL_DSP(np, v) \
234 MEMORY_WRITE_BARRIER(); \
235 OUTL(np, nc_dsp, (v)); \
238 #define OUTONB_STD() \
240 MEMORY_WRITE_BARRIER(); \
241 OUTONB(np, nc_dcntl, (STD|NOCOM)); \
245 * Command control block states.
249 #define HS_NEGOTIATE (2) /* sync/wide data transfer*/
250 #define HS_DISCONNECT (3) /* Disconnected by target */
251 #define HS_WAIT (4) /* waiting for resource */
253 #define HS_DONEMASK (0x80)
254 #define HS_COMPLETE (4|HS_DONEMASK)
255 #define HS_SEL_TIMEOUT (5|HS_DONEMASK) /* Selection timeout */
256 #define HS_UNEXPECTED (6|HS_DONEMASK) /* Unexpected disconnect */
257 #define HS_COMP_ERR (7|HS_DONEMASK) /* Completed with error */
260 * Software Interrupt Codes
262 #define SIR_BAD_SCSI_STATUS (1)
263 #define SIR_SEL_ATN_NO_MSG_OUT (2)
264 #define SIR_MSG_RECEIVED (3)
265 #define SIR_MSG_WEIRD (4)
266 #define SIR_NEGO_FAILED (5)
267 #define SIR_NEGO_PROTO (6)
268 #define SIR_SCRIPT_STOPPED (7)
269 #define SIR_REJECT_TO_SEND (8)
270 #define SIR_SWIDE_OVERRUN (9)
271 #define SIR_SODL_UNDERRUN (10)
272 #define SIR_RESEL_NO_MSG_IN (11)
273 #define SIR_RESEL_NO_IDENTIFY (12)
274 #define SIR_RESEL_BAD_LUN (13)
275 #define SIR_TARGET_SELECTED (14)
276 #define SIR_RESEL_BAD_I_T_L (15)
277 #define SIR_RESEL_BAD_I_T_L_Q (16)
278 #define SIR_ABORT_SENT (17)
279 #define SIR_RESEL_ABORTED (18)
280 #define SIR_MSG_OUT_DONE (19)
281 #define SIR_COMPLETE_ERROR (20)
282 #define SIR_DATA_OVERRUN (21)
283 #define SIR_BAD_PHASE (22)
284 #if SYM_CONF_DMA_ADDRESSING_MODE == 2
285 #define SIR_DMAP_DIRTY (23)
292 * Extended error bit codes.
293 * xerr_status field of struct sym_ccb.
295 #define XE_EXTRA_DATA (1) /* unexpected data phase */
296 #define XE_BAD_PHASE (1<<1) /* illegal phase (4/5) */
297 #define XE_PARITY_ERR (1<<2) /* unrecovered SCSI parity error */
298 #define XE_SODL_UNRUN (1<<3) /* ODD transfer in DATA OUT phase */
299 #define XE_SWIDE_OVRUN (1<<4) /* ODD transfer in DATA IN phase */
302 * Negotiation status.
303 * nego_status field of struct sym_ccb.
310 * A CCB hashed table is used to retrieve CCB address
313 #define CCB_HASH_SHIFT 8
314 #define CCB_HASH_SIZE (1UL << CCB_HASH_SHIFT)
315 #define CCB_HASH_MASK (CCB_HASH_SIZE-1)
317 #define CCB_HASH_CODE(dsa) \
318 (((dsa) >> (_LGRU16_(sizeof(struct sym_ccb)))) & CCB_HASH_MASK)
320 #define CCB_HASH_CODE(dsa) (((dsa) >> 9) & CCB_HASH_MASK)
323 #if SYM_CONF_DMA_ADDRESSING_MODE == 2
325 * We may want to use segment registers for 64 bit DMA.
326 * 16 segments registers -> up to 64 GB addressable.
328 #define SYM_DMAP_SHIFT (4)
329 #define SYM_DMAP_SIZE (1u<<SYM_DMAP_SHIFT)
330 #define SYM_DMAP_MASK (SYM_DMAP_SIZE-1)
336 #define SYM_DISC_ENABLED (1)
337 #define SYM_TAGS_ENABLED (1<<1)
338 #define SYM_SCAN_BOOT_DISABLED (1<<2)
339 #define SYM_SCAN_LUNS_DISABLED (1<<3)
342 * Host adapter miscellaneous flags.
344 #define SYM_AVOID_BUS_RESET (1)
349 #define SYM_SNOOP_TIMEOUT (10000000)
354 * Gather negotiable parameters value
359 unsigned int width:1;
363 unsigned int check_nego:1;
369 * Due to lack of indirect addressing on earlier NCR chips,
370 * this substructure is copied from the TCB to a global
371 * address after selection.
372 * For SYMBIOS chips that support LOAD/STORE this copy is
373 * not needed and thus not performed.
377 * Scripts bus addresses of LUN table accessed from scripts.
378 * LUN #0 is a special case, since multi-lun devices are rare,
379 * and we we want to speed-up the general case and not waste
382 u32 luntbl_sa; /* bus address of this table */
383 u32 lun0_sa; /* bus address of LCB #0 */
385 * Actual SYNC/WIDE IO registers value for this target.
386 * 'sval', 'wval' and 'uval' are read from SCRIPTS and
387 * so have alignment constraints.
389 /*0*/ u_char uval; /* -> SCNTL4 register */
390 /*1*/ u_char sval; /* -> SXFER io register */
391 /*2*/ u_char filler1;
392 /*3*/ u_char wval; /* -> SCNTL3 io register */
396 * Target Control Block
401 * Assumed at offset 0.
403 /*0*/ struct sym_tcbh head;
406 * LUN table used by the SCRIPTS processor.
407 * An array of bus addresses is used on reselection.
409 u32 *luntbl; /* LCBs bus address table */
412 * LUN table used by the C code.
414 struct sym_lcb *lun0p; /* LCB of LUN #0 (usual case) */
415 #if SYM_CONF_MAX_LUN > 1
416 struct sym_lcb **lunmp; /* Other LCBs [1..MAX_LUN] */
420 * Bitmap that tells about LUNs that succeeded at least
421 * 1 IO and therefore assumed to be a real device.
422 * Avoid useless allocation of the LCB structure.
424 u32 lun_map[(SYM_CONF_MAX_LUN+31)/32];
427 * Bitmap that tells about LUNs that haven't yet an LCB
428 * allocated (not discovered or LCB allocation failed).
430 u32 busy0_map[(SYM_CONF_MAX_LUN+31)/32];
434 * O/S specific data structure.
440 struct sym_trans tgoal;
443 * Keep track of the CCB used for the negotiation in order
444 * to ensure that only 1 negotiation is queued at a time.
446 struct sym_ccb * nego_cp; /* CCB used for the nego */
449 * Set when we want to reset the device.
454 * Other user settable limits and options.
455 * These limits are read from the NVRAM if present.
459 struct scsi_target *starget;
465 * Due to lack of indirect addressing on earlier NCR chips,
466 * this substructure is copied from the LCB to a global
467 * address after selection.
468 * For SYMBIOS chips that support LOAD/STORE this copy is
469 * not needed and thus not performed.
473 * SCRIPTS address jumped by SCRIPTS on reselection.
474 * For not probed logical units, this address points to
475 * SCRIPTS that deal with bad LU handling (must be at
476 * offset zero of the LCB for that reason).
481 * Task (bus address of a CCB) read from SCRIPTS that points
482 * to the unique ITL nexus allowed to be disconnected.
487 * Task table bus address (read from SCRIPTS).
493 * Logical Unit Control Block
498 * Assumed at offset 0.
500 /*0*/ struct sym_lcbh head;
503 * Task table read from SCRIPTS that contains pointers to
504 * ITLQ nexuses. The bus address read from SCRIPTS is
507 u32 *itlq_tbl; /* Kernel virtual address */
510 * Busy CCBs management.
512 u_short busy_itlq; /* Number of busy tagged CCBs */
513 u_short busy_itl; /* Number of busy untagged CCBs */
516 * Circular tag allocation buffer.
518 u_short ia_tag; /* Tag allocation index */
519 u_short if_tag; /* Tag release index */
520 u_char *cb_tags; /* Circular tags buffer */
523 * O/S specific data structure.
529 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
531 * Optionnaly the driver can handle device queueing,
532 * and requeues internally command to redo.
534 SYM_QUEHEAD waiting_ccbq;
535 SYM_QUEHEAD started_ccbq;
537 u_short started_tags;
538 u_short started_no_tag;
540 u_short started_limit;
543 #ifdef SYM_OPT_LIMIT_COMMAND_REORDERING
545 * Optionally the driver can try to prevent SCSI
546 * IOs from being reordered too much.
548 u_char tags_si; /* Current index to tags sum */
549 u_short tags_sum[2]; /* Tags sum counters */
550 u_short tags_since; /* # of tags since last switch */
554 * Set when we want to clear all tasks.
566 * Action from SCRIPTS on a task.
567 * Is part of the CCB, but is also used separately to plug
568 * error handling action to perform from SCRIPTS.
571 u32 start; /* Jumped by SCRIPTS after selection */
572 u32 restart; /* Jumped by SCRIPTS on relection */
576 * Phase mismatch context.
578 * It is part of the CCB and is used as parameters for the
579 * DATA pointer. We need two contexts to handle correctly the
580 * SAVED DATA POINTER.
583 struct sym_tblmove sg; /* Updated interrupted SG block */
584 u32 ret; /* SCRIPT return address */
588 * LUN control block lookup.
589 * We use a direct pointer for LUN #0, and a table of
590 * pointers which is only allocated for devices that support
593 #if SYM_CONF_MAX_LUN <= 1
594 #define sym_lp(tp, lun) (!lun) ? (tp)->lun0p : NULL
596 #define sym_lp(tp, lun) \
597 (!lun) ? (tp)->lun0p : (tp)->lunmp ? (tp)->lunmp[(lun)] : NULL
601 * Status are used by the host and the script processor.
603 * The last four bytes (status[4]) are copied to the
604 * scratchb register (declared as scr0..scr3) just after the
605 * select/reselect, and copied back just after disconnecting.
606 * Inside the script the XX_REG are used.
610 * Last four bytes (script)
613 #define HX_PRT nc_scr0
615 #define HS_PRT nc_scr1
617 #define SS_PRT nc_scr2
619 #define HF_PRT nc_scr3
622 * Last four bytes (host)
624 #define host_xflags phys.head.status[0]
625 #define host_status phys.head.status[1]
626 #define ssss_status phys.head.status[2]
627 #define host_flags phys.head.status[3]
633 #define HF_IN_PM1 (1u<<1)
634 #define HF_ACT_PM (1u<<2)
635 #define HF_DP_SAVED (1u<<3)
636 #define HF_SENSE (1u<<4)
637 #define HF_EXT_ERR (1u<<5)
638 #define HF_DATA_IN (1u<<6)
639 #ifdef SYM_CONF_IARB_SUPPORT
640 #define HF_HINT_IARB (1u<<7)
646 #if SYM_CONF_DMA_ADDRESSING_MODE == 2
647 #define HX_DMAP_DIRTY (1u<<7)
653 * Due to lack of indirect addressing on earlier NCR chips,
654 * this substructure is copied from the ccb to a global
655 * address after selection (or reselection) and copied back
657 * For SYMBIOS chips that support LOAD/STORE this copy is
658 * not needed and thus not performed.
663 * Start and restart SCRIPTS addresses (must be at 0).
665 /*0*/ struct sym_actscr go;
668 * SCRIPTS jump address that deal with data pointers.
669 * 'savep' points to the position in the script responsible
670 * for the actual transfer of data.
671 * It's written on reception of a SAVE_DATA_POINTER message.
673 u32 savep; /* Jump address to saved data pointer */
674 u32 lastp; /* SCRIPTS address at end of data */
675 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN
686 * GET/SET the value of the data pointer used by SCRIPTS.
688 * We must distinguish between the LOAD/STORE-based SCRIPTS
689 * that use directly the header in the CCB, and the NCR-GENERIC
690 * SCRIPTS that use the copy of the header in the HCB.
692 #if SYM_CONF_GENERIC_SUPPORT
693 #define sym_set_script_dp(np, cp, dp) \
695 if (np->features & FE_LDSTR) \
696 cp->phys.head.lastp = cpu_to_scr(dp); \
698 np->ccb_head.lastp = cpu_to_scr(dp); \
700 #define sym_get_script_dp(np, cp) \
701 scr_to_cpu((np->features & FE_LDSTR) ? \
702 cp->phys.head.lastp : np->ccb_head.lastp)
704 #define sym_set_script_dp(np, cp, dp) \
706 cp->phys.head.lastp = cpu_to_scr(dp); \
709 #define sym_get_script_dp(np, cp) (cp->phys.head.lastp)
713 * Data Structure Block
715 * During execution of a ccb by the script processor, the
716 * DSA (data structure address) register points to this
717 * substructure of the ccb.
722 * Also assumed at offset 0 of the sym_ccb structure.
724 /*0*/ struct sym_ccbh head;
727 * Phase mismatch contexts.
728 * We need two to handle correctly the SAVED DATA POINTER.
729 * MUST BOTH BE AT OFFSET < 256, due to using 8 bit arithmetic
730 * for address calculation from SCRIPTS.
736 * Table data for Script
738 struct sym_tblsel select;
739 struct sym_tblmove smsg;
740 struct sym_tblmove smsg_ext;
741 struct sym_tblmove cmd;
742 struct sym_tblmove sense;
743 struct sym_tblmove wresid;
744 struct sym_tblmove data [SYM_CONF_MAX_SG];
748 * Our Command Control Block
752 * This is the data structure which is pointed by the DSA
753 * register when it is executed by the script processor.
754 * It must be the first entry.
759 * Pointer to CAM ccb and related stuff.
761 struct scsi_cmnd *cmd; /* CAM scsiio ccb */
762 u8 cdb_buf[16]; /* Copy of CDB */
763 #define SYM_SNS_BBUF_LEN 32
764 u8 sns_bbuf[SYM_SNS_BBUF_LEN]; /* Bounce buffer for sense data */
765 int data_len; /* Total data length */
766 int segments; /* Number of SG segments */
768 u8 order; /* Tag type (if tagged command) */
769 unsigned char odd_byte_adjustment; /* odd-sized req on wide bus */
771 u_char nego_status; /* Negotiation status */
772 u_char xerr_status; /* Extended error flags */
773 u32 extra_bytes; /* Extraneous bytes transferred */
777 * We prepare a message to be sent after selection.
778 * We may use a second one if the command is rescheduled
779 * due to CHECK_CONDITION or COMMAND TERMINATED.
780 * Contents are IDENTIFY and SIMPLE_TAG.
781 * While negotiating sync or wide transfer,
782 * a SDTR or WDTR message is appended.
784 u_char scsi_smsg [12];
785 u_char scsi_smsg2[12];
788 * Auto request sense related fields.
790 u_char sensecmd[6]; /* Request Sense command */
791 u_char sv_scsi_status; /* Saved SCSI status */
792 u_char sv_xerr_status; /* Saved extended status */
793 int sv_resid; /* Saved residual */
798 u32 ccb_ba; /* BUS address of this CCB */
799 u_short tag; /* Tag for this transfer */
800 /* NO_TAG means no tag */
803 struct sym_ccb *link_ccbh; /* Host adapter CCB hash chain */
804 SYM_QUEHEAD link_ccbq; /* Link to free/busy CCB queue */
805 u32 startp; /* Initial data pointer */
806 u32 goalp; /* Expected last data pointer */
807 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN
810 int ext_sg; /* Extreme data pointer, used */
811 int ext_ofs; /* to calculate the residual. */
812 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
813 SYM_QUEHEAD link2_ccbq; /* Link for device queueing */
814 u_char started; /* CCB queued to the squeue */
816 u_char to_abort; /* Want this IO to be aborted */
817 #ifdef SYM_OPT_LIMIT_COMMAND_REORDERING
818 u_char tags_si; /* Lun tags sum index (0,1) */
822 #define CCB_BA(cp,lbl) cpu_to_scr(cp->ccb_ba + offsetof(struct sym_ccb, lbl))
824 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN
825 #define sym_goalp(cp) ((cp->host_flags & HF_DATA_IN) ? cp->goalp : cp->wgoalp)
827 #define sym_goalp(cp) (cp->goalp)
830 typedef struct device *m_pool_ident_t;
838 * Due to poorness of addressing capabilities, earlier
839 * chips (810, 815, 825) copy part of the data structures
840 * (CCB, TCB and LCB) in fixed areas.
842 #if SYM_CONF_GENERIC_SUPPORT
843 struct sym_ccbh ccb_head;
844 struct sym_tcbh tcb_head;
845 struct sym_lcbh lcb_head;
848 * Idle task and invalid task actions and
849 * their bus addresses.
851 struct sym_actscr idletask, notask, bad_itl, bad_itlq;
852 u32 idletask_ba, notask_ba, bad_itl_ba, bad_itlq_ba;
855 * Dummy lun table to protect us against target
856 * returning bad lun number on reselection.
858 u32 *badluntbl; /* Table physical address */
859 u32 badlun_sa; /* SCRIPT handler BUS address */
862 * Bus address of this host control block.
867 * Bit 32-63 of the on-chip RAM bus address in LE format.
868 * The START_RAM64 script loads the MMRS and MMWS from this
874 * Initial value of some IO register bits.
875 * These values are assumed to have been set by BIOS, and may
876 * be used to probe adapter implementation differences.
878 u_char sv_scntl0, sv_scntl3, sv_dmode, sv_dcntl, sv_ctest3, sv_ctest4,
879 sv_ctest5, sv_gpcntl, sv_stest2, sv_stest4, sv_scntl4,
883 * Actual initial value of IO register bits used by the
884 * driver. They are loaded at initialisation according to
885 * features that are to be enabled/disabled.
887 u_char rv_scntl0, rv_scntl3, rv_dmode, rv_dcntl, rv_ctest3, rv_ctest4,
888 rv_ctest5, rv_stest2, rv_ccntl0, rv_ccntl1, rv_scntl4;
893 struct sym_tcb target[SYM_CONF_MAX_TARGET];
896 * Target control block bus address array used by the SCRIPT
903 * DMA pool handle for this HBA.
905 m_pool_ident_t bus_dmat;
908 * O/S specific data structure
913 * Physical bus addresses of the chip.
915 u32 mmio_ba; /* MMIO 32 bit BUS address */
916 int mmio_ws; /* MMIO Window size */
918 u32 ram_ba; /* RAM 32 bit BUS address */
919 int ram_ws; /* RAM window size */
922 * SCRIPTS virtual and physical bus addresses.
923 * 'script' is loaded in the on-chip RAM if present.
924 * 'scripth' stays in main memory for all chips except the
925 * 53C895A, 53C896 and 53C1010 that provide 8K on-chip RAM.
927 u_char *scripta0; /* Copy of scripts A, B, Z */
930 u32 scripta_ba; /* Actual scripts A, B, Z */
931 u32 scriptb_ba; /* 32 bit bus addresses. */
933 u_short scripta_sz; /* Actual size of script A, B, Z*/
938 * Bus addresses, setup and patch methods for
939 * the selected firmware.
941 struct sym_fwa_ba fwa_bas; /* Useful SCRIPTA bus addresses */
942 struct sym_fwb_ba fwb_bas; /* Useful SCRIPTB bus addresses */
943 struct sym_fwz_ba fwz_bas; /* Useful SCRIPTZ bus addresses */
944 void (*fw_setup)(struct sym_hcb *np, struct sym_fw *fw);
945 void (*fw_patch)(struct sym_hcb *np);
949 * General controller parameters and configuration.
951 u_short device_id; /* PCI device id */
952 u_char revision_id; /* PCI device revision id */
953 u_int features; /* Chip features map */
954 u_char myaddr; /* SCSI id of the adapter */
955 u_char maxburst; /* log base 2 of dwords burst */
956 u_char maxwide; /* Maximum transfer width */
957 u_char minsync; /* Min sync period factor (ST) */
958 u_char maxsync; /* Max sync period factor (ST) */
959 u_char maxoffs; /* Max scsi offset (ST) */
960 u_char minsync_dt; /* Min sync period factor (DT) */
961 u_char maxsync_dt; /* Max sync period factor (DT) */
962 u_char maxoffs_dt; /* Max scsi offset (DT) */
963 u_char multiplier; /* Clock multiplier (1,2,4) */
964 u_char clock_divn; /* Number of clock divisors */
965 u32 clock_khz; /* SCSI clock frequency in KHz */
966 u32 pciclk_khz; /* Estimated PCI clock in KHz */
968 * Start queue management.
969 * It is filled up by the host processor and accessed by the
970 * SCRIPTS processor in order to start SCSI commands.
972 volatile /* Prevent code optimizations */
973 u32 *squeue; /* Start queue virtual address */
974 u32 squeue_ba; /* Start queue BUS address */
975 u_short squeueput; /* Next free slot of the queue */
976 u_short actccbs; /* Number of allocated CCBs */
979 * Command completion queue.
980 * It is the same size as the start queue to avoid overflow.
982 u_short dqueueget; /* Next position to scan */
983 volatile /* Prevent code optimizations */
984 u32 *dqueue; /* Completion (done) queue */
985 u32 dqueue_ba; /* Done queue BUS address */
988 * Miscellaneous buffers accessed by the scripts-processor.
989 * They shall be DWORD aligned, because they may be read or
990 * written with a script command.
992 u_char msgout[8]; /* Buffer for MESSAGE OUT */
993 u_char msgin [8]; /* Buffer for MESSAGE IN */
994 u32 lastmsg; /* Last SCSI message sent */
995 u32 scratch; /* Scratch for SCSI receive */
996 /* Also used for cache test */
998 * Miscellaneous configuration and status parameters.
1000 u_char usrflags; /* Miscellaneous user flags */
1001 u_char scsi_mode; /* Current SCSI BUS mode */
1002 u_char verbose; /* Verbosity for this controller*/
1005 * CCB lists and queue.
1007 struct sym_ccb **ccbh; /* CCBs hashed by DSA value */
1008 /* CCB_HASH_SIZE lists of CCBs */
1009 SYM_QUEHEAD free_ccbq; /* Queue of available CCBs */
1010 SYM_QUEHEAD busy_ccbq; /* Queue of busy CCBs */
1013 * During error handling and/or recovery,
1014 * active CCBs that are to be completed with
1015 * error or requeued are moved from the busy_ccbq
1016 * to the comp_ccbq prior to completion.
1018 SYM_QUEHEAD comp_ccbq;
1020 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
1021 SYM_QUEHEAD dummy_ccbq;
1025 * IMMEDIATE ARBITRATION (IARB) control.
1027 * We keep track in 'last_cp' of the last CCB that has been
1028 * queued to the SCRIPTS processor and clear 'last_cp' when
1029 * this CCB completes. If last_cp is not zero at the moment
1030 * we queue a new CCB, we set a flag in 'last_cp' that is
1031 * used by the SCRIPTS as a hint for setting IARB.
1032 * We donnot set more than 'iarb_max' consecutive hints for
1033 * IARB in order to leave devices a chance to reselect.
1034 * By the way, any non zero value of 'iarb_max' is unfair. :)
1036 #ifdef SYM_CONF_IARB_SUPPORT
1037 u_short iarb_max; /* Max. # consecutive IARB hints*/
1038 u_short iarb_count; /* Actual # of these hints */
1039 struct sym_ccb * last_cp;
1043 * Command abort handling.
1044 * We need to synchronize tightly with the SCRIPTS
1045 * processor in order to handle things correctly.
1047 u_char abrt_msg[4]; /* Message to send buffer */
1048 struct sym_tblmove abrt_tbl; /* Table for the MOV of it */
1049 struct sym_tblsel abrt_sel; /* Sync params for selection */
1050 u_char istat_sem; /* Tells the chip to stop (SEM) */
1053 * 64 bit DMA handling.
1055 #if SYM_CONF_DMA_ADDRESSING_MODE != 0
1056 u_char use_dac; /* Use PCI DAC cycles */
1057 #if SYM_CONF_DMA_ADDRESSING_MODE == 2
1058 u_char dmap_dirty; /* Dma segments registers dirty */
1059 u32 dmap_bah[SYM_DMAP_SIZE];/* Segment registers map */
1064 #define HCB_BA(np, lbl) (np->hcb_ba + offsetof(struct sym_hcb, lbl))
1068 * FIRMWARES (sym_fw.c)
1070 struct sym_fw * sym_find_firmware(struct sym_chip *chip);
1071 void sym_fw_bind_script(struct sym_hcb *np, u32 *start, int len);
1074 * Driver methods called from O/S specific code.
1076 char *sym_driver_name(void);
1077 void sym_print_xerr(struct scsi_cmnd *cmd, int x_status);
1078 int sym_reset_scsi_bus(struct sym_hcb *np, int enab_int);
1079 struct sym_chip *sym_lookup_chip_table(u_short device_id, u_char revision);
1080 void sym_put_start_queue(struct sym_hcb *np, struct sym_ccb *cp);
1081 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
1082 void sym_start_next_ccbs(struct sym_hcb *np, struct sym_lcb *lp, int maxn);
1084 void sym_start_up(struct sym_hcb *np, int reason);
1085 void sym_interrupt(struct sym_hcb *np);
1086 int sym_clear_tasks(struct sym_hcb *np, int cam_status, int target, int lun, int task);
1087 struct sym_ccb *sym_get_ccb(struct sym_hcb *np, struct scsi_cmnd *cmd, u_char tag_order);
1088 void sym_free_ccb(struct sym_hcb *np, struct sym_ccb *cp);
1089 struct sym_lcb *sym_alloc_lcb(struct sym_hcb *np, u_char tn, u_char ln);
1090 int sym_queue_scsiio(struct sym_hcb *np, struct scsi_cmnd *csio, struct sym_ccb *cp);
1091 int sym_abort_scsiio(struct sym_hcb *np, struct scsi_cmnd *ccb, int timed_out);
1092 int sym_reset_scsi_target(struct sym_hcb *np, int target);
1093 void sym_hcb_free(struct sym_hcb *np);
1094 int sym_hcb_attach(struct Scsi_Host *shost, struct sym_fw *fw, struct sym_nvram *nvram);
1097 * Build a scatter/gather entry.
1099 * For 64 bit systems, we use the 8 upper bits of the size field
1100 * to provide bus address bits 32-39 to the SCRIPTS processor.
1101 * This allows the 895A, 896, 1010 to address up to 1 TB of memory.
1104 #if SYM_CONF_DMA_ADDRESSING_MODE == 0
1105 #define sym_build_sge(np, data, badd, len) \
1107 (data)->addr = cpu_to_scr(badd); \
1108 (data)->size = cpu_to_scr(len); \
1110 #elif SYM_CONF_DMA_ADDRESSING_MODE == 1
1111 #define sym_build_sge(np, data, badd, len) \
1113 (data)->addr = cpu_to_scr(badd); \
1114 (data)->size = cpu_to_scr((((badd) >> 8) & 0xff000000) + len); \
1116 #elif SYM_CONF_DMA_ADDRESSING_MODE == 2
1117 int sym_lookup_dmap(struct sym_hcb *np, u32 h, int s);
1118 static __inline void
1119 sym_build_sge(struct sym_hcb *np, struct sym_tblmove *data, u64 badd, int len)
1122 int s = (h&SYM_DMAP_MASK);
1124 if (h != np->dmap_bah[s])
1127 (data)->addr = cpu_to_scr(badd);
1128 (data)->size = cpu_to_scr((s<<24) + len);
1131 s = sym_lookup_dmap(np, h, s);
1135 #error "Unsupported DMA addressing mode"
1139 * Set up data pointers used by SCRIPTS.
1140 * Called from O/S specific code.
1142 static inline void sym_setup_data_pointers(struct sym_hcb *np,
1143 struct sym_ccb *cp, int dir)
1148 * No segments means no data.
1154 * Set the data pointer.
1157 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN
1158 case DMA_BIDIRECTIONAL:
1161 goalp = SCRIPTA_BA(np, data_out2) + 8;
1162 lastp = goalp - 8 - (cp->segments * (2*4));
1163 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN
1164 cp->wgoalp = cpu_to_scr(goalp);
1165 if (dir != DMA_BIDIRECTIONAL)
1167 cp->phys.head.wlastp = cpu_to_scr(lastp);
1172 case DMA_FROM_DEVICE:
1173 cp->host_flags |= HF_DATA_IN;
1174 goalp = SCRIPTA_BA(np, data_in2) + 8;
1175 lastp = goalp - 8 - (cp->segments * (2*4));
1179 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN
1180 cp->host_flags |= HF_DATA_IN;
1182 lastp = goalp = SCRIPTB_BA(np, no_data);
1187 * Set all pointers values needed by SCRIPTS.
1189 cp->phys.head.lastp = cpu_to_scr(lastp);
1190 cp->phys.head.savep = cpu_to_scr(lastp);
1191 cp->startp = cp->phys.head.savep;
1192 cp->goalp = cpu_to_scr(goalp);
1194 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN
1196 * If direction is unknown, start at data_io.
1198 if (dir == DMA_BIDIRECTIONAL)
1199 cp->phys.head.savep = cpu_to_scr(SCRIPTB_BA(np, data_io));
1207 #define sym_get_mem_cluster() \
1208 (void *) __get_free_pages(GFP_ATOMIC, SYM_MEM_PAGE_ORDER)
1209 #define sym_free_mem_cluster(p) \
1210 free_pages((unsigned long)p, SYM_MEM_PAGE_ORDER)
1213 * Link between free memory chunks of a given size.
1215 typedef struct sym_m_link {
1216 struct sym_m_link *next;
1220 * Virtual to bus physical translation for a given cluster.
1221 * Such a structure is only useful with DMA abstraction.
1223 typedef struct sym_m_vtob { /* Virtual to Bus address translation */
1224 struct sym_m_vtob *next;
1225 void *vaddr; /* Virtual address */
1226 dma_addr_t baddr; /* Bus physical address */
1229 /* Hash this stuff a bit to speed up translations */
1230 #define VTOB_HASH_SHIFT 5
1231 #define VTOB_HASH_SIZE (1UL << VTOB_HASH_SHIFT)
1232 #define VTOB_HASH_MASK (VTOB_HASH_SIZE-1)
1233 #define VTOB_HASH_CODE(m) \
1234 ((((unsigned long)(m)) >> SYM_MEM_CLUSTER_SHIFT) & VTOB_HASH_MASK)
1237 * Memory pool of a given kind.
1238 * Ideally, we want to use:
1239 * 1) 1 pool for memory we donnot need to involve in DMA.
1240 * 2) The same pool for controllers that require same DMA
1241 * constraints and features.
1242 * The OS specific m_pool_id_t thing and the sym_m_pool_match()
1243 * method are expected to tell the driver about.
1245 typedef struct sym_m_pool {
1246 m_pool_ident_t dev_dmat; /* Identifies the pool (see above) */
1247 void * (*get_mem_cluster)(struct sym_m_pool *);
1248 #ifdef SYM_MEM_FREE_UNUSED
1249 void (*free_mem_cluster)(struct sym_m_pool *, void *);
1251 #define M_GET_MEM_CLUSTER() mp->get_mem_cluster(mp)
1252 #define M_FREE_MEM_CLUSTER(p) mp->free_mem_cluster(mp, p)
1254 m_vtob_p vtob[VTOB_HASH_SIZE];
1255 struct sym_m_pool *next;
1256 struct sym_m_link h[SYM_MEM_CLUSTER_SHIFT - SYM_MEM_SHIFT + 1];
1260 * Alloc, free and translate addresses to bus physical
1261 * for DMAable memory.
1263 void *__sym_calloc_dma(m_pool_ident_t dev_dmat, int size, char *name);
1264 void __sym_mfree_dma(m_pool_ident_t dev_dmat, void *m, int size, char *name);
1265 dma_addr_t __vtobus(m_pool_ident_t dev_dmat, void *m);
1268 * Verbs used by the driver code for DMAable memory handling.
1269 * The _uvptv_ macro avoids a nasty warning about pointer to volatile
1272 #define _uvptv_(p) ((void *)((u_long)(p)))
1274 #define _sym_calloc_dma(np, l, n) __sym_calloc_dma(np->bus_dmat, l, n)
1275 #define _sym_mfree_dma(np, p, l, n) \
1276 __sym_mfree_dma(np->bus_dmat, _uvptv_(p), l, n)
1277 #define sym_calloc_dma(l, n) _sym_calloc_dma(np, l, n)
1278 #define sym_mfree_dma(p, l, n) _sym_mfree_dma(np, p, l, n)
1279 #define vtobus(p) __vtobus(np->bus_dmat, _uvptv_(p))
1282 * We have to provide the driver memory allocator with methods for
1283 * it to maintain virtual to bus physical address translations.
1286 #define sym_m_pool_match(mp_id1, mp_id2) (mp_id1 == mp_id2)
1288 static __inline void *sym_m_get_dma_mem_cluster(m_pool_p mp, m_vtob_p vbp)
1291 dma_addr_t baddr = 0;
1293 vaddr = dma_alloc_coherent(mp->dev_dmat, SYM_MEM_CLUSTER_SIZE, &baddr,
1302 static __inline void sym_m_free_dma_mem_cluster(m_pool_p mp, m_vtob_p vbp)
1304 dma_free_coherent(mp->dev_dmat, SYM_MEM_CLUSTER_SIZE, vbp->vaddr,
1308 #endif /* SYM_HIPD_H */