xref: /illumos-gate/usr/src/uts/i86pc/io/immu_regs.c (revision 789dced6271483dc9a692ceb9c8e31f2b2f5da27)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Portions Copyright (c) 2010, Oracle and/or its affiliates.
23  * All rights reserved.
24  */
25 
26 /*
27  * immu_regs.c  - File that operates on a IMMU unit's regsiters
28  */
29 #include <sys/dditypes.h>
30 #include <sys/ddi.h>
31 #include <sys/archsystm.h>
32 #include <sys/x86_archext.h>
33 #include <sys/spl.h>
34 #include <sys/sysmacros.h>
35 #include <sys/immu.h>
36 #include <sys/cpu.h>
37 
38 #define	get_reg32(immu, offset)	ddi_get32((immu)->immu_regs_handle, \
39 		(uint32_t *)(immu->immu_regs_addr + (offset)))
40 #define	get_reg64(immu, offset)	ddi_get64((immu)->immu_regs_handle, \
41 		(uint64_t *)(immu->immu_regs_addr + (offset)))
42 #define	put_reg32(immu, offset, val)	ddi_put32\
43 		((immu)->immu_regs_handle, \
44 		(uint32_t *)(immu->immu_regs_addr + (offset)), val)
45 #define	put_reg64(immu, offset, val)	ddi_put64\
46 		((immu)->immu_regs_handle, \
47 		(uint64_t *)(immu->immu_regs_addr + (offset)), val)
48 
49 static void immu_regs_inv_wait(immu_inv_wait_t *iwp);
50 
51 struct immu_flushops immu_regs_flushops = {
52 	immu_regs_context_fsi,
53 	immu_regs_context_dsi,
54 	immu_regs_context_gbl,
55 	immu_regs_iotlb_psi,
56 	immu_regs_iotlb_dsi,
57 	immu_regs_iotlb_gbl,
58 	immu_regs_inv_wait
59 };
60 
61 /*
62  * wait max 60s for the hardware completion
63  */
64 #define	IMMU_MAX_WAIT_TIME		60000000
65 #define	wait_completion(immu, offset, getf, completion, status) \
66 { \
67 	clock_t stick = ddi_get_lbolt(); \
68 	clock_t ntick; \
69 	_NOTE(CONSTCOND) \
70 	while (1) { \
71 		status = getf(immu, offset); \
72 		ntick = ddi_get_lbolt(); \
73 		if (completion) { \
74 			break; \
75 		} \
76 		if (ntick - stick >= drv_usectohz(IMMU_MAX_WAIT_TIME)) { \
77 			ddi_err(DER_PANIC, NULL, \
78 			    "immu wait completion time out");		\
79 			/*NOTREACHED*/   \
80 		} else { \
81 			ht_pause();\
82 		}\
83 	}\
84 }
85 
86 static ddi_device_acc_attr_t immu_regs_attr = {
87 	DDI_DEVICE_ATTR_V0,
88 	DDI_NEVERSWAP_ACC,
89 	DDI_STRICTORDER_ACC,
90 };
91 
92 /*
93  * iotlb_flush()
94  *   flush the iotlb cache
95  */
96 static void
97 iotlb_flush(immu_t *immu, uint_t domain_id,
98     uint64_t addr, uint_t am, uint_t hint, immu_iotlb_inv_t type)
99 {
100 	uint64_t command = 0, iva = 0;
101 	uint_t iva_offset, iotlb_offset;
102 	uint64_t status = 0;
103 
104 	/* no lock needed since cap and excap fields are RDONLY */
105 	iva_offset = IMMU_ECAP_GET_IRO(immu->immu_regs_excap);
106 	iotlb_offset = iva_offset + 8;
107 
108 	/*
109 	 * prepare drain read/write command
110 	 */
111 	if (IMMU_CAP_GET_DWD(immu->immu_regs_cap)) {
112 		command |= TLB_INV_DRAIN_WRITE;
113 	}
114 
115 	if (IMMU_CAP_GET_DRD(immu->immu_regs_cap)) {
116 		command |= TLB_INV_DRAIN_READ;
117 	}
118 
119 	/*
120 	 * if the hardward doesn't support page selective invalidation, we
121 	 * will use domain type. Otherwise, use global type
122 	 */
123 	switch (type) {
124 	case IOTLB_PSI:
125 		command |= TLB_INV_PAGE | TLB_INV_IVT |
126 		    TLB_INV_DID(domain_id);
127 		iva = addr | am | TLB_IVA_HINT(hint);
128 		break;
129 	case IOTLB_DSI:
130 		command |= TLB_INV_DOMAIN | TLB_INV_IVT |
131 		    TLB_INV_DID(domain_id);
132 		break;
133 	case IOTLB_GLOBAL:
134 		command |= TLB_INV_GLOBAL | TLB_INV_IVT;
135 		break;
136 	default:
137 		ddi_err(DER_MODE, NULL, "%s: incorrect iotlb flush type",
138 		    immu->immu_name);
139 		return;
140 	}
141 
142 	if (iva)
143 		put_reg64(immu, iva_offset, iva);
144 	put_reg64(immu, iotlb_offset, command);
145 	wait_completion(immu, iotlb_offset, get_reg64,
146 	    (!(status & TLB_INV_IVT)), status);
147 }
148 
149 /*
150  * immu_regs_iotlb_psi()
151  *   iotlb page specific invalidation
152  */
153 /*ARGSUSED*/
154 void
155 immu_regs_iotlb_psi(immu_t *immu, uint_t did, uint64_t dvma, uint_t snpages,
156     uint_t hint, immu_inv_wait_t *iwp)
157 {
158 	int dvma_am;
159 	int npg_am;
160 	int max_am;
161 	int am;
162 	uint64_t align;
163 	int npages_left;
164 	int npages;
165 	int i;
166 
167 	if (!IMMU_CAP_GET_PSI(immu->immu_regs_cap)) {
168 		immu_regs_iotlb_dsi(immu, did, iwp);
169 		return;
170 	}
171 
172 	max_am = IMMU_CAP_GET_MAMV(immu->immu_regs_cap);
173 
174 	mutex_enter(&(immu->immu_regs_lock));
175 
176 	npages_left = snpages;
177 	for (i = 0; i < immu_flush_gran && npages_left > 0; i++) {
178 		/* First calculate alignment of DVMA */
179 
180 		if (dvma == 0) {
181 			dvma_am = max_am;
182 		} else {
183 			for (align = (1 << 12), dvma_am = 1;
184 			    (dvma & align) == 0; align <<= 1, dvma_am++)
185 				;
186 			dvma_am--;
187 		}
188 
189 		/* Calculate the npg_am */
190 		npages = npages_left;
191 		for (npg_am = 0, npages >>= 1; npages; npages >>= 1, npg_am++)
192 			;
193 
194 		am = MIN(max_am, MIN(dvma_am, npg_am));
195 
196 		iotlb_flush(immu, did, dvma, am, hint, IOTLB_PSI);
197 
198 		npages = (1 << am);
199 		npages_left -= npages;
200 		dvma += (npages * IMMU_PAGESIZE);
201 	}
202 
203 	if (npages_left) {
204 		iotlb_flush(immu, did, 0, 0, 0, IOTLB_DSI);
205 	}
206 	mutex_exit(&(immu->immu_regs_lock));
207 }
208 
209 /*
210  * immu_regs_iotlb_dsi()
211  *	domain specific invalidation
212  */
213 /*ARGSUSED*/
214 void
215 immu_regs_iotlb_dsi(immu_t *immu, uint_t domain_id, immu_inv_wait_t *iwp)
216 {
217 	mutex_enter(&(immu->immu_regs_lock));
218 	iotlb_flush(immu, domain_id, 0, 0, 0, IOTLB_DSI);
219 	mutex_exit(&(immu->immu_regs_lock));
220 }
221 
222 /*
223  * immu_regs_iotlb_gbl()
224  *     global iotlb invalidation
225  */
226 /*ARGSUSED*/
227 void
228 immu_regs_iotlb_gbl(immu_t *immu, immu_inv_wait_t *iwp)
229 {
230 	mutex_enter(&(immu->immu_regs_lock));
231 	iotlb_flush(immu, 0, 0, 0, 0, IOTLB_GLOBAL);
232 	mutex_exit(&(immu->immu_regs_lock));
233 }
234 
235 
236 static int
237 gaw2agaw(int gaw)
238 {
239 	int r, agaw;
240 
241 	r = (gaw - 12) % 9;
242 
243 	if (r == 0)
244 		agaw = gaw;
245 	else
246 		agaw = gaw + 9 - r;
247 
248 	if (agaw > 64)
249 		agaw = 64;
250 
251 	return (agaw);
252 }
253 
254 /*
255  * set_immu_agaw()
256  * 	calculate agaw for a IOMMU unit
257  */
258 static int
259 set_agaw(immu_t *immu)
260 {
261 	int mgaw, magaw, agaw;
262 	uint_t bitpos;
263 	int max_sagaw_mask, sagaw_mask, mask;
264 	int nlevels;
265 
266 	/*
267 	 * mgaw is the maximum guest address width.
268 	 * Addresses above this value will be
269 	 * blocked by the IOMMU unit.
270 	 * sagaw is a bitmask that lists all the
271 	 * AGAWs supported by this IOMMU unit.
272 	 */
273 	mgaw = IMMU_CAP_MGAW(immu->immu_regs_cap);
274 	sagaw_mask = IMMU_CAP_SAGAW(immu->immu_regs_cap);
275 
276 	magaw = gaw2agaw(mgaw);
277 
278 	/*
279 	 * Get bitpos corresponding to
280 	 * magaw
281 	 */
282 
283 	/*
284 	 * Maximum SAGAW is specified by
285 	 * Vt-d spec.
286 	 */
287 	max_sagaw_mask = ((1 << 5) - 1);
288 
289 	if (sagaw_mask > max_sagaw_mask) {
290 		ddi_err(DER_WARN, NULL, "%s: SAGAW bitmask (%x) "
291 		    "is larger than maximu SAGAW bitmask "
292 		    "(%x) specified by Intel Vt-d spec",
293 		    immu->immu_name, sagaw_mask, max_sagaw_mask);
294 		return (DDI_FAILURE);
295 	}
296 
297 	/*
298 	 * Find a supported AGAW <= magaw
299 	 *
300 	 *	sagaw_mask    bitpos   AGAW (bits)  nlevels
301 	 *	==============================================
302 	 *	0 0 0 0 1	0	30		2
303 	 *	0 0 0 1 0	1	39		3
304 	 *	0 0 1 0 0	2	48		4
305 	 *	0 1 0 0 0	3	57		5
306 	 *	1 0 0 0 0	4	64(66)		6
307 	 */
308 	mask = 1;
309 	nlevels = 0;
310 	agaw = 0;
311 	for (mask = 1, bitpos = 0; bitpos < 5;
312 	    bitpos++, mask <<= 1) {
313 		if (mask & sagaw_mask) {
314 			nlevels = bitpos + 2;
315 			agaw = 30 + (bitpos * 9);
316 		}
317 	}
318 
319 	/* calculated agaw can be > 64 */
320 	agaw = (agaw > 64) ? 64 : agaw;
321 
322 	if (agaw < 30 || agaw > magaw) {
323 		ddi_err(DER_WARN, NULL, "%s: Calculated AGAW (%d) "
324 		    "is outside valid limits [30,%d] specified by Vt-d spec "
325 		    "and magaw",  immu->immu_name, agaw, magaw);
326 		return (DDI_FAILURE);
327 	}
328 
329 	if (nlevels < 2 || nlevels > 6) {
330 		ddi_err(DER_WARN, NULL, "%s: Calculated pagetable "
331 		    "level (%d) is outside valid limits [2,6]",
332 		    immu->immu_name, nlevels);
333 		return (DDI_FAILURE);
334 	}
335 
336 	ddi_err(DER_LOG, NULL, "Calculated pagetable "
337 	    "level (%d), agaw = %d", nlevels, agaw);
338 
339 	immu->immu_dvma_nlevels = nlevels;
340 	immu->immu_dvma_agaw = agaw;
341 
342 	return (DDI_SUCCESS);
343 }
344 
345 static int
346 setup_regs(immu_t *immu)
347 {
348 	int error;
349 
350 	/*
351 	 * This lock may be acquired by the IOMMU interrupt handler
352 	 */
353 	mutex_init(&(immu->immu_regs_lock), NULL, MUTEX_DRIVER,
354 	    (void *)ipltospl(IMMU_INTR_IPL));
355 
356 	/*
357 	 * map the register address space
358 	 */
359 	error = ddi_regs_map_setup(immu->immu_dip, 0,
360 	    (caddr_t *)&(immu->immu_regs_addr), (offset_t)0,
361 	    (offset_t)IMMU_REGSZ, &immu_regs_attr,
362 	    &(immu->immu_regs_handle));
363 
364 	if (error == DDI_FAILURE) {
365 		ddi_err(DER_WARN, NULL, "%s: Intel IOMMU register map failed",
366 		    immu->immu_name);
367 		mutex_destroy(&(immu->immu_regs_lock));
368 		return (DDI_FAILURE);
369 	}
370 
371 	/*
372 	 * get the register value
373 	 */
374 	immu->immu_regs_cap = get_reg64(immu, IMMU_REG_CAP);
375 	immu->immu_regs_excap = get_reg64(immu, IMMU_REG_EXCAP);
376 
377 	/*
378 	 * if the hardware access is non-coherent, we need clflush
379 	 */
380 	if (IMMU_ECAP_GET_C(immu->immu_regs_excap)) {
381 		immu->immu_dvma_coherent = B_TRUE;
382 	} else {
383 		immu->immu_dvma_coherent = B_FALSE;
384 		if (!is_x86_feature(x86_featureset, X86FSET_CLFSH)) {
385 			ddi_err(DER_WARN, NULL,
386 			    "immu unit %s can't be enabled due to "
387 			    "missing clflush functionality", immu->immu_name);
388 			ddi_regs_map_free(&(immu->immu_regs_handle));
389 			mutex_destroy(&(immu->immu_regs_lock));
390 			return (DDI_FAILURE);
391 		}
392 	}
393 
394 	/* Setup SNP and TM reserved fields */
395 	immu->immu_SNP_reserved = immu_regs_is_SNP_reserved(immu);
396 	immu->immu_TM_reserved = immu_regs_is_TM_reserved(immu);
397 
398 	if (IMMU_ECAP_GET_CH(immu->immu_regs_excap) && immu_use_tm)
399 		immu->immu_ptemask = PDTE_MASK_TM;
400 	else
401 		immu->immu_ptemask = 0;
402 
403 	/*
404 	 * Check for Mobile 4 series chipset
405 	 */
406 	if (immu_quirk_mobile4 == B_TRUE &&
407 	    !IMMU_CAP_GET_RWBF(immu->immu_regs_cap)) {
408 		ddi_err(DER_LOG, NULL,
409 		    "IMMU: Mobile 4 chipset quirk detected. "
410 		    "Force-setting RWBF");
411 		IMMU_CAP_SET_RWBF(immu->immu_regs_cap);
412 	}
413 
414 	/*
415 	 * retrieve the maximum number of domains
416 	 */
417 	immu->immu_max_domains = IMMU_CAP_ND(immu->immu_regs_cap);
418 
419 	/*
420 	 * calculate the agaw
421 	 */
422 	if (set_agaw(immu) != DDI_SUCCESS) {
423 		ddi_regs_map_free(&(immu->immu_regs_handle));
424 		mutex_destroy(&(immu->immu_regs_lock));
425 		return (DDI_FAILURE);
426 	}
427 	immu->immu_regs_cmdval = 0;
428 
429 	immu->immu_flushops = &immu_regs_flushops;
430 
431 	return (DDI_SUCCESS);
432 }
433 
434 /* ############### Functions exported ################## */
435 
436 /*
437  * immu_regs_setup()
438  *       Setup mappings to a IMMU unit's registers
439  *       so that they can be read/written
440  */
441 void
442 immu_regs_setup(list_t *listp)
443 {
444 	int i;
445 	immu_t *immu;
446 
447 	for (i = 0; i < IMMU_MAXSEG; i++) {
448 		immu = list_head(listp);
449 		for (; immu; immu = list_next(listp, immu)) {
450 			/* do your best, continue on error */
451 			if (setup_regs(immu) != DDI_SUCCESS) {
452 				immu->immu_regs_setup = B_FALSE;
453 			} else {
454 				immu->immu_regs_setup = B_TRUE;
455 			}
456 		}
457 	}
458 }
459 
460 /*
461  * immu_regs_map()
462  */
463 int
464 immu_regs_resume(immu_t *immu)
465 {
466 	int error;
467 
468 	/*
469 	 * remap the register address space
470 	 */
471 	error = ddi_regs_map_setup(immu->immu_dip, 0,
472 	    (caddr_t *)&(immu->immu_regs_addr), (offset_t)0,
473 	    (offset_t)IMMU_REGSZ, &immu_regs_attr,
474 	    &(immu->immu_regs_handle));
475 	if (error != DDI_SUCCESS) {
476 		return (DDI_FAILURE);
477 	}
478 
479 	immu_regs_set_root_table(immu);
480 
481 	immu_regs_intr_enable(immu, immu->immu_regs_intr_msi_addr,
482 	    immu->immu_regs_intr_msi_data, immu->immu_regs_intr_uaddr);
483 
484 	(void) immu_intr_handler(immu);
485 
486 	immu_regs_intrmap_enable(immu, immu->immu_intrmap_irta_reg);
487 
488 	immu_regs_qinv_enable(immu, immu->immu_qinv_reg_value);
489 
490 
491 	return (error);
492 }
493 
494 /*
495  * immu_regs_suspend()
496  */
497 void
498 immu_regs_suspend(immu_t *immu)
499 {
500 
501 	immu->immu_intrmap_running = B_FALSE;
502 
503 	/* Finally, unmap the regs */
504 	ddi_regs_map_free(&(immu->immu_regs_handle));
505 }
506 
507 /*
508  * immu_regs_startup()
509  *	set a IMMU unit's registers to startup the unit
510  */
511 void
512 immu_regs_startup(immu_t *immu)
513 {
514 	uint32_t status;
515 
516 	if (immu->immu_regs_setup == B_FALSE) {
517 		return;
518 	}
519 
520 	mutex_enter(&(immu->immu_regs_lock));
521 	put_reg32(immu, IMMU_REG_GLOBAL_CMD,
522 	    immu->immu_regs_cmdval | IMMU_GCMD_TE);
523 	wait_completion(immu, IMMU_REG_GLOBAL_STS,
524 	    get_reg32, (status & IMMU_GSTS_TES), status);
525 	immu->immu_regs_cmdval |= IMMU_GCMD_TE;
526 	immu->immu_regs_running = B_TRUE;
527 	mutex_exit(&(immu->immu_regs_lock));
528 
529 	ddi_err(DER_NOTE, NULL, "%s running", immu->immu_name);
530 }
531 
532 /*
533  * immu_regs_shutdown()
534  *	shutdown a unit
535  */
536 void
537 immu_regs_shutdown(immu_t *immu)
538 {
539 	uint32_t status;
540 
541 	if (immu->immu_regs_running == B_FALSE) {
542 		return;
543 	}
544 
545 	mutex_enter(&(immu->immu_regs_lock));
546 	immu->immu_regs_cmdval &= ~IMMU_GCMD_TE;
547 	put_reg32(immu, IMMU_REG_GLOBAL_CMD,
548 	    immu->immu_regs_cmdval);
549 	wait_completion(immu, IMMU_REG_GLOBAL_STS,
550 	    get_reg32, !(status & IMMU_GSTS_TES), status);
551 	immu->immu_regs_running = B_FALSE;
552 	mutex_exit(&(immu->immu_regs_lock));
553 
554 	ddi_err(DER_NOTE, NULL, "IOMMU %s stopped", immu->immu_name);
555 }
556 
557 /*
558  * immu_regs_intr()
559  *        Set a IMMU unit regs to setup a IMMU unit's
560  *        interrupt handler
561  */
562 void
563 immu_regs_intr_enable(immu_t *immu, uint32_t msi_addr, uint32_t msi_data,
564     uint32_t uaddr)
565 {
566 	mutex_enter(&(immu->immu_regs_lock));
567 	immu->immu_regs_intr_msi_addr = msi_addr;
568 	immu->immu_regs_intr_uaddr = uaddr;
569 	immu->immu_regs_intr_msi_data = msi_data;
570 	put_reg32(immu, IMMU_REG_FEVNT_ADDR, msi_addr);
571 	put_reg32(immu, IMMU_REG_FEVNT_UADDR, uaddr);
572 	put_reg32(immu, IMMU_REG_FEVNT_DATA, msi_data);
573 	put_reg32(immu, IMMU_REG_FEVNT_CON, 0);
574 	mutex_exit(&(immu->immu_regs_lock));
575 }
576 
577 /*
578  * immu_regs_passthru_supported()
579  *       Returns B_TRUE ifi passthru is supported
580  */
581 boolean_t
582 immu_regs_passthru_supported(immu_t *immu)
583 {
584 	if (IMMU_ECAP_GET_PT(immu->immu_regs_excap)) {
585 		return (B_TRUE);
586 	}
587 
588 	ddi_err(DER_WARN, NULL, "Passthru not supported");
589 	return (B_FALSE);
590 }
591 
592 /*
593  * immu_regs_is_TM_reserved()
594  *       Returns B_TRUE if TM field is reserved
595  */
596 boolean_t
597 immu_regs_is_TM_reserved(immu_t *immu)
598 {
599 	if (IMMU_ECAP_GET_DI(immu->immu_regs_excap) ||
600 	    IMMU_ECAP_GET_CH(immu->immu_regs_excap)) {
601 		return (B_FALSE);
602 	}
603 	return (B_TRUE);
604 }
605 
606 /*
607  * immu_regs_is_SNP_reserved()
608  *       Returns B_TRUE if SNP field is reserved
609  */
610 boolean_t
611 immu_regs_is_SNP_reserved(immu_t *immu)
612 {
613 
614 	return (IMMU_ECAP_GET_SC(immu->immu_regs_excap) ? B_FALSE : B_TRUE);
615 }
616 
617 /*
618  * immu_regs_wbf_flush()
619  *     If required and supported, write to IMMU
620  *     unit's regs to flush DMA write buffer(s)
621  */
622 void
623 immu_regs_wbf_flush(immu_t *immu)
624 {
625 	uint32_t status;
626 
627 	if (!IMMU_CAP_GET_RWBF(immu->immu_regs_cap)) {
628 		return;
629 	}
630 
631 	mutex_enter(&(immu->immu_regs_lock));
632 	put_reg32(immu, IMMU_REG_GLOBAL_CMD,
633 	    immu->immu_regs_cmdval | IMMU_GCMD_WBF);
634 	wait_completion(immu, IMMU_REG_GLOBAL_STS,
635 	    get_reg32, (!(status & IMMU_GSTS_WBFS)), status);
636 	mutex_exit(&(immu->immu_regs_lock));
637 }
638 
639 /*
640  * immu_regs_cpu_flush()
641  * 	flush the cpu cache line after CPU memory writes, so
642  *      IOMMU can see the writes
643  */
644 void
645 immu_regs_cpu_flush(immu_t *immu, caddr_t addr, uint_t size)
646 {
647 	uintptr_t startline, endline;
648 
649 	if (immu->immu_dvma_coherent == B_TRUE)
650 		return;
651 
652 	startline = (uintptr_t)addr  & ~(uintptr_t)(x86_clflush_size - 1);
653 	endline = ((uintptr_t)addr + size - 1) &
654 	    ~(uintptr_t)(x86_clflush_size - 1);
655 	while (startline <= endline) {
656 		clflush_insn((caddr_t)startline);
657 		startline += x86_clflush_size;
658 	}
659 
660 	mfence_insn();
661 }
662 
663 /*
664  * immu_regs_context_flush()
665  *   flush the context cache
666  */
667 static void
668 context_flush(immu_t *immu, uint8_t function_mask,
669     uint16_t sid, uint_t did, immu_context_inv_t type)
670 {
671 	uint64_t command = 0;
672 	uint64_t status;
673 
674 	/*
675 	 * define the command
676 	 */
677 	switch (type) {
678 	case CONTEXT_FSI:
679 		command |= CCMD_INV_ICC | CCMD_INV_DEVICE
680 		    | CCMD_INV_DID(did)
681 		    | CCMD_INV_SID(sid) | CCMD_INV_FM(function_mask);
682 		break;
683 	case CONTEXT_DSI:
684 		command |= CCMD_INV_ICC | CCMD_INV_DOMAIN
685 		    | CCMD_INV_DID(did);
686 		break;
687 	case CONTEXT_GLOBAL:
688 		command |= CCMD_INV_ICC | CCMD_INV_GLOBAL;
689 		break;
690 	default:
691 		ddi_err(DER_PANIC, NULL,
692 		    "%s: incorrect context cache flush type",
693 		    immu->immu_name);
694 		/*NOTREACHED*/
695 	}
696 
697 	mutex_enter(&(immu->immu_regs_lock));
698 	put_reg64(immu, IMMU_REG_CONTEXT_CMD, command);
699 	wait_completion(immu, IMMU_REG_CONTEXT_CMD, get_reg64,
700 	    (!(status & CCMD_INV_ICC)), status);
701 	mutex_exit(&(immu->immu_regs_lock));
702 }
703 
704 /*ARGSUSED*/
705 void
706 immu_regs_context_fsi(immu_t *immu, uint8_t function_mask,
707     uint16_t source_id, uint_t domain_id, immu_inv_wait_t *iwp)
708 {
709 	context_flush(immu, function_mask, source_id, domain_id, CONTEXT_FSI);
710 }
711 
712 /*ARGSUSED*/
713 void
714 immu_regs_context_dsi(immu_t *immu, uint_t domain_id, immu_inv_wait_t *iwp)
715 {
716 	context_flush(immu, 0, 0, domain_id, CONTEXT_DSI);
717 }
718 
719 /*ARGSUSED*/
720 void
721 immu_regs_context_gbl(immu_t *immu, immu_inv_wait_t *iwp)
722 {
723 	context_flush(immu, 0, 0, 0, CONTEXT_GLOBAL);
724 }
725 
726 /*
727  * Nothing to do, all register operations are synchronous.
728  */
729 /*ARGSUSED*/
730 static void
731 immu_regs_inv_wait(immu_inv_wait_t *iwp)
732 {
733 }
734 
735 void
736 immu_regs_set_root_table(immu_t *immu)
737 {
738 	uint32_t status;
739 
740 	mutex_enter(&(immu->immu_regs_lock));
741 	put_reg64(immu, IMMU_REG_ROOTENTRY,
742 	    immu->immu_ctx_root->hwpg_paddr);
743 	put_reg32(immu, IMMU_REG_GLOBAL_CMD,
744 	    immu->immu_regs_cmdval | IMMU_GCMD_SRTP);
745 	wait_completion(immu, IMMU_REG_GLOBAL_STS,
746 	    get_reg32, (status & IMMU_GSTS_RTPS), status);
747 	mutex_exit(&(immu->immu_regs_lock));
748 }
749 
750 
751 /* enable queued invalidation interface */
752 void
753 immu_regs_qinv_enable(immu_t *immu, uint64_t qinv_reg_value)
754 {
755 	uint32_t status;
756 
757 	if (immu_qinv_enable == B_FALSE)
758 		return;
759 
760 	mutex_enter(&immu->immu_regs_lock);
761 	immu->immu_qinv_reg_value = qinv_reg_value;
762 	/* Initialize the Invalidation Queue Tail register to zero */
763 	put_reg64(immu, IMMU_REG_INVAL_QT, 0);
764 
765 	/* set invalidation queue base address register */
766 	put_reg64(immu, IMMU_REG_INVAL_QAR, qinv_reg_value);
767 
768 	/* enable queued invalidation interface */
769 	put_reg32(immu, IMMU_REG_GLOBAL_CMD,
770 	    immu->immu_regs_cmdval | IMMU_GCMD_QIE);
771 	wait_completion(immu, IMMU_REG_GLOBAL_STS,
772 	    get_reg32, (status & IMMU_GSTS_QIES), status);
773 	mutex_exit(&immu->immu_regs_lock);
774 
775 	immu->immu_regs_cmdval |= IMMU_GCMD_QIE;
776 	immu->immu_qinv_running = B_TRUE;
777 
778 }
779 
780 /* enable interrupt remapping hardware unit */
781 void
782 immu_regs_intrmap_enable(immu_t *immu, uint64_t irta_reg)
783 {
784 	uint32_t status;
785 
786 	if (immu_intrmap_enable == B_FALSE)
787 		return;
788 
789 	/* set interrupt remap table pointer */
790 	mutex_enter(&(immu->immu_regs_lock));
791 	immu->immu_intrmap_irta_reg = irta_reg;
792 	put_reg64(immu, IMMU_REG_IRTAR, irta_reg);
793 	put_reg32(immu, IMMU_REG_GLOBAL_CMD,
794 	    immu->immu_regs_cmdval | IMMU_GCMD_SIRTP);
795 	wait_completion(immu, IMMU_REG_GLOBAL_STS,
796 	    get_reg32, (status & IMMU_GSTS_IRTPS), status);
797 	mutex_exit(&(immu->immu_regs_lock));
798 
799 	/* global flush intr entry cache */
800 	immu_qinv_intr_global(immu, &immu->immu_intrmap_inv_wait);
801 
802 	/* enable interrupt remapping */
803 	mutex_enter(&(immu->immu_regs_lock));
804 	put_reg32(immu, IMMU_REG_GLOBAL_CMD,
805 	    immu->immu_regs_cmdval | IMMU_GCMD_IRE);
806 	wait_completion(immu, IMMU_REG_GLOBAL_STS,
807 	    get_reg32, (status & IMMU_GSTS_IRES),
808 	    status);
809 	immu->immu_regs_cmdval |= IMMU_GCMD_IRE;
810 
811 	/* set compatible mode */
812 	put_reg32(immu, IMMU_REG_GLOBAL_CMD,
813 	    immu->immu_regs_cmdval | IMMU_GCMD_CFI);
814 	wait_completion(immu, IMMU_REG_GLOBAL_STS,
815 	    get_reg32, (status & IMMU_GSTS_CFIS),
816 	    status);
817 	immu->immu_regs_cmdval |= IMMU_GCMD_CFI;
818 	mutex_exit(&(immu->immu_regs_lock));
819 
820 	immu->immu_intrmap_running = B_TRUE;
821 }
822 
823 uint64_t
824 immu_regs_get64(immu_t *immu, uint_t reg)
825 {
826 	return (get_reg64(immu, reg));
827 }
828 
829 uint32_t
830 immu_regs_get32(immu_t *immu, uint_t reg)
831 {
832 	return (get_reg32(immu, reg));
833 }
834 
835 void
836 immu_regs_put64(immu_t *immu, uint_t reg, uint64_t val)
837 {
838 	put_reg64(immu, reg, val);
839 }
840 
841 void
842 immu_regs_put32(immu_t *immu, uint_t reg, uint32_t val)
843 {
844 	put_reg32(immu, reg, val);
845 }
846