Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sym_hipd.h
Go to the documentation of this file.
1 /*
2  * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family
3  * of PCI-SCSI IO processors.
4  *
5  * Copyright (C) 1999-2001 Gerard Roudier <[email protected]>
6  *
7  * This driver is derived from the Linux sym53c8xx driver.
8  * Copyright (C) 1998-2000 Gerard Roudier
9  *
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.
12  *
13  * The original ncr driver has been written for 386bsd and FreeBSD by
14  * Wolfgang Stanglmeier <[email protected]>
15  * Stefan Esser <[email protected]>
16  * Copyright (C) 1994 Wolfgang Stanglmeier
17  *
18  * Other major contributions:
19  *
20  * NVRAM detection and reading.
21  * Copyright (C) 1997 Richard Waltham <[email protected]>
22  *
23  *-----------------------------------------------------------------------------
24  *
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.
29  *
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.
34  *
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
38  */
39 
40 #include <linux/gfp.h>
41 
42 #ifndef SYM_HIPD_H
43 #define SYM_HIPD_H
44 
45 /*
46  * Generic driver options.
47  *
48  * They may be defined in platform specific headers, if they
49  * are useful.
50  *
51  * SYM_OPT_HANDLE_DEVICE_QUEUEING
52  * When this option is set, the driver will use a queue per
53  * device and handle QUEUE FULL status requeuing internally.
54  *
55  * SYM_OPT_LIMIT_COMMAND_REORDERING
56  * When this option is set, the driver tries to limit tagged
57  * command reordering to some reasonable value.
58  * (set for Linux)
59  */
60 #if 0
61 #define SYM_OPT_HANDLE_DEVICE_QUEUEING
62 #define SYM_OPT_LIMIT_COMMAND_REORDERING
63 #endif
64 
65 /*
66  * Active debugging tags and verbosity.
67  * Both DEBUG_FLAGS and sym_verbose can be redefined
68  * by the platform specific code to something else.
69  */
70 #define DEBUG_ALLOC (0x0001)
71 #define DEBUG_PHASE (0x0002)
72 #define DEBUG_POLL (0x0004)
73 #define DEBUG_QUEUE (0x0008)
74 #define DEBUG_RESULT (0x0010)
75 #define DEBUG_SCATTER (0x0020)
76 #define DEBUG_SCRIPT (0x0040)
77 #define DEBUG_TINY (0x0080)
78 #define DEBUG_TIMING (0x0100)
79 #define DEBUG_NEGO (0x0200)
80 #define DEBUG_TAGS (0x0400)
81 #define DEBUG_POINTER (0x0800)
82 
83 #ifndef DEBUG_FLAGS
84 #define DEBUG_FLAGS (0x0000)
85 #endif
86 
87 #ifndef sym_verbose
88 #define sym_verbose (np->verbose)
89 #endif
90 
91 /*
92  * These ones should have been already defined.
93  */
94 #ifndef assert
95 #define assert(expression) { \
96  if (!(expression)) { \
97  (void)panic( \
98  "assertion \"%s\" failed: file \"%s\", line %d\n", \
99  #expression, \
100  __FILE__, __LINE__); \
101  } \
102 }
103 #endif
104 
105 /*
106  * Number of tasks per device we want to handle.
107  */
108 #if SYM_CONF_MAX_TAG_ORDER > 8
109 #error "more than 256 tags per logical unit not allowed."
110 #endif
111 #define SYM_CONF_MAX_TASK (1<<SYM_CONF_MAX_TAG_ORDER)
112 
113 /*
114  * Donnot use more tasks that we can handle.
115  */
116 #ifndef SYM_CONF_MAX_TAG
117 #define SYM_CONF_MAX_TAG SYM_CONF_MAX_TASK
118 #endif
119 #if SYM_CONF_MAX_TAG > SYM_CONF_MAX_TASK
120 #undef SYM_CONF_MAX_TAG
121 #define SYM_CONF_MAX_TAG SYM_CONF_MAX_TASK
122 #endif
123 
124 /*
125  * This one means 'NO TAG for this job'
126  */
127 #define NO_TAG (256)
128 
129 /*
130  * Number of SCSI targets.
131  */
132 #if SYM_CONF_MAX_TARGET > 16
133 #error "more than 16 targets not allowed."
134 #endif
135 
136 /*
137  * Number of logical units per target.
138  */
139 #if SYM_CONF_MAX_LUN > 64
140 #error "more than 64 logical units per target not allowed."
141 #endif
142 
143 /*
144  * Asynchronous pre-scaler (ns). Shall be 40 for
145  * the SCSI timings to be compliant.
146  */
147 #define SYM_CONF_MIN_ASYNC (40)
148 
149 
150 /*
151  * MEMORY ALLOCATOR.
152  */
153 
154 #define SYM_MEM_WARN 1 /* Warn on failed operations */
155 
156 #define SYM_MEM_PAGE_ORDER 0 /* 1 PAGE maximum */
157 #define SYM_MEM_CLUSTER_SHIFT (PAGE_SHIFT+SYM_MEM_PAGE_ORDER)
158 #define SYM_MEM_FREE_UNUSED /* Free unused pages immediately */
159 /*
160  * Shortest memory chunk is (1<<SYM_MEM_SHIFT), currently 16.
161  * Actual allocations happen as SYM_MEM_CLUSTER_SIZE sized.
162  * (1 PAGE at a time is just fine).
163  */
164 #define SYM_MEM_SHIFT 4
165 #define SYM_MEM_CLUSTER_SIZE (1UL << SYM_MEM_CLUSTER_SHIFT)
166 #define SYM_MEM_CLUSTER_MASK (SYM_MEM_CLUSTER_SIZE-1)
167 
168 /*
169  * Number of entries in the START and DONE queues.
170  *
171  * We limit to 1 PAGE in order to succeed allocation of
172  * these queues. Each entry is 8 bytes long (2 DWORDS).
173  */
174 #ifdef SYM_CONF_MAX_START
175 #define SYM_CONF_MAX_QUEUE (SYM_CONF_MAX_START+2)
176 #else
177 #define SYM_CONF_MAX_QUEUE (7*SYM_CONF_MAX_TASK+2)
178 #define SYM_CONF_MAX_START (SYM_CONF_MAX_QUEUE-2)
179 #endif
180 
181 #if SYM_CONF_MAX_QUEUE > SYM_MEM_CLUSTER_SIZE/8
182 #undef SYM_CONF_MAX_QUEUE
183 #define SYM_CONF_MAX_QUEUE (SYM_MEM_CLUSTER_SIZE/8)
184 #undef SYM_CONF_MAX_START
185 #define SYM_CONF_MAX_START (SYM_CONF_MAX_QUEUE-2)
186 #endif
187 
188 /*
189  * For this one, we want a short name :-)
190  */
191 #define MAX_QUEUE SYM_CONF_MAX_QUEUE
192 
193 /*
194  * Common definitions for both bus space based and legacy IO methods.
195  */
196 
197 #define INB_OFF(np, o) ioread8(np->s.ioaddr + (o))
198 #define INW_OFF(np, o) ioread16(np->s.ioaddr + (o))
199 #define INL_OFF(np, o) ioread32(np->s.ioaddr + (o))
200 
201 #define OUTB_OFF(np, o, val) iowrite8((val), np->s.ioaddr + (o))
202 #define OUTW_OFF(np, o, val) iowrite16((val), np->s.ioaddr + (o))
203 #define OUTL_OFF(np, o, val) iowrite32((val), np->s.ioaddr + (o))
204 
205 #define INB(np, r) INB_OFF(np, offsetof(struct sym_reg, r))
206 #define INW(np, r) INW_OFF(np, offsetof(struct sym_reg, r))
207 #define INL(np, r) INL_OFF(np, offsetof(struct sym_reg, r))
208 
209 #define OUTB(np, r, v) OUTB_OFF(np, offsetof(struct sym_reg, r), (v))
210 #define OUTW(np, r, v) OUTW_OFF(np, offsetof(struct sym_reg, r), (v))
211 #define OUTL(np, r, v) OUTL_OFF(np, offsetof(struct sym_reg, r), (v))
212 
213 #define OUTONB(np, r, m) OUTB(np, r, INB(np, r) | (m))
214 #define OUTOFFB(np, r, m) OUTB(np, r, INB(np, r) & ~(m))
215 #define OUTONW(np, r, m) OUTW(np, r, INW(np, r) | (m))
216 #define OUTOFFW(np, r, m) OUTW(np, r, INW(np, r) & ~(m))
217 #define OUTONL(np, r, m) OUTL(np, r, INL(np, r) | (m))
218 #define OUTOFFL(np, r, m) OUTL(np, r, INL(np, r) & ~(m))
219 
220 /*
221  * We normally want the chip to have a consistent view
222  * of driver internal data structures when we restart it.
223  * Thus these macros.
224  */
225 #define OUTL_DSP(np, v) \
226  do { \
227  MEMORY_WRITE_BARRIER(); \
228  OUTL(np, nc_dsp, (v)); \
229  } while (0)
230 
231 #define OUTONB_STD() \
232  do { \
233  MEMORY_WRITE_BARRIER(); \
234  OUTONB(np, nc_dcntl, (STD|NOCOM)); \
235  } while (0)
236 
237 /*
238  * Command control block states.
239  */
240 #define HS_IDLE (0)
241 #define HS_BUSY (1)
242 #define HS_NEGOTIATE (2) /* sync/wide data transfer*/
243 #define HS_DISCONNECT (3) /* Disconnected by target */
244 #define HS_WAIT (4) /* waiting for resource */
245 
246 #define HS_DONEMASK (0x80)
247 #define HS_COMPLETE (4|HS_DONEMASK)
248 #define HS_SEL_TIMEOUT (5|HS_DONEMASK) /* Selection timeout */
249 #define HS_UNEXPECTED (6|HS_DONEMASK) /* Unexpected disconnect */
250 #define HS_COMP_ERR (7|HS_DONEMASK) /* Completed with error */
251 
252 /*
253  * Software Interrupt Codes
254  */
255 #define SIR_BAD_SCSI_STATUS (1)
256 #define SIR_SEL_ATN_NO_MSG_OUT (2)
257 #define SIR_MSG_RECEIVED (3)
258 #define SIR_MSG_WEIRD (4)
259 #define SIR_NEGO_FAILED (5)
260 #define SIR_NEGO_PROTO (6)
261 #define SIR_SCRIPT_STOPPED (7)
262 #define SIR_REJECT_TO_SEND (8)
263 #define SIR_SWIDE_OVERRUN (9)
264 #define SIR_SODL_UNDERRUN (10)
265 #define SIR_RESEL_NO_MSG_IN (11)
266 #define SIR_RESEL_NO_IDENTIFY (12)
267 #define SIR_RESEL_BAD_LUN (13)
268 #define SIR_TARGET_SELECTED (14)
269 #define SIR_RESEL_BAD_I_T_L (15)
270 #define SIR_RESEL_BAD_I_T_L_Q (16)
271 #define SIR_ABORT_SENT (17)
272 #define SIR_RESEL_ABORTED (18)
273 #define SIR_MSG_OUT_DONE (19)
274 #define SIR_COMPLETE_ERROR (20)
275 #define SIR_DATA_OVERRUN (21)
276 #define SIR_BAD_PHASE (22)
277 #if SYM_CONF_DMA_ADDRESSING_MODE == 2
278 #define SIR_DMAP_DIRTY (23)
279 #define SIR_MAX (23)
280 #else
281 #define SIR_MAX (22)
282 #endif
283 
284 /*
285  * Extended error bit codes.
286  * xerr_status field of struct sym_ccb.
287  */
288 #define XE_EXTRA_DATA (1) /* unexpected data phase */
289 #define XE_BAD_PHASE (1<<1) /* illegal phase (4/5) */
290 #define XE_PARITY_ERR (1<<2) /* unrecovered SCSI parity error */
291 #define XE_SODL_UNRUN (1<<3) /* ODD transfer in DATA OUT phase */
292 #define XE_SWIDE_OVRUN (1<<4) /* ODD transfer in DATA IN phase */
293 
294 /*
295  * Negotiation status.
296  * nego_status field of struct sym_ccb.
297  */
298 #define NS_SYNC (1)
299 #define NS_WIDE (2)
300 #define NS_PPR (3)
301 
302 /*
303  * A CCB hashed table is used to retrieve CCB address
304  * from DSA value.
305  */
306 #define CCB_HASH_SHIFT 8
307 #define CCB_HASH_SIZE (1UL << CCB_HASH_SHIFT)
308 #define CCB_HASH_MASK (CCB_HASH_SIZE-1)
309 #if 1
310 #define CCB_HASH_CODE(dsa) \
311  (((dsa) >> (_LGRU16_(sizeof(struct sym_ccb)))) & CCB_HASH_MASK)
312 #else
313 #define CCB_HASH_CODE(dsa) (((dsa) >> 9) & CCB_HASH_MASK)
314 #endif
315 
316 #if SYM_CONF_DMA_ADDRESSING_MODE == 2
317 /*
318  * We may want to use segment registers for 64 bit DMA.
319  * 16 segments registers -> up to 64 GB addressable.
320  */
321 #define SYM_DMAP_SHIFT (4)
322 #define SYM_DMAP_SIZE (1u<<SYM_DMAP_SHIFT)
323 #define SYM_DMAP_MASK (SYM_DMAP_SIZE-1)
324 #endif
325 
326 /*
327  * Device flags.
328  */
329 #define SYM_DISC_ENABLED (1)
330 #define SYM_TAGS_ENABLED (1<<1)
331 #define SYM_SCAN_BOOT_DISABLED (1<<2)
332 #define SYM_SCAN_LUNS_DISABLED (1<<3)
333 
334 /*
335  * Host adapter miscellaneous flags.
336  */
337 #define SYM_AVOID_BUS_RESET (1)
338 
339 /*
340  * Misc.
341  */
342 #define SYM_SNOOP_TIMEOUT (10000000)
343 #define BUS_8_BIT 0
344 #define BUS_16_BIT 1
345 
346 /*
347  * Gather negotiable parameters value
348  */
349 struct sym_trans {
352  unsigned int width:1;
353  unsigned int iu:1;
354  unsigned int dt:1;
355  unsigned int qas:1;
356  unsigned int check_nego:1;
357  unsigned int renego:2;
358 };
359 
360 /*
361  * Global TCB HEADER.
362  *
363  * Due to lack of indirect addressing on earlier NCR chips,
364  * this substructure is copied from the TCB to a global
365  * address after selection.
366  * For SYMBIOS chips that support LOAD/STORE this copy is
367  * not needed and thus not performed.
368  */
369 struct sym_tcbh {
370  /*
371  * Scripts bus addresses of LUN table accessed from scripts.
372  * LUN #0 is a special case, since multi-lun devices are rare,
373  * and we we want to speed-up the general case and not waste
374  * resources.
375  */
376  u32 luntbl_sa; /* bus address of this table */
377  u32 lun0_sa; /* bus address of LCB #0 */
378  /*
379  * Actual SYNC/WIDE IO registers value for this target.
380  * 'sval', 'wval' and 'uval' are read from SCRIPTS and
381  * so have alignment constraints.
382  */
383 /*0*/ u_char uval; /* -> SCNTL4 register */
384 /*1*/ u_char sval; /* -> SXFER io register */
386 /*3*/ u_char wval; /* -> SCNTL3 io register */
387 };
388 
389 /*
390  * Target Control Block
391  */
392 struct sym_tcb {
393  /*
394  * TCB header.
395  * Assumed at offset 0.
396  */
397 /*0*/ struct sym_tcbh head;
398 
399  /*
400  * LUN table used by the SCRIPTS processor.
401  * An array of bus addresses is used on reselection.
402  */
403  u32 *luntbl; /* LCBs bus address table */
404  int nlcb; /* Number of valid LCBs (including LUN #0) */
405 
406  /*
407  * LUN table used by the C code.
408  */
409  struct sym_lcb *lun0p; /* LCB of LUN #0 (usual case) */
410 #if SYM_CONF_MAX_LUN > 1
411  struct sym_lcb **lunmp; /* Other LCBs [1..MAX_LUN] */
412 #endif
413 
414 #ifdef SYM_HAVE_STCB
415  /*
416  * O/S specific data structure.
417  */
418  struct sym_stcb s;
419 #endif
420 
421  /* Transfer goal */
422  struct sym_trans tgoal;
423 
424  /* Last printed transfer speed */
426 
427  /*
428  * Keep track of the CCB used for the negotiation in order
429  * to ensure that only 1 negotiation is queued at a time.
430  */
431  struct sym_ccb * nego_cp; /* CCB used for the nego */
432 
433  /*
434  * Set when we want to reset the device.
435  */
437 
438  /*
439  * Other user settable limits and options.
440  * These limits are read from the NVRAM if present.
441  */
442  unsigned char usrflags;
443  unsigned char usr_period;
444  unsigned char usr_width;
445  unsigned short usrtags;
447 };
448 
449 /*
450  * Global LCB HEADER.
451  *
452  * Due to lack of indirect addressing on earlier NCR chips,
453  * this substructure is copied from the LCB to a global
454  * address after selection.
455  * For SYMBIOS chips that support LOAD/STORE this copy is
456  * not needed and thus not performed.
457  */
458 struct sym_lcbh {
459  /*
460  * SCRIPTS address jumped by SCRIPTS on reselection.
461  * For not probed logical units, this address points to
462  * SCRIPTS that deal with bad LU handling (must be at
463  * offset zero of the LCB for that reason).
464  */
465 /*0*/ u32 resel_sa;
466 
467  /*
468  * Task (bus address of a CCB) read from SCRIPTS that points
469  * to the unique ITL nexus allowed to be disconnected.
470  */
472 
473  /*
474  * Task table bus address (read from SCRIPTS).
475  */
477 };
478 
479 /*
480  * Logical Unit Control Block
481  */
482 struct sym_lcb {
483  /*
484  * TCB header.
485  * Assumed at offset 0.
486  */
487 /*0*/ struct sym_lcbh head;
488 
489  /*
490  * Task table read from SCRIPTS that contains pointers to
491  * ITLQ nexuses. The bus address read from SCRIPTS is
492  * inside the header.
493  */
494  u32 *itlq_tbl; /* Kernel virtual address */
495 
496  /*
497  * Busy CCBs management.
498  */
499  u_short busy_itlq; /* Number of busy tagged CCBs */
500  u_short busy_itl; /* Number of busy untagged CCBs */
501 
502  /*
503  * Circular tag allocation buffer.
504  */
505  u_short ia_tag; /* Tag allocation index */
506  u_short if_tag; /* Tag release index */
507  u_char *cb_tags; /* Circular tags buffer */
508 
509  /*
510  * O/S specific data structure.
511  */
512 #ifdef SYM_HAVE_SLCB
513  struct sym_slcb s;
514 #endif
515 
516 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
517  /*
518  * Optionnaly the driver can handle device queueing,
519  * and requeues internally command to redo.
520  */
521  SYM_QUEHEAD waiting_ccbq;
522  SYM_QUEHEAD started_ccbq;
523  int num_sgood;
524  u_short started_tags;
525  u_short started_no_tag;
526  u_short started_max;
527  u_short started_limit;
528 #endif
529 
530 #ifdef SYM_OPT_LIMIT_COMMAND_REORDERING
531  /*
532  * Optionally the driver can try to prevent SCSI
533  * IOs from being reordered too much.
534  */
535  u_char tags_si; /* Current index to tags sum */
536  u_short tags_sum[2]; /* Tags sum counters */
537  u_short tags_since; /* # of tags since last switch */
538 #endif
539 
540  /*
541  * Set when we want to clear all tasks.
542  */
544 
545  /*
546  * Capabilities.
547  */
550 };
551 
552 /*
553  * Action from SCRIPTS on a task.
554  * Is part of the CCB, but is also used separately to plug
555  * error handling action to perform from SCRIPTS.
556  */
557 struct sym_actscr {
558  u32 start; /* Jumped by SCRIPTS after selection */
559  u32 restart; /* Jumped by SCRIPTS on relection */
560 };
561 
562 /*
563  * Phase mismatch context.
564  *
565  * It is part of the CCB and is used as parameters for the
566  * DATA pointer. We need two contexts to handle correctly the
567  * SAVED DATA POINTER.
568  */
569 struct sym_pmc {
570  struct sym_tblmove sg; /* Updated interrupted SG block */
571  u32 ret; /* SCRIPT return address */
572 };
573 
574 /*
575  * LUN control block lookup.
576  * We use a direct pointer for LUN #0, and a table of
577  * pointers which is only allocated for devices that support
578  * LUN(s) > 0.
579  */
580 #if SYM_CONF_MAX_LUN <= 1
581 #define sym_lp(tp, lun) (!lun) ? (tp)->lun0p : NULL
582 #else
583 #define sym_lp(tp, lun) \
584  (!lun) ? (tp)->lun0p : (tp)->lunmp ? (tp)->lunmp[(lun)] : NULL
585 #endif
586 
587 /*
588  * Status are used by the host and the script processor.
589  *
590  * The last four bytes (status[4]) are copied to the
591  * scratchb register (declared as scr0..scr3) just after the
592  * select/reselect, and copied back just after disconnecting.
593  * Inside the script the XX_REG are used.
594  */
595 
596 /*
597  * Last four bytes (script)
598  */
599 #define HX_REG scr0
600 #define HX_PRT nc_scr0
601 #define HS_REG scr1
602 #define HS_PRT nc_scr1
603 #define SS_REG scr2
604 #define SS_PRT nc_scr2
605 #define HF_REG scr3
606 #define HF_PRT nc_scr3
607 
608 /*
609  * Last four bytes (host)
610  */
611 #define host_xflags phys.head.status[0]
612 #define host_status phys.head.status[1]
613 #define ssss_status phys.head.status[2]
614 #define host_flags phys.head.status[3]
615 
616 /*
617  * Host flags
618  */
619 #define HF_IN_PM0 1u
620 #define HF_IN_PM1 (1u<<1)
621 #define HF_ACT_PM (1u<<2)
622 #define HF_DP_SAVED (1u<<3)
623 #define HF_SENSE (1u<<4)
624 #define HF_EXT_ERR (1u<<5)
625 #define HF_DATA_IN (1u<<6)
626 #ifdef SYM_CONF_IARB_SUPPORT
627 #define HF_HINT_IARB (1u<<7)
628 #endif
629 
630 /*
631  * More host flags
632  */
633 #if SYM_CONF_DMA_ADDRESSING_MODE == 2
634 #define HX_DMAP_DIRTY (1u<<7)
635 #endif
636 
637 /*
638  * Global CCB HEADER.
639  *
640  * Due to lack of indirect addressing on earlier NCR chips,
641  * this substructure is copied from the ccb to a global
642  * address after selection (or reselection) and copied back
643  * before disconnect.
644  * For SYMBIOS chips that support LOAD/STORE this copy is
645  * not needed and thus not performed.
646  */
647 
648 struct sym_ccbh {
649  /*
650  * Start and restart SCRIPTS addresses (must be at 0).
651  */
652 /*0*/ struct sym_actscr go;
653 
654  /*
655  * SCRIPTS jump address that deal with data pointers.
656  * 'savep' points to the position in the script responsible
657  * for the actual transfer of data.
658  * It's written on reception of a SAVE_DATA_POINTER message.
659  */
660  u32 savep; /* Jump address to saved data pointer */
661  u32 lastp; /* SCRIPTS address at end of data */
662 
663  /*
664  * Status fields.
665  */
666  u8 status[4];
667 };
668 
669 /*
670  * GET/SET the value of the data pointer used by SCRIPTS.
671  *
672  * We must distinguish between the LOAD/STORE-based SCRIPTS
673  * that use directly the header in the CCB, and the NCR-GENERIC
674  * SCRIPTS that use the copy of the header in the HCB.
675  */
676 #if SYM_CONF_GENERIC_SUPPORT
677 #define sym_set_script_dp(np, cp, dp) \
678  do { \
679  if (np->features & FE_LDSTR) \
680  cp->phys.head.lastp = cpu_to_scr(dp); \
681  else \
682  np->ccb_head.lastp = cpu_to_scr(dp); \
683  } while (0)
684 #define sym_get_script_dp(np, cp) \
685  scr_to_cpu((np->features & FE_LDSTR) ? \
686  cp->phys.head.lastp : np->ccb_head.lastp)
687 #else
688 #define sym_set_script_dp(np, cp, dp) \
689  do { \
690  cp->phys.head.lastp = cpu_to_scr(dp); \
691  } while (0)
692 
693 #define sym_get_script_dp(np, cp) (cp->phys.head.lastp)
694 #endif
695 
696 /*
697  * Data Structure Block
698  *
699  * During execution of a ccb by the script processor, the
700  * DSA (data structure address) register points to this
701  * substructure of the ccb.
702  */
703 struct sym_dsb {
704  /*
705  * CCB header.
706  * Also assumed at offset 0 of the sym_ccb structure.
707  */
708 /*0*/ struct sym_ccbh head;
709 
710  /*
711  * Phase mismatch contexts.
712  * We need two to handle correctly the SAVED DATA POINTER.
713  * MUST BOTH BE AT OFFSET < 256, due to using 8 bit arithmetic
714  * for address calculation from SCRIPTS.
715  */
716  struct sym_pmc pm0;
717  struct sym_pmc pm1;
718 
719  /*
720  * Table data for Script
721  */
725  struct sym_tblmove cmd;
729 };
730 
731 /*
732  * Our Command Control Block
733  */
734 struct sym_ccb {
735  /*
736  * This is the data structure which is pointed by the DSA
737  * register when it is executed by the script processor.
738  * It must be the first entry.
739  */
740  struct sym_dsb phys;
741 
742  /*
743  * Pointer to CAM ccb and related stuff.
744  */
745  struct scsi_cmnd *cmd; /* CAM scsiio ccb */
746  u8 cdb_buf[16]; /* Copy of CDB */
747 #define SYM_SNS_BBUF_LEN 32
748  u8 sns_bbuf[SYM_SNS_BBUF_LEN]; /* Bounce buffer for sense data */
749  int data_len; /* Total data length */
750  int segments; /* Number of SG segments */
751 
752  u8 order; /* Tag type (if tagged command) */
753  unsigned char odd_byte_adjustment; /* odd-sized req on wide bus */
754 
755  u_char nego_status; /* Negotiation status */
756  u_char xerr_status; /* Extended error flags */
757  u32 extra_bytes; /* Extraneous bytes transferred */
758 
759  /*
760  * Message areas.
761  * We prepare a message to be sent after selection.
762  * We may use a second one if the command is rescheduled
763  * due to CHECK_CONDITION or COMMAND TERMINATED.
764  * Contents are IDENTIFY and SIMPLE_TAG.
765  * While negotiating sync or wide transfer,
766  * a SDTR or WDTR message is appended.
767  */
770 
771  /*
772  * Auto request sense related fields.
773  */
774  u_char sensecmd[6]; /* Request Sense command */
775  u_char sv_scsi_status; /* Saved SCSI status */
776  u_char sv_xerr_status; /* Saved extended status */
777  int sv_resid; /* Saved residual */
778 
779  /*
780  * Other fields.
781  */
782  u32 ccb_ba; /* BUS address of this CCB */
783  u_short tag; /* Tag for this transfer */
784  /* NO_TAG means no tag */
787  struct sym_ccb *link_ccbh; /* Host adapter CCB hash chain */
788  SYM_QUEHEAD link_ccbq; /* Link to free/busy CCB queue */
789  u32 startp; /* Initial data pointer */
790  u32 goalp; /* Expected last data pointer */
791  int ext_sg; /* Extreme data pointer, used */
792  int ext_ofs; /* to calculate the residual. */
793 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
794  SYM_QUEHEAD link2_ccbq; /* Link for device queueing */
795  u_char started; /* CCB queued to the squeue */
796 #endif
797  u_char to_abort; /* Want this IO to be aborted */
798 #ifdef SYM_OPT_LIMIT_COMMAND_REORDERING
799  u_char tags_si; /* Lun tags sum index (0,1) */
800 #endif
801 };
802 
803 #define CCB_BA(cp,lbl) cpu_to_scr(cp->ccb_ba + offsetof(struct sym_ccb, lbl))
804 
805 typedef struct device *m_pool_ident_t;
806 
807 /*
808  * Host Control Block
809  */
810 struct sym_hcb {
811  /*
812  * Global headers.
813  * Due to poorness of addressing capabilities, earlier
814  * chips (810, 815, 825) copy part of the data structures
815  * (CCB, TCB and LCB) in fixed areas.
816  */
817 #if SYM_CONF_GENERIC_SUPPORT
818  struct sym_ccbh ccb_head;
819  struct sym_tcbh tcb_head;
820  struct sym_lcbh lcb_head;
821 #endif
822  /*
823  * Idle task and invalid task actions and
824  * their bus addresses.
825  */
826  struct sym_actscr idletask, notask, bad_itl, bad_itlq;
828 
829  /*
830  * Dummy lun table to protect us against target
831  * returning bad lun number on reselection.
832  */
833  u32 *badluntbl; /* Table physical address */
834  u32 badlun_sa; /* SCRIPT handler BUS address */
835 
836  /*
837  * Bus address of this host control block.
838  */
840 
841  /*
842  * Bit 32-63 of the on-chip RAM bus address in LE format.
843  * The START_RAM64 script loads the MMRS and MMWS from this
844  * field.
845  */
847 
848  /*
849  * Initial value of some IO register bits.
850  * These values are assumed to have been set by BIOS, and may
851  * be used to probe adapter implementation differences.
852  */
855  sv_stest1;
856 
857  /*
858  * Actual initial value of IO register bits used by the
859  * driver. They are loaded at initialisation according to
860  * features that are to be enabled/disabled.
861  */
864 
865  /*
866  * Target data.
867  */
869 
870  /*
871  * Target control block bus address array used by the SCRIPT
872  * on reselection.
873  */
876 
877  /*
878  * DMA pool handle for this HBA.
879  */
880  m_pool_ident_t bus_dmat;
881 
882  /*
883  * O/S specific data structure
884  */
885  struct sym_shcb s;
886 
887  /*
888  * Physical bus addresses of the chip.
889  */
890  u32 mmio_ba; /* MMIO 32 bit BUS address */
891  u32 ram_ba; /* RAM 32 bit BUS address */
892 
893  /*
894  * SCRIPTS virtual and physical bus addresses.
895  * 'script' is loaded in the on-chip RAM if present.
896  * 'scripth' stays in main memory for all chips except the
897  * 53C895A, 53C896 and 53C1010 that provide 8K on-chip RAM.
898  */
899  u_char *scripta0; /* Copy of scripts A, B, Z */
902  u32 scripta_ba; /* Actual scripts A, B, Z */
903  u32 scriptb_ba; /* 32 bit bus addresses. */
905  u_short scripta_sz; /* Actual size of script A, B, Z*/
908 
909  /*
910  * Bus addresses, setup and patch methods for
911  * the selected firmware.
912  */
913  struct sym_fwa_ba fwa_bas; /* Useful SCRIPTA bus addresses */
914  struct sym_fwb_ba fwb_bas; /* Useful SCRIPTB bus addresses */
915  struct sym_fwz_ba fwz_bas; /* Useful SCRIPTZ bus addresses */
916  void (*fw_setup)(struct sym_hcb *np, struct sym_fw *fw);
917  void (*fw_patch)(struct Scsi_Host *);
918  char *fw_name;
919 
920  /*
921  * General controller parameters and configuration.
922  */
923  u_int features; /* Chip features map */
924  u_char myaddr; /* SCSI id of the adapter */
925  u_char maxburst; /* log base 2 of dwords burst */
926  u_char maxwide; /* Maximum transfer width */
927  u_char minsync; /* Min sync period factor (ST) */
928  u_char maxsync; /* Max sync period factor (ST) */
929  u_char maxoffs; /* Max scsi offset (ST) */
930  u_char minsync_dt; /* Min sync period factor (DT) */
931  u_char maxsync_dt; /* Max sync period factor (DT) */
932  u_char maxoffs_dt; /* Max scsi offset (DT) */
933  u_char multiplier; /* Clock multiplier (1,2,4) */
934  u_char clock_divn; /* Number of clock divisors */
935  u32 clock_khz; /* SCSI clock frequency in KHz */
936  u32 pciclk_khz; /* Estimated PCI clock in KHz */
937  /*
938  * Start queue management.
939  * It is filled up by the host processor and accessed by the
940  * SCRIPTS processor in order to start SCSI commands.
941  */
942  volatile /* Prevent code optimizations */
943  u32 *squeue; /* Start queue virtual address */
944  u32 squeue_ba; /* Start queue BUS address */
945  u_short squeueput; /* Next free slot of the queue */
946  u_short actccbs; /* Number of allocated CCBs */
947 
948  /*
949  * Command completion queue.
950  * It is the same size as the start queue to avoid overflow.
951  */
952  u_short dqueueget; /* Next position to scan */
953  volatile /* Prevent code optimizations */
954  u32 *dqueue; /* Completion (done) queue */
955  u32 dqueue_ba; /* Done queue BUS address */
956 
957  /*
958  * Miscellaneous buffers accessed by the scripts-processor.
959  * They shall be DWORD aligned, because they may be read or
960  * written with a script command.
961  */
962  u_char msgout[8]; /* Buffer for MESSAGE OUT */
963  u_char msgin [8]; /* Buffer for MESSAGE IN */
964  u32 lastmsg; /* Last SCSI message sent */
965  u32 scratch; /* Scratch for SCSI receive */
966  /* Also used for cache test */
967  /*
968  * Miscellaneous configuration and status parameters.
969  */
970  u_char usrflags; /* Miscellaneous user flags */
971  u_char scsi_mode; /* Current SCSI BUS mode */
972  u_char verbose; /* Verbosity for this controller*/
973 
974  /*
975  * CCB lists and queue.
976  */
977  struct sym_ccb **ccbh; /* CCBs hashed by DSA value */
978  /* CCB_HASH_SIZE lists of CCBs */
979  SYM_QUEHEAD free_ccbq; /* Queue of available CCBs */
980  SYM_QUEHEAD busy_ccbq; /* Queue of busy CCBs */
981 
982  /*
983  * During error handling and/or recovery,
984  * active CCBs that are to be completed with
985  * error or requeued are moved from the busy_ccbq
986  * to the comp_ccbq prior to completion.
987  */
989 
990 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
991  SYM_QUEHEAD dummy_ccbq;
992 #endif
993 
994  /*
995  * IMMEDIATE ARBITRATION (IARB) control.
996  *
997  * We keep track in 'last_cp' of the last CCB that has been
998  * queued to the SCRIPTS processor and clear 'last_cp' when
999  * this CCB completes. If last_cp is not zero at the moment
1000  * we queue a new CCB, we set a flag in 'last_cp' that is
1001  * used by the SCRIPTS as a hint for setting IARB.
1002  * We donnot set more than 'iarb_max' consecutive hints for
1003  * IARB in order to leave devices a chance to reselect.
1004  * By the way, any non zero value of 'iarb_max' is unfair. :)
1005  */
1006 #ifdef SYM_CONF_IARB_SUPPORT
1007  u_short iarb_max; /* Max. # consecutive IARB hints*/
1008  u_short iarb_count; /* Actual # of these hints */
1009  struct sym_ccb * last_cp;
1010 #endif
1011 
1012  /*
1013  * Command abort handling.
1014  * We need to synchronize tightly with the SCRIPTS
1015  * processor in order to handle things correctly.
1016  */
1017  u_char abrt_msg[4]; /* Message to send buffer */
1018  struct sym_tblmove abrt_tbl; /* Table for the MOV of it */
1019  struct sym_tblsel abrt_sel; /* Sync params for selection */
1020  u_char istat_sem; /* Tells the chip to stop (SEM) */
1021 
1022  /*
1023  * 64 bit DMA handling.
1024  */
1025 #if SYM_CONF_DMA_ADDRESSING_MODE != 0
1026  u_char use_dac; /* Use PCI DAC cycles */
1027 #if SYM_CONF_DMA_ADDRESSING_MODE == 2
1028  u_char dmap_dirty; /* Dma segments registers dirty */
1029  u32 dmap_bah[SYM_DMAP_SIZE];/* Segment registers map */
1030 #endif
1031 #endif
1032 };
1033 
1034 #if SYM_CONF_DMA_ADDRESSING_MODE == 0
1035 #define use_dac(np) 0
1036 #define set_dac(np) do { } while (0)
1037 #else
1038 #define use_dac(np) (np)->use_dac
1039 #define set_dac(np) (np)->use_dac = 1
1040 #endif
1041 
1042 #define HCB_BA(np, lbl) (np->hcb_ba + offsetof(struct sym_hcb, lbl))
1043 
1044 
1045 /*
1046  * FIRMWARES (sym_fw.c)
1047  */
1048 struct sym_fw * sym_find_firmware(struct sym_chip *chip);
1049 void sym_fw_bind_script(struct sym_hcb *np, u32 *start, int len);
1050 
1051 /*
1052  * Driver methods called from O/S specific code.
1053  */
1054 char *sym_driver_name(void);
1055 void sym_print_xerr(struct scsi_cmnd *cmd, int x_status);
1056 int sym_reset_scsi_bus(struct sym_hcb *np, int enab_int);
1058 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
1059 void sym_start_next_ccbs(struct sym_hcb *np, struct sym_lcb *lp, int maxn);
1060 #else
1061 void sym_put_start_queue(struct sym_hcb *np, struct sym_ccb *cp);
1062 #endif
1063 void sym_start_up(struct Scsi_Host *, int reason);
1065 int sym_clear_tasks(struct sym_hcb *np, int cam_status, int target, int lun, int task);
1066 struct sym_ccb *sym_get_ccb(struct sym_hcb *np, struct scsi_cmnd *cmd, u_char tag_order);
1067 void sym_free_ccb(struct sym_hcb *np, struct sym_ccb *cp);
1068 struct sym_lcb *sym_alloc_lcb(struct sym_hcb *np, u_char tn, u_char ln);
1069 int sym_free_lcb(struct sym_hcb *np, u_char tn, u_char ln);
1070 int sym_queue_scsiio(struct sym_hcb *np, struct scsi_cmnd *csio, struct sym_ccb *cp);
1071 int sym_abort_scsiio(struct sym_hcb *np, struct scsi_cmnd *ccb, int timed_out);
1072 int sym_reset_scsi_target(struct sym_hcb *np, int target);
1073 void sym_hcb_free(struct sym_hcb *np);
1074 int sym_hcb_attach(struct Scsi_Host *shost, struct sym_fw *fw, struct sym_nvram *nvram);
1075 
1076 /*
1077  * Build a scatter/gather entry.
1078  *
1079  * For 64 bit systems, we use the 8 upper bits of the size field
1080  * to provide bus address bits 32-39 to the SCRIPTS processor.
1081  * This allows the 895A, 896, 1010 to address up to 1 TB of memory.
1082  */
1083 
1084 #if SYM_CONF_DMA_ADDRESSING_MODE == 0
1085 #define DMA_DAC_MASK DMA_BIT_MASK(32)
1086 #define sym_build_sge(np, data, badd, len) \
1087 do { \
1088  (data)->addr = cpu_to_scr(badd); \
1089  (data)->size = cpu_to_scr(len); \
1090 } while (0)
1091 #elif SYM_CONF_DMA_ADDRESSING_MODE == 1
1092 #define DMA_DAC_MASK DMA_BIT_MASK(40)
1093 #define sym_build_sge(np, data, badd, len) \
1094 do { \
1095  (data)->addr = cpu_to_scr(badd); \
1096  (data)->size = cpu_to_scr((((badd) >> 8) & 0xff000000) + len); \
1097 } while (0)
1098 #elif SYM_CONF_DMA_ADDRESSING_MODE == 2
1099 #define DMA_DAC_MASK DMA_BIT_MASK(64)
1100 int sym_lookup_dmap(struct sym_hcb *np, u32 h, int s);
1101 static inline void
1102 sym_build_sge(struct sym_hcb *np, struct sym_tblmove *data, u64 badd, int len)
1103 {
1104  u32 h = (badd>>32);
1105  int s = (h&SYM_DMAP_MASK);
1106 
1107  if (h != np->dmap_bah[s])
1108  goto bad;
1109 good:
1110  (data)->addr = cpu_to_scr(badd);
1111  (data)->size = cpu_to_scr((s<<24) + len);
1112  return;
1113 bad:
1114  s = sym_lookup_dmap(np, h, s);
1115  goto good;
1116 }
1117 #else
1118 #error "Unsupported DMA addressing mode"
1119 #endif
1120 
1121 /*
1122  * MEMORY ALLOCATOR.
1123  */
1124 
1125 #define sym_get_mem_cluster() \
1126  (void *) __get_free_pages(GFP_ATOMIC, SYM_MEM_PAGE_ORDER)
1127 #define sym_free_mem_cluster(p) \
1128  free_pages((unsigned long)p, SYM_MEM_PAGE_ORDER)
1129 
1130 /*
1131  * Link between free memory chunks of a given size.
1132  */
1133 typedef struct sym_m_link {
1134  struct sym_m_link *next;
1135 } *m_link_p;
1136 
1137 /*
1138  * Virtual to bus physical translation for a given cluster.
1139  * Such a structure is only useful with DMA abstraction.
1140  */
1141 typedef struct sym_m_vtob { /* Virtual to Bus address translation */
1142  struct sym_m_vtob *next;
1143  void *vaddr; /* Virtual address */
1144  dma_addr_t baddr; /* Bus physical address */
1145 } *m_vtob_p;
1146 
1147 /* Hash this stuff a bit to speed up translations */
1148 #define VTOB_HASH_SHIFT 5
1149 #define VTOB_HASH_SIZE (1UL << VTOB_HASH_SHIFT)
1150 #define VTOB_HASH_MASK (VTOB_HASH_SIZE-1)
1151 #define VTOB_HASH_CODE(m) \
1152  ((((unsigned long)(m)) >> SYM_MEM_CLUSTER_SHIFT) & VTOB_HASH_MASK)
1153 
1154 /*
1155  * Memory pool of a given kind.
1156  * Ideally, we want to use:
1157  * 1) 1 pool for memory we donnot need to involve in DMA.
1158  * 2) The same pool for controllers that require same DMA
1159  * constraints and features.
1160  * The OS specific m_pool_id_t thing and the sym_m_pool_match()
1161  * method are expected to tell the driver about.
1162  */
1163 typedef struct sym_m_pool {
1164  m_pool_ident_t dev_dmat; /* Identifies the pool (see above) */
1165  void * (*get_mem_cluster)(struct sym_m_pool *);
1166 #ifdef SYM_MEM_FREE_UNUSED
1167  void (*free_mem_cluster)(struct sym_m_pool *, void *);
1168 #endif
1169 #define M_GET_MEM_CLUSTER() mp->get_mem_cluster(mp)
1170 #define M_FREE_MEM_CLUSTER(p) mp->free_mem_cluster(mp, p)
1171  int nump;
1173  struct sym_m_pool *next;
1175 } *m_pool_p;
1176 
1177 /*
1178  * Alloc, free and translate addresses to bus physical
1179  * for DMAable memory.
1180  */
1181 void *__sym_calloc_dma(m_pool_ident_t dev_dmat, int size, char *name);
1182 void __sym_mfree_dma(m_pool_ident_t dev_dmat, void *m, int size, char *name);
1183 dma_addr_t __vtobus(m_pool_ident_t dev_dmat, void *m);
1184 
1185 /*
1186  * Verbs used by the driver code for DMAable memory handling.
1187  * The _uvptv_ macro avoids a nasty warning about pointer to volatile
1188  * being discarded.
1189  */
1190 #define _uvptv_(p) ((void *)((u_long)(p)))
1191 
1192 #define _sym_calloc_dma(np, l, n) __sym_calloc_dma(np->bus_dmat, l, n)
1193 #define _sym_mfree_dma(np, p, l, n) \
1194  __sym_mfree_dma(np->bus_dmat, _uvptv_(p), l, n)
1195 #define sym_calloc_dma(l, n) _sym_calloc_dma(np, l, n)
1196 #define sym_mfree_dma(p, l, n) _sym_mfree_dma(np, p, l, n)
1197 #define vtobus(p) __vtobus(np->bus_dmat, _uvptv_(p))
1198 
1199 /*
1200  * We have to provide the driver memory allocator with methods for
1201  * it to maintain virtual to bus physical address translations.
1202  */
1203 
1204 #define sym_m_pool_match(mp_id1, mp_id2) (mp_id1 == mp_id2)
1205 
1206 static inline void *sym_m_get_dma_mem_cluster(m_pool_p mp, m_vtob_p vbp)
1207 {
1208  void *vaddr = NULL;
1209  dma_addr_t baddr = 0;
1210 
1211  vaddr = dma_alloc_coherent(mp->dev_dmat, SYM_MEM_CLUSTER_SIZE, &baddr,
1212  GFP_ATOMIC);
1213  if (vaddr) {
1214  vbp->vaddr = vaddr;
1215  vbp->baddr = baddr;
1216  }
1217  return vaddr;
1218 }
1219 
1220 static inline void sym_m_free_dma_mem_cluster(m_pool_p mp, m_vtob_p vbp)
1221 {
1223  vbp->baddr);
1224 }
1225 
1226 #endif /* SYM_HIPD_H */