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