1 /*
2  * Copyright (C) 2016 Cavium, Inc.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of version 2 of the GNU General Public License
6  * as published by the Free Software Foundation.
7  */
8 
9 #ifndef __CPT_HW_TYPES_H
10 #define __CPT_HW_TYPES_H
11 
12 #include "cpt_common.h"
13 
14 /**
15  * Enumeration cpt_comp_e
16  *
17  * CPT Completion Enumeration
18  * Enumerates the values of CPT_RES_S[COMPCODE].
19  */
20 enum cpt_comp_e {
21 	CPT_COMP_E_NOTDONE = 0x00,
22 	CPT_COMP_E_GOOD = 0x01,
23 	CPT_COMP_E_FAULT = 0x02,
24 	CPT_COMP_E_SWERR = 0x03,
25 	CPT_COMP_E_LAST_ENTRY = 0xFF
26 };
27 
28 /**
29  * Structure cpt_inst_s
30  *
31  * CPT Instruction Structure
32  * This structure specifies the instruction layout. Instructions are
33  * stored in memory as little-endian unless CPT()_PF_Q()_CTL[INST_BE] is set.
34  * cpt_inst_s_s
35  * Word 0
36  * doneint:1 Done interrupt.
37  *	0 = No interrupts related to this instruction.
38  *	1 = When the instruction completes, CPT()_VQ()_DONE[DONE] will be
39  *	incremented,and based on the rules described there an interrupt may
40  *	occur.
41  * Word 1
42  * res_addr [127: 64] Result IOVA.
43  *	If nonzero, specifies where to write CPT_RES_S.
44  *	If zero, no result structure will be written.
45  *	Address must be 16-byte aligned.
46  *	Bits <63:49> are ignored by hardware; software should use a
47  *	sign-extended bit <48> for forward compatibility.
48  * Word 2
49  *  grp:10 [171:162] If [WQ_PTR] is nonzero, the SSO guest-group to use when
50  *	CPT submits work SSO.
51  *	For the SSO to not discard the add-work request, FPA_PF_MAP() must map
52  *	[GRP] and CPT()_PF_Q()_GMCTL[GMID] as valid.
53  *  tt:2 [161:160] If [WQ_PTR] is nonzero, the SSO tag type to use when CPT
54  *	submits work to SSO
55  *  tag:32 [159:128] If [WQ_PTR] is nonzero, the SSO tag to use when CPT
56  *	submits work to SSO.
57  * Word 3
58  *  wq_ptr [255:192] If [WQ_PTR] is nonzero, it is a pointer to a
59  *	work-queue entry that CPT submits work to SSO after all context,
60  *	output data, and result write operations are visible to other
61  *	CNXXXX units and the cores. Bits <2:0> must be zero.
62  *	Bits <63:49> are ignored by hardware; software should
63  *	use a sign-extended bit <48> for forward compatibility.
64  *	Internal:
65  *	Bits <63:49>, <2:0> are ignored by hardware, treated as always 0x0.
66  * Word 4
67  *  ei0; [319:256] Engine instruction word 0. Passed to the AE/SE.
68  * Word 5
69  *  ei1; [383:320] Engine instruction word 1. Passed to the AE/SE.
70  * Word 6
71  *  ei2; [447:384] Engine instruction word 1. Passed to the AE/SE.
72  * Word 7
73  *  ei3; [511:448] Engine instruction word 1. Passed to the AE/SE.
74  *
75  */
76 union cpt_inst_s {
77 	u64 u[8];
78 	struct cpt_inst_s_s {
79 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
80 		u64 reserved_17_63:47;
81 		u64 doneint:1;
82 		u64 reserved_0_1:16;
83 #else /* Word 0 - Little Endian */
84 		u64 reserved_0_15:16;
85 		u64 doneint:1;
86 		u64 reserved_17_63:47;
87 #endif /* Word 0 - End */
88 		u64 res_addr;
89 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 2 - Big Endian */
90 		u64 reserved_172_19:20;
91 		u64 grp:10;
92 		u64 tt:2;
93 		u64 tag:32;
94 #else /* Word 2 - Little Endian */
95 		u64 tag:32;
96 		u64 tt:2;
97 		u64 grp:10;
98 		u64 reserved_172_191:20;
99 #endif /* Word 2 - End */
100 		u64 wq_ptr;
101 		u64 ei0;
102 		u64 ei1;
103 		u64 ei2;
104 		u64 ei3;
105 	} s;
106 };
107 
108 /**
109  * Structure cpt_res_s
110  *
111  * CPT Result Structure
112  * The CPT coprocessor writes the result structure after it completes a
113  * CPT_INST_S instruction. The result structure is exactly 16 bytes, and
114  * each instruction completion produces exactly one result structure.
115  *
116  * This structure is stored in memory as little-endian unless
117  * CPT()_PF_Q()_CTL[INST_BE] is set.
118  * cpt_res_s_s
119  * Word 0
120  *  doneint:1 [16:16] Done interrupt. This bit is copied from the
121  *	corresponding instruction's CPT_INST_S[DONEINT].
122  *  compcode:8 [7:0] Indicates completion/error status of the CPT coprocessor
123  *	for the	associated instruction, as enumerated by CPT_COMP_E.
124  *	Core software may write the memory location containing [COMPCODE] to
125  *	0x0 before ringing the doorbell, and then poll for completion by
126  *	checking for a nonzero value.
127  *	Once the core observes a nonzero [COMPCODE] value in this case,the CPT
128  *	coprocessor will have also completed L2/DRAM write operations.
129  * Word 1
130  *  reserved
131  *
132  */
133 union cpt_res_s {
134 	u64 u[2];
135 	struct cpt_res_s_s {
136 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
137 		u64 reserved_17_63:47;
138 		u64 doneint:1;
139 		u64 reserved_8_15:8;
140 		u64 compcode:8;
141 #else /* Word 0 - Little Endian */
142 		u64 compcode:8;
143 		u64 reserved_8_15:8;
144 		u64 doneint:1;
145 		u64 reserved_17_63:47;
146 #endif /* Word 0 - End */
147 		u64 reserved_64_127;
148 	} s;
149 };
150 
151 /**
152  * Register (NCB) cpt#_pf_bist_status
153  *
154  * CPT PF Control Bist Status Register
155  * This register has the BIST status of memories. Each bit is the BIST result
156  * of an individual memory (per bit, 0 = pass and 1 = fail).
157  * cptx_pf_bist_status_s
158  * Word0
159  *  bstatus [29:0](RO/H) BIST status. One bit per memory, enumerated by
160  *	CPT_RAMS_E.
161  */
162 union cptx_pf_bist_status {
163 	u64 u;
164 	struct cptx_pf_bist_status_s {
165 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
166 		u64 reserved_30_63:34;
167 		u64 bstatus:30;
168 #else /* Word 0 - Little Endian */
169 		u64 bstatus:30;
170 		u64 reserved_30_63:34;
171 #endif /* Word 0 - End */
172 	} s;
173 };
174 
175 /**
176  * Register (NCB) cpt#_pf_constants
177  *
178  * CPT PF Constants Register
179  * This register contains implementation-related parameters of CPT in CNXXXX.
180  * cptx_pf_constants_s
181  * Word 0
182  *  reserved_40_63:24 [63:40] Reserved.
183  *  epcis:8 [39:32](RO) Number of EPCI busses.
184  *  grps:8 [31:24](RO) Number of engine groups implemented.
185  *  ae:8 [23:16](RO/H) Number of AEs. In CNXXXX, for CPT0 returns 0x0,
186  *	for CPT1 returns 0x18, or less if there are fuse-disables.
187  *  se:8 [15:8](RO/H) Number of SEs. In CNXXXX, for CPT0 returns 0x30,
188  *	or less if there are fuse-disables, for CPT1 returns 0x0.
189  *  vq:8 [7:0](RO) Number of VQs.
190  */
191 union cptx_pf_constants {
192 	u64 u;
193 	struct cptx_pf_constants_s {
194 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
195 		u64 reserved_40_63:24;
196 		u64 epcis:8;
197 		u64 grps:8;
198 		u64 ae:8;
199 		u64 se:8;
200 		u64 vq:8;
201 #else /* Word 0 - Little Endian */
202 		u64 vq:8;
203 		u64 se:8;
204 		u64 ae:8;
205 		u64 grps:8;
206 		u64 epcis:8;
207 		u64 reserved_40_63:24;
208 #endif /* Word 0 - End */
209 	} s;
210 };
211 
212 /**
213  * Register (NCB) cpt#_pf_exe_bist_status
214  *
215  * CPT PF Engine Bist Status Register
216  * This register has the BIST status of each engine.  Each bit is the
217  * BIST result of an individual engine (per bit, 0 = pass and 1 = fail).
218  * cptx_pf_exe_bist_status_s
219  * Word0
220  *  reserved_48_63:16 [63:48] reserved
221  *  bstatus:48 [47:0](RO/H) BIST status. One bit per engine.
222  *
223  */
224 union cptx_pf_exe_bist_status {
225 	u64 u;
226 	struct cptx_pf_exe_bist_status_s {
227 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
228 		u64 reserved_48_63:16;
229 		u64 bstatus:48;
230 #else /* Word 0 - Little Endian */
231 		u64 bstatus:48;
232 		u64 reserved_48_63:16;
233 #endif /* Word 0 - End */
234 	} s;
235 };
236 
237 /**
238  * Register (NCB) cpt#_pf_q#_ctl
239  *
240  * CPT Queue Control Register
241  * This register configures queues. This register should be changed only
242  * when quiescent (see CPT()_VQ()_INPROG[INFLIGHT]).
243  * cptx_pf_qx_ctl_s
244  * Word0
245  *  reserved_60_63:4 [63:60] reserved.
246  *  aura:12; [59:48](R/W) Guest-aura for returning this queue's
247  *	instruction-chunk buffers to FPA. Only used when [INST_FREE] is set.
248  *	For the FPA to not discard the request, FPA_PF_MAP() must map
249  *	[AURA] and CPT()_PF_Q()_GMCTL[GMID] as valid.
250  *  reserved_45_47:3 [47:45] reserved.
251  *  size:13 [44:32](R/W) Command-buffer size, in number of 64-bit words per
252  *	command buffer segment. Must be 8*n + 1, where n is the number of
253  *	instructions per buffer segment.
254  *  reserved_11_31:21 [31:11] Reserved.
255  *  cont_err:1 [10:10](R/W) Continue on error.
256  *	0 = When CPT()_VQ()_MISC_INT[NWRP], CPT()_VQ()_MISC_INT[IRDE] or
257  *	CPT()_VQ()_MISC_INT[DOVF] are set by hardware or software via
258  *	CPT()_VQ()_MISC_INT_W1S, then CPT()_VQ()_CTL[ENA] is cleared.  Due to
259  *	pipelining, additional instructions may have been processed between the
260  *	instruction causing the error and the next instruction in the disabled
261  *	queue (the instruction at CPT()_VQ()_SADDR).
262  *	1 = Ignore errors and continue processing instructions.
263  *	For diagnostic use only.
264  *  inst_free:1 [9:9](R/W) Instruction FPA free. When set, when CPT reaches the
265  *	end of an instruction chunk, that chunk will be freed to the FPA.
266  *  inst_be:1 [8:8](R/W) Instruction big-endian control. When set, instructions,
267  *	instruction next chunk pointers, and result structures are stored in
268  *	big-endian format in memory.
269  *  iqb_ldwb:1 [7:7](R/W) Instruction load don't write back.
270  *	0 = The hardware issues NCB transient load (LDT) towards the cache,
271  *	which if the line hits and is is dirty will cause the line to be
272  *	written back before being replaced.
273  *	1 = The hardware issues NCB LDWB read-and-invalidate command towards
274  *	the cache when fetching the last word of instructions; as a result the
275  *	line will not be written back when replaced.  This improves
276  *	performance, but software must not read the instructions after they are
277  *	posted to the hardware.	Reads that do not consume the last word of a
278  *	cache line always use LDI.
279  *  reserved_4_6:3 [6:4] Reserved.
280  *  grp:3; [3:1](R/W) Engine group.
281  *  pri:1; [0:0](R/W) Queue priority.
282  *	1 = This queue has higher priority. Round-robin between higher
283  *	priority queues.
284  *	0 = This queue has lower priority. Round-robin between lower
285  *	priority queues.
286  */
287 union cptx_pf_qx_ctl {
288 	u64 u;
289 	struct cptx_pf_qx_ctl_s {
290 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
291 		u64 reserved_60_63:4;
292 		u64 aura:12;
293 		u64 reserved_45_47:3;
294 		u64 size:13;
295 		u64 reserved_11_31:21;
296 		u64 cont_err:1;
297 		u64 inst_free:1;
298 		u64 inst_be:1;
299 		u64 iqb_ldwb:1;
300 		u64 reserved_4_6:3;
301 		u64 grp:3;
302 		u64 pri:1;
303 #else /* Word 0 - Little Endian */
304 		u64 pri:1;
305 		u64 grp:3;
306 		u64 reserved_4_6:3;
307 		u64 iqb_ldwb:1;
308 		u64 inst_be:1;
309 		u64 inst_free:1;
310 		u64 cont_err:1;
311 		u64 reserved_11_31:21;
312 		u64 size:13;
313 		u64 reserved_45_47:3;
314 		u64 aura:12;
315 		u64 reserved_60_63:4;
316 #endif /* Word 0 - End */
317 	} s;
318 };
319 
320 /**
321  * Register (NCB) cpt#_vq#_saddr
322  *
323  * CPT Queue Starting Buffer Address Registers
324  * These registers set the instruction buffer starting address.
325  * cptx_vqx_saddr_s
326  * Word0
327  *  reserved_49_63:15 [63:49] Reserved.
328  *  ptr:43 [48:6](R/W/H) Instruction buffer IOVA <48:6> (64-byte aligned).
329  *	When written, it is the initial buffer starting address; when read,
330  *	it is the next read pointer to be requested from L2C. The PTR field
331  *	is overwritten with the next pointer each time that the command buffer
332  *	segment is exhausted. New commands will then be read from the newly
333  *	specified command buffer pointer.
334  *  reserved_0_5:6 [5:0] Reserved.
335  *
336  */
337 union cptx_vqx_saddr {
338 	u64 u;
339 	struct cptx_vqx_saddr_s {
340 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
341 		u64 reserved_49_63:15;
342 		u64 ptr:43;
343 		u64 reserved_0_5:6;
344 #else /* Word 0 - Little Endian */
345 		u64 reserved_0_5:6;
346 		u64 ptr:43;
347 		u64 reserved_49_63:15;
348 #endif /* Word 0 - End */
349 	} s;
350 };
351 
352 /**
353  * Register (NCB) cpt#_vq#_misc_ena_w1s
354  *
355  * CPT Queue Misc Interrupt Enable Set Register
356  * This register sets interrupt enable bits.
357  * cptx_vqx_misc_ena_w1s_s
358  * Word0
359  * reserved_5_63:59 [63:5] Reserved.
360  * swerr:1 [4:4](R/W1S/H) Reads or sets enable for
361  *	CPT(0..1)_VQ(0..63)_MISC_INT[SWERR].
362  * nwrp:1 [3:3](R/W1S/H) Reads or sets enable for
363  *	CPT(0..1)_VQ(0..63)_MISC_INT[NWRP].
364  * irde:1 [2:2](R/W1S/H) Reads or sets enable for
365  *	CPT(0..1)_VQ(0..63)_MISC_INT[IRDE].
366  * dovf:1 [1:1](R/W1S/H) Reads or sets enable for
367  *	CPT(0..1)_VQ(0..63)_MISC_INT[DOVF].
368  * mbox:1 [0:0](R/W1S/H) Reads or sets enable for
369  *	CPT(0..1)_VQ(0..63)_MISC_INT[MBOX].
370  *
371  */
372 union cptx_vqx_misc_ena_w1s {
373 	u64 u;
374 	struct cptx_vqx_misc_ena_w1s_s {
375 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
376 		u64 reserved_5_63:59;
377 		u64 swerr:1;
378 		u64 nwrp:1;
379 		u64 irde:1;
380 		u64 dovf:1;
381 		u64 mbox:1;
382 #else /* Word 0 - Little Endian */
383 		u64 mbox:1;
384 		u64 dovf:1;
385 		u64 irde:1;
386 		u64 nwrp:1;
387 		u64 swerr:1;
388 		u64 reserved_5_63:59;
389 #endif /* Word 0 - End */
390 	} s;
391 };
392 
393 /**
394  * Register (NCB) cpt#_vq#_doorbell
395  *
396  * CPT Queue Doorbell Registers
397  * Doorbells for the CPT instruction queues.
398  * cptx_vqx_doorbell_s
399  * Word0
400  *  reserved_20_63:44 [63:20] Reserved.
401  *  dbell_cnt:20 [19:0](R/W/H) Number of instruction queue 64-bit words to add
402  *	to the CPT instruction doorbell count. Readback value is the the
403  *	current number of pending doorbell requests. If counter overflows
404  *	CPT()_VQ()_MISC_INT[DBELL_DOVF] is set. To reset the count back to
405  *	zero, write one to clear CPT()_VQ()_MISC_INT_ENA_W1C[DBELL_DOVF],
406  *	then write a value of 2^20 minus the read [DBELL_CNT], then write one
407  *	to CPT()_VQ()_MISC_INT_W1C[DBELL_DOVF] and
408  *	CPT()_VQ()_MISC_INT_ENA_W1S[DBELL_DOVF]. Must be a multiple of 8.
409  *	All CPT instructions are 8 words and require a doorbell count of
410  *	multiple of 8.
411  */
412 union cptx_vqx_doorbell {
413 	u64 u;
414 	struct cptx_vqx_doorbell_s {
415 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
416 		u64 reserved_20_63:44;
417 		u64 dbell_cnt:20;
418 #else /* Word 0 - Little Endian */
419 		u64 dbell_cnt:20;
420 		u64 reserved_20_63:44;
421 #endif /* Word 0 - End */
422 	} s;
423 };
424 
425 /**
426  * Register (NCB) cpt#_vq#_inprog
427  *
428  * CPT Queue In Progress Count Registers
429  * These registers contain the per-queue instruction in flight registers.
430  * cptx_vqx_inprog_s
431  * Word0
432  *  reserved_8_63:56 [63:8] Reserved.
433  *  inflight:8 [7:0](RO/H) Inflight count. Counts the number of instructions
434  *	for the VF for which CPT is fetching, executing or responding to
435  *	instructions. However this does not include any interrupts that are
436  *	awaiting software handling (CPT()_VQ()_DONE[DONE] != 0x0).
437  *	A queue may not be reconfigured until:
438  *	1. CPT()_VQ()_CTL[ENA] is cleared by software.
439  *	2. [INFLIGHT] is polled until equals to zero.
440  */
441 union cptx_vqx_inprog {
442 	u64 u;
443 	struct cptx_vqx_inprog_s {
444 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
445 		u64 reserved_8_63:56;
446 		u64 inflight:8;
447 #else /* Word 0 - Little Endian */
448 		u64 inflight:8;
449 		u64 reserved_8_63:56;
450 #endif /* Word 0 - End */
451 	} s;
452 };
453 
454 /**
455  * Register (NCB) cpt#_vq#_misc_int
456  *
457  * CPT Queue Misc Interrupt Register
458  * These registers contain the per-queue miscellaneous interrupts.
459  * cptx_vqx_misc_int_s
460  * Word 0
461  *  reserved_5_63:59 [63:5] Reserved.
462  *  swerr:1 [4:4](R/W1C/H) Software error from engines.
463  *  nwrp:1  [3:3](R/W1C/H) NCB result write response error.
464  *  irde:1  [2:2](R/W1C/H) Instruction NCB read response error.
465  *  dovf:1 [1:1](R/W1C/H) Doorbell overflow.
466  *  mbox:1 [0:0](R/W1C/H) PF to VF mailbox interrupt. Set when
467  *	CPT()_VF()_PF_MBOX(0) is written.
468  *
469  */
470 union cptx_vqx_misc_int {
471 	u64 u;
472 	struct cptx_vqx_misc_int_s {
473 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
474 		u64 reserved_5_63:59;
475 		u64 swerr:1;
476 		u64 nwrp:1;
477 		u64 irde:1;
478 		u64 dovf:1;
479 		u64 mbox:1;
480 #else /* Word 0 - Little Endian */
481 		u64 mbox:1;
482 		u64 dovf:1;
483 		u64 irde:1;
484 		u64 nwrp:1;
485 		u64 swerr:1;
486 		u64 reserved_5_63:59;
487 #endif /* Word 0 - End */
488 	} s;
489 };
490 
491 /**
492  * Register (NCB) cpt#_vq#_done_ack
493  *
494  * CPT Queue Done Count Ack Registers
495  * This register is written by software to acknowledge interrupts.
496  * cptx_vqx_done_ack_s
497  * Word0
498  *  reserved_20_63:44 [63:20] Reserved.
499  *  done_ack:20 [19:0](R/W/H) Number of decrements to CPT()_VQ()_DONE[DONE].
500  *	Reads CPT()_VQ()_DONE[DONE]. Written by software to acknowledge
501  *	interrupts. If CPT()_VQ()_DONE[DONE] is still nonzero the interrupt
502  *	will be re-sent if the conditions described in CPT()_VQ()_DONE[DONE]
503  *	are satisfied.
504  *
505  */
506 union cptx_vqx_done_ack {
507 	u64 u;
508 	struct cptx_vqx_done_ack_s {
509 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
510 		u64 reserved_20_63:44;
511 		u64 done_ack:20;
512 #else /* Word 0 - Little Endian */
513 		u64 done_ack:20;
514 		u64 reserved_20_63:44;
515 #endif /* Word 0 - End */
516 	} s;
517 };
518 
519 /**
520  * Register (NCB) cpt#_vq#_done
521  *
522  * CPT Queue Done Count Registers
523  * These registers contain the per-queue instruction done count.
524  * cptx_vqx_done_s
525  * Word0
526  *  reserved_20_63:44 [63:20] Reserved.
527  *  done:20 [19:0](R/W/H) Done count. When CPT_INST_S[DONEINT] set and that
528  *	instruction completes, CPT()_VQ()_DONE[DONE] is incremented when the
529  *	instruction finishes. Write to this field are for diagnostic use only;
530  *	instead software writes CPT()_VQ()_DONE_ACK with the number of
531  *	decrements for this field.
532  *	Interrupts are sent as follows:
533  *	* When CPT()_VQ()_DONE[DONE] = 0, then no results are pending, the
534  *	interrupt coalescing timer is held to zero, and an interrupt is not
535  *	sent.
536  *	* When CPT()_VQ()_DONE[DONE] != 0, then the interrupt coalescing timer
537  *	counts. If the counter is >= CPT()_VQ()_DONE_WAIT[TIME_WAIT]*1024, or
538  *	CPT()_VQ()_DONE[DONE] >= CPT()_VQ()_DONE_WAIT[NUM_WAIT], i.e. enough
539  *	time has passed or enough results have arrived, then the interrupt is
540  *	sent.
541  *	* When CPT()_VQ()_DONE_ACK is written (or CPT()_VQ()_DONE is written
542  *	but this is not typical), the interrupt coalescing timer restarts.
543  *	Note after decrementing this interrupt equation is recomputed,
544  *	for example if CPT()_VQ()_DONE[DONE] >= CPT()_VQ()_DONE_WAIT[NUM_WAIT]
545  *	and because the timer is zero, the interrupt will be resent immediately.
546  *	(This covers the race case between software acknowledging an interrupt
547  *	and a result returning.)
548  *	* When CPT()_VQ()_DONE_ENA_W1S[DONE] = 0, interrupts are not sent,
549  *	but the counting described above still occurs.
550  *	Since CPT instructions complete out-of-order, if software is using
551  *	completion interrupts the suggested scheme is to request a DONEINT on
552  *	each request, and when an interrupt arrives perform a "greedy" scan for
553  *	completions; even if a later command is acknowledged first this will
554  *	not result in missing a completion.
555  *	Software is responsible for making sure [DONE] does not overflow;
556  *	for example by insuring there are not more than 2^20-1 instructions in
557  *	flight that may request interrupts.
558  *
559  */
560 union cptx_vqx_done {
561 	u64 u;
562 	struct cptx_vqx_done_s {
563 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
564 		u64 reserved_20_63:44;
565 		u64 done:20;
566 #else /* Word 0 - Little Endian */
567 		u64 done:20;
568 		u64 reserved_20_63:44;
569 #endif /* Word 0 - End */
570 	} s;
571 };
572 
573 /**
574  * Register (NCB) cpt#_vq#_done_wait
575  *
576  * CPT Queue Done Interrupt Coalescing Wait Registers
577  * Specifies the per queue interrupt coalescing settings.
578  * cptx_vqx_done_wait_s
579  * Word0
580  *  reserved_48_63:16 [63:48] Reserved.
581  *  time_wait:16; [47:32](R/W) Time hold-off. When CPT()_VQ()_DONE[DONE] = 0
582  *	or CPT()_VQ()_DONE_ACK is written a timer is cleared. When the timer
583  *	reaches [TIME_WAIT]*1024 then interrupt coalescing ends.
584  *	see CPT()_VQ()_DONE[DONE]. If 0x0, time coalescing is disabled.
585  *  reserved_20_31:12 [31:20] Reserved.
586  *  num_wait:20 [19:0](R/W) Number of messages hold-off.
587  *	When CPT()_VQ()_DONE[DONE] >= [NUM_WAIT] then interrupt coalescing ends
588  *	see CPT()_VQ()_DONE[DONE]. If 0x0, same behavior as 0x1.
589  *
590  */
591 union cptx_vqx_done_wait {
592 	u64 u;
593 	struct cptx_vqx_done_wait_s {
594 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
595 		u64 reserved_48_63:16;
596 		u64 time_wait:16;
597 		u64 reserved_20_31:12;
598 		u64 num_wait:20;
599 #else /* Word 0 - Little Endian */
600 		u64 num_wait:20;
601 		u64 reserved_20_31:12;
602 		u64 time_wait:16;
603 		u64 reserved_48_63:16;
604 #endif /* Word 0 - End */
605 	} s;
606 };
607 
608 /**
609  * Register (NCB) cpt#_vq#_done_ena_w1s
610  *
611  * CPT Queue Done Interrupt Enable Set Registers
612  * Write 1 to these registers will enable the DONEINT interrupt for the queue.
613  * cptx_vqx_done_ena_w1s_s
614  * Word0
615  *  reserved_1_63:63 [63:1] Reserved.
616  *  done:1 [0:0](R/W1S/H) Write 1 will enable DONEINT for this queue.
617  *	Write 0 has no effect. Read will return the enable bit.
618  */
619 union cptx_vqx_done_ena_w1s {
620 	u64 u;
621 	struct cptx_vqx_done_ena_w1s_s {
622 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
623 		u64 reserved_1_63:63;
624 		u64 done:1;
625 #else /* Word 0 - Little Endian */
626 		u64 done:1;
627 		u64 reserved_1_63:63;
628 #endif /* Word 0 - End */
629 	} s;
630 };
631 
632 /**
633  * Register (NCB) cpt#_vq#_ctl
634  *
635  * CPT VF Queue Control Registers
636  * This register configures queues. This register should be changed (other than
637  * clearing [ENA]) only when quiescent (see CPT()_VQ()_INPROG[INFLIGHT]).
638  * cptx_vqx_ctl_s
639  * Word0
640  *  reserved_1_63:63 [63:1] Reserved.
641  *  ena:1 [0:0](R/W/H) Enables the logical instruction queue.
642  *	See also CPT()_PF_Q()_CTL[CONT_ERR] and	CPT()_VQ()_INPROG[INFLIGHT].
643  *	1 = Queue is enabled.
644  *	0 = Queue is disabled.
645  */
646 union cptx_vqx_ctl {
647 	u64 u;
648 	struct cptx_vqx_ctl_s {
649 #if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
650 		u64 reserved_1_63:63;
651 		u64 ena:1;
652 #else /* Word 0 - Little Endian */
653 		u64 ena:1;
654 		u64 reserved_1_63:63;
655 #endif /* Word 0 - End */
656 	} s;
657 };
658 #endif /*__CPT_HW_TYPES_H*/
659