xref: /linux/drivers/scsi/sym53c8xx_2/sym_hipd.h (revision 75bf465f0bc33e9b776a46d6a1b9b990f5fb7c37)
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
sym_build_sge(struct sym_hcb * np,struct sym_tblmove * data,u64 badd,int len)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 
sym_m_get_dma_mem_cluster(m_pool_p mp,m_vtob_p vbp)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 
sym_m_free_dma_mem_cluster(m_pool_p mp,m_vtob_p vbp)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 */
1214