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 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <sys/types.h>
28 #include <sys/file.h>
29 #include <sys/errno.h>
30 #include <sys/open.h>
31 #include <sys/stat.h>
32 #include <sys/cred.h>
33 #include <sys/modctl.h>
34 #include <sys/conf.h>
35 #include <sys/devops.h>
36 #include <sys/ddi.h>
37 #include <sys/x86_archext.h>
38
39 #include <sys/amd_iommu.h>
40 #include "amd_iommu_impl.h"
41 #include "amd_iommu_acpi.h"
42
43
44 #define AMD_IOMMU_MINOR2INST(x) (x)
45 #define AMD_IOMMU_INST2MINOR(x) (x)
46 #define AMD_IOMMU_NODETYPE "ddi_iommu"
47 #define AMD_IOMMU_MINOR_NAME "amd-iommu"
48
49 static int amd_iommu_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg,
50 void **result);
51 static int amd_iommu_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
52 static int amd_iommu_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
53 static int amd_iommu_open(dev_t *devp, int flag, int otyp, cred_t *credp);
54 static int amd_iommu_close(dev_t dev, int flag, int otyp, cred_t *credp);
55 static int amd_iommu_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
56 cred_t *credp, int *rvalp);
57 static int amd_iommu_quiesce(dev_info_t *dip);
58
59 static struct cb_ops amd_iommu_cb_ops = {
60 amd_iommu_open, /* cb_open */
61 amd_iommu_close, /* cb_close */
62 nodev, /* cb_strategy */
63 nodev, /* cb_print */
64 nodev, /* cb_dump */
65 nodev, /* cb_read */
66 nodev, /* cb_write */
67 amd_iommu_ioctl, /* cb_ioctl */
68 nodev, /* cb_devmap */
69 nodev, /* cb_mmap */
70 nodev, /* cb_segmap */
71 nochpoll, /* cb_chpoll */
72 ddi_prop_op, /* cb_prop_op */
73 NULL, /* cb_str */
74 D_NEW | D_MP, /* cb_flag */
75 CB_REV, /* cb_rev */
76 nodev, /* cb_aread */
77 nodev /* cb_awrite */
78 };
79
80 static struct dev_ops amd_iommu_dev_ops = {
81 DEVO_REV, /* devo_rev */
82 0, /* devo_refcnt */
83 amd_iommu_getinfo, /* devo_getinfo */
84 nulldev, /* devo_identify */
85 nulldev, /* devo_probe */
86 amd_iommu_attach, /* devo_attach */
87 amd_iommu_detach, /* devo_detach */
88 nodev, /* devo_reset */
89 &amd_iommu_cb_ops, /* devo_cb_ops */
90 NULL, /* devo_bus_ops */
91 nulldev, /* devo_power */
92 amd_iommu_quiesce, /* devo_quiesce */
93 };
94
95 static struct modldrv modldrv = {
96 &mod_driverops,
97 "AMD IOMMU 0.1",
98 &amd_iommu_dev_ops
99 };
100
101 static struct modlinkage modlinkage = {
102 MODREV_1,
103 (void *)&modldrv,
104 NULL
105 };
106
107 amd_iommu_debug_t amd_iommu_debug;
108 kmutex_t amd_iommu_global_lock;
109 const char *amd_iommu_modname = "amd_iommu";
110 amd_iommu_alias_t **amd_iommu_alias;
111 amd_iommu_page_table_hash_t amd_iommu_page_table_hash;
112 static void *amd_iommu_statep;
113 int amd_iommu_64bit_bug;
114 int amd_iommu_unity_map;
115 int amd_iommu_no_RW_perms;
116 int amd_iommu_no_unmap;
117 int amd_iommu_pageva_inval_all;
118 int amd_iommu_disable; /* disable IOMMU */
119 char *amd_iommu_disable_list; /* list of drivers bypassing IOMMU */
120
121 int
122 _init(void)
123 {
124 int error = ENOTSUP;
125
126 #if defined(__amd64) && !defined(__xpv)
127
128 if (get_hwenv() != HW_NATIVE)
129 return (ENOTSUP);
130
131 error = ddi_soft_state_init(&amd_iommu_statep,
132 sizeof (struct amd_iommu_state), 1);
133 if (error) {
134 cmn_err(CE_WARN, "%s: _init: failed to init soft state.",
135 amd_iommu_modname);
136 return (error);
137 }
138
139 if (amd_iommu_acpi_init() != DDI_SUCCESS) {
140 if (amd_iommu_debug) {
141 cmn_err(CE_WARN, "%s: _init: ACPI init failed.",
142 amd_iommu_modname);
143 }
144 ddi_soft_state_fini(&amd_iommu_statep);
145 return (ENOTSUP);
146 }
147
148 amd_iommu_read_boot_props();
149
150 if (amd_iommu_page_table_hash_init(&amd_iommu_page_table_hash)
151 != DDI_SUCCESS) {
152 cmn_err(CE_WARN, "%s: _init: Page table hash init failed.",
153 amd_iommu_modname);
154 if (amd_iommu_disable_list) {
155 kmem_free(amd_iommu_disable_list,
156 strlen(amd_iommu_disable_list) + 1);
157 amd_iommu_disable_list = NULL;
158 }
159 amd_iommu_acpi_fini();
160 ddi_soft_state_fini(&amd_iommu_statep);
161 amd_iommu_statep = NULL;
162 return (EFAULT);
163 }
164
165 error = mod_install(&modlinkage);
166 if (error) {
167 cmn_err(CE_WARN, "%s: _init: mod_install failed.",
168 amd_iommu_modname);
169 amd_iommu_page_table_hash_fini(&amd_iommu_page_table_hash);
170 if (amd_iommu_disable_list) {
171 kmem_free(amd_iommu_disable_list,
172 strlen(amd_iommu_disable_list) + 1);
173 amd_iommu_disable_list = NULL;
174 }
175 amd_iommu_acpi_fini();
176 ddi_soft_state_fini(&amd_iommu_statep);
177 amd_iommu_statep = NULL;
178 return (error);
179 }
180 error = 0;
181 #endif
182
183 return (error);
184 }
185
186 int
187 _info(struct modinfo *modinfop)
188 {
189 return (mod_info(&modlinkage, modinfop));
190 }
191
192 int
193 _fini(void)
194 {
195 int error;
196
197 error = mod_remove(&modlinkage);
198 if (error)
199 return (error);
200
201 amd_iommu_page_table_hash_fini(&amd_iommu_page_table_hash);
202 if (amd_iommu_disable_list) {
203 kmem_free(amd_iommu_disable_list,
204 strlen(amd_iommu_disable_list) + 1);
205 amd_iommu_disable_list = NULL;
206 }
207 amd_iommu_acpi_fini();
208 ddi_soft_state_fini(&amd_iommu_statep);
209 amd_iommu_statep = NULL;
210
211 return (0);
212 }
213
214 /*ARGSUSED*/
215 static int
216 amd_iommu_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
217 {
218 struct amd_iommu_state *statep;
219
220 ASSERT(result);
221
222 *result = NULL;
223
224 switch (cmd) {
225 case DDI_INFO_DEVT2DEVINFO:
226 statep = ddi_get_soft_state(amd_iommu_statep,
227 AMD_IOMMU_MINOR2INST(getminor((dev_t)arg)));
228 if (statep) {
229 *result = statep->aioms_devi;
230 return (DDI_SUCCESS);
231 }
232 break;
233 case DDI_INFO_DEVT2INSTANCE:
234 *result = (void *)(uintptr_t)
235 AMD_IOMMU_MINOR2INST(getminor((dev_t)arg));
236 return (DDI_SUCCESS);
237 }
238
239 return (DDI_FAILURE);
240 }
241
242 static int
243 amd_iommu_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
244 {
245 int instance = ddi_get_instance(dip);
246 const char *driver = ddi_driver_name(dip);
247 struct amd_iommu_state *statep;
248
249 ASSERT(instance >= 0);
250 ASSERT(driver);
251
252 switch (cmd) {
253 case DDI_ATTACH:
254 if (ddi_soft_state_zalloc(amd_iommu_statep, instance)
255 != DDI_SUCCESS) {
256 cmn_err(CE_WARN, "Unable to allocate soft state for "
257 "%s%d", driver, instance);
258 return (DDI_FAILURE);
259 }
260
261 statep = ddi_get_soft_state(amd_iommu_statep, instance);
262 if (statep == NULL) {
263 cmn_err(CE_WARN, "Unable to get soft state for "
264 "%s%d", driver, instance);
265 ddi_soft_state_free(amd_iommu_statep, instance);
266 return (DDI_FAILURE);
267 }
268
269 if (ddi_create_minor_node(dip, AMD_IOMMU_MINOR_NAME, S_IFCHR,
270 AMD_IOMMU_INST2MINOR(instance), AMD_IOMMU_NODETYPE,
271 0) != DDI_SUCCESS) {
272 cmn_err(CE_WARN, "Unable to create minor node for "
273 "%s%d", driver, instance);
274 ddi_remove_minor_node(dip, NULL);
275 ddi_soft_state_free(amd_iommu_statep, instance);
276 return (DDI_FAILURE);
277 }
278
279 statep->aioms_devi = dip;
280 statep->aioms_instance = instance;
281 statep->aioms_iommu_start = NULL;
282 statep->aioms_iommu_end = NULL;
283
284 amd_iommu_lookup_conf_props(dip);
285
286 if (amd_iommu_disable_list) {
287 cmn_err(CE_NOTE, "AMD IOMMU disabled for the following"
288 " drivers:\n%s", amd_iommu_disable_list);
289 }
290
291 if (amd_iommu_disable) {
292 cmn_err(CE_NOTE, "AMD IOMMU disabled by user");
293 } else if (amd_iommu_setup(dip, statep) != DDI_SUCCESS) {
294 cmn_err(CE_WARN, "Unable to initialize AMD IOMMU "
295 "%s%d", driver, instance);
296 ddi_remove_minor_node(dip, NULL);
297 ddi_soft_state_free(amd_iommu_statep, instance);
298 return (DDI_FAILURE);
299 }
300
301 ddi_report_dev(dip);
302
303 return (DDI_SUCCESS);
304
305 case DDI_RESUME:
306 return (DDI_SUCCESS);
307 default:
308 return (DDI_FAILURE);
309 }
310 }
311
312 static int
313 amd_iommu_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
314 {
315 int instance = ddi_get_instance(dip);
316 const char *driver = ddi_driver_name(dip);
317 struct amd_iommu_state *statep;
318
319 ASSERT(instance >= 0);
320 ASSERT(driver);
321
322 switch (cmd) {
323 case DDI_DETACH:
324 statep = ddi_get_soft_state(amd_iommu_statep, instance);
325 if (statep == NULL) {
326 cmn_err(CE_WARN, "%s%d: Cannot get soft state",
327 driver, instance);
328 return (DDI_FAILURE);
329 }
330 return (DDI_FAILURE);
331 case DDI_SUSPEND:
332 return (DDI_SUCCESS);
333 default:
334 return (DDI_FAILURE);
335 }
336 }
337
338 /*ARGSUSED*/
339 static int
340 amd_iommu_open(dev_t *devp, int flag, int otyp, cred_t *credp)
341 {
342 int instance = AMD_IOMMU_MINOR2INST(getminor(*devp));
343 struct amd_iommu_state *statep;
344 const char *f = "amd_iommu_open";
345
346 if (instance < 0) {
347 cmn_err(CE_WARN, "%s: invalid instance %d",
348 f, instance);
349 return (ENXIO);
350 }
351
352 if (!(flag & (FREAD|FWRITE))) {
353 cmn_err(CE_WARN, "%s: invalid flags %d", f, flag);
354 return (EINVAL);
355 }
356
357 if (otyp != OTYP_CHR) {
358 cmn_err(CE_WARN, "%s: invalid otyp %d", f, otyp);
359 return (EINVAL);
360 }
361
362 statep = ddi_get_soft_state(amd_iommu_statep, instance);
363 if (statep == NULL) {
364 cmn_err(CE_WARN, "%s: cannot get soft state: instance %d",
365 f, instance);
366 return (ENXIO);
367 }
368
369 ASSERT(statep->aioms_instance == instance);
370
371 return (0);
372 }
373
374 /*ARGSUSED*/
375 static int
376 amd_iommu_close(dev_t dev, int flag, int otyp, cred_t *credp)
377 {
378 int instance = AMD_IOMMU_MINOR2INST(getminor(dev));
379 struct amd_iommu_state *statep;
380 const char *f = "amd_iommu_close";
381
382 if (instance < 0) {
383 cmn_err(CE_WARN, "%s: invalid instance %d", f, instance);
384 return (ENXIO);
385 }
386
387 if (!(flag & (FREAD|FWRITE))) {
388 cmn_err(CE_WARN, "%s: invalid flags %d", f, flag);
389 return (EINVAL);
390 }
391
392 if (otyp != OTYP_CHR) {
393 cmn_err(CE_WARN, "%s: invalid otyp %d", f, otyp);
394 return (EINVAL);
395 }
396
397 statep = ddi_get_soft_state(amd_iommu_statep, instance);
398 if (statep == NULL) {
399 cmn_err(CE_WARN, "%s: cannot get soft state: instance %d",
400 f, instance);
401 return (ENXIO);
402 }
403
404 ASSERT(statep->aioms_instance == instance);
405 return (0);
406
407 }
408
409 /*ARGSUSED*/
410 static int
411 amd_iommu_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
412 int *rvalp)
413 {
414 int instance = AMD_IOMMU_MINOR2INST(getminor(dev));
415 struct amd_iommu_state *statep;
416 const char *f = "amd_iommu_ioctl";
417
418 ASSERT(*rvalp);
419
420 if (instance < 0) {
421 cmn_err(CE_WARN, "%s: invalid instance %d", f, instance);
422 return (ENXIO);
423 }
424
425
426 if (!(mode & (FREAD|FWRITE))) {
427 cmn_err(CE_WARN, "%s: invalid mode %d", f, mode);
428 return (EINVAL);
429 }
430
431 if (mode & FKIOCTL) {
432 cmn_err(CE_WARN, "%s: FKIOCTL unsupported mode %d", f, mode);
433 return (EINVAL);
434 }
435
436 statep = ddi_get_soft_state(amd_iommu_statep, instance);
437 if (statep == NULL) {
438 cmn_err(CE_WARN, "%s: cannot get soft state: instance %d",
439 f, instance);
440 return (ENXIO);
441 }
442
443 ASSERT(statep->aioms_instance == instance);
444
445 return (ENOTTY);
446 }
447
448 static int
449 amd_iommu_quiesce(dev_info_t *dip)
450 {
451 int instance = ddi_get_instance(dip);
452 struct amd_iommu_state *statep;
453 const char *f = "amd_iommu_quiesce";
454
455 statep = ddi_get_soft_state(amd_iommu_statep, instance);
456 if (statep == NULL) {
457 cmn_err(CE_WARN, "%s: cannot get soft state: instance %d",
458 f, instance);
459 return (DDI_FAILURE);
460 }
461
462 if (amd_iommu_teardown(dip, statep, AMD_IOMMU_QUIESCE) != DDI_SUCCESS) {
463 cmn_err(CE_WARN, "%s: Unable to quiesce AMD IOMMU "
464 "%s%d", f, ddi_driver_name(dip), instance);
465 return (DDI_FAILURE);
466 }
467
468 return (DDI_SUCCESS);
469 }