1 | /* |
2 | * Copyright 2017 Red Hat Inc. |
3 | * |
4 | * Permission is hereby granted, free of charge, to any person obtaining a |
5 | * copy of this software and associated documentation files (the "Software"), |
6 | * to deal in the Software without restriction, including without limitation |
7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
8 | * and/or sell copies of the Software, and to permit persons to whom the |
9 | * Software is furnished to do so, subject to the following conditions: |
10 | * |
11 | * The above copyright notice and this permission notice shall be included in |
12 | * all copies or substantial portions of the Software. |
13 | * |
14 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
15 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
16 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
17 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR |
18 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
19 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
20 | * OTHER DEALINGS IN THE SOFTWARE. |
21 | */ |
22 | #include <nvif/mmu.h> |
23 | |
24 | #include <nvif/class.h> |
25 | #include <nvif/if0008.h> |
26 | |
27 | void |
28 | nvif_mmu_dtor(struct nvif_mmu *mmu) |
29 | { |
30 | if (!nvif_object_constructed(&mmu->object)) |
31 | return; |
32 | |
33 | kfree(mmu->kind); |
34 | kfree(mmu->type); |
35 | kfree(mmu->heap); |
36 | nvif_object_dtor(&mmu->object); |
37 | } |
38 | |
39 | int |
40 | nvif_mmu_ctor(struct nvif_object *parent, const char *name, s32 oclass, |
41 | struct nvif_mmu *mmu) |
42 | { |
43 | static const struct nvif_mclass mems[] = { |
44 | { NVIF_CLASS_MEM_GF100, -1 }, |
45 | { NVIF_CLASS_MEM_NV50 , -1 }, |
46 | { NVIF_CLASS_MEM_NV04 , -1 }, |
47 | {} |
48 | }; |
49 | struct nvif_mmu_v0 args; |
50 | int ret, i; |
51 | |
52 | args.version = 0; |
53 | mmu->heap = NULL; |
54 | mmu->type = NULL; |
55 | mmu->kind = NULL; |
56 | |
57 | ret = nvif_object_ctor(parent, name ? name : "nvifMmu" , 0, oclass, |
58 | &args, sizeof(args), &mmu->object); |
59 | if (ret) |
60 | goto done; |
61 | |
62 | mmu->dmabits = args.dmabits; |
63 | mmu->heap_nr = args.heap_nr; |
64 | mmu->type_nr = args.type_nr; |
65 | mmu->kind_nr = args.kind_nr; |
66 | |
67 | ret = nvif_mclass(&mmu->object, mems); |
68 | if (ret < 0) |
69 | goto done; |
70 | mmu->mem = mems[ret].oclass; |
71 | |
72 | mmu->heap = kmalloc_array(mmu->heap_nr, sizeof(*mmu->heap), |
73 | GFP_KERNEL); |
74 | mmu->type = kmalloc_array(mmu->type_nr, sizeof(*mmu->type), |
75 | GFP_KERNEL); |
76 | if (ret = -ENOMEM, !mmu->heap || !mmu->type) |
77 | goto done; |
78 | |
79 | mmu->kind = kmalloc_array(mmu->kind_nr, sizeof(*mmu->kind), |
80 | GFP_KERNEL); |
81 | if (!mmu->kind && mmu->kind_nr) |
82 | goto done; |
83 | |
84 | for (i = 0; i < mmu->heap_nr; i++) { |
85 | struct nvif_mmu_heap_v0 args = { .index = i }; |
86 | |
87 | ret = nvif_object_mthd(&mmu->object, NVIF_MMU_V0_HEAP, |
88 | &args, sizeof(args)); |
89 | if (ret) |
90 | goto done; |
91 | |
92 | mmu->heap[i].size = args.size; |
93 | } |
94 | |
95 | for (i = 0; i < mmu->type_nr; i++) { |
96 | struct nvif_mmu_type_v0 args = { .index = i }; |
97 | |
98 | ret = nvif_object_mthd(&mmu->object, NVIF_MMU_V0_TYPE, |
99 | &args, sizeof(args)); |
100 | if (ret) |
101 | goto done; |
102 | |
103 | mmu->type[i].type = 0; |
104 | if (args.vram) mmu->type[i].type |= NVIF_MEM_VRAM; |
105 | if (args.host) mmu->type[i].type |= NVIF_MEM_HOST; |
106 | if (args.comp) mmu->type[i].type |= NVIF_MEM_COMP; |
107 | if (args.disp) mmu->type[i].type |= NVIF_MEM_DISP; |
108 | if (args.kind ) mmu->type[i].type |= NVIF_MEM_KIND; |
109 | if (args.mappable) mmu->type[i].type |= NVIF_MEM_MAPPABLE; |
110 | if (args.coherent) mmu->type[i].type |= NVIF_MEM_COHERENT; |
111 | if (args.uncached) mmu->type[i].type |= NVIF_MEM_UNCACHED; |
112 | mmu->type[i].heap = args.heap; |
113 | } |
114 | |
115 | if (mmu->kind_nr) { |
116 | struct nvif_mmu_kind_v0 *kind; |
117 | size_t argc = struct_size(kind, data, mmu->kind_nr); |
118 | |
119 | if (ret = -ENOMEM, !(kind = kmalloc(argc, GFP_KERNEL))) |
120 | goto done; |
121 | kind->version = 0; |
122 | kind->count = mmu->kind_nr; |
123 | |
124 | ret = nvif_object_mthd(&mmu->object, NVIF_MMU_V0_KIND, |
125 | kind, argc); |
126 | if (ret == 0) |
127 | memcpy(mmu->kind, kind->data, kind->count); |
128 | mmu->kind_inv = kind->kind_inv; |
129 | kfree(kind); |
130 | } |
131 | |
132 | done: |
133 | if (ret) |
134 | nvif_mmu_dtor(mmu); |
135 | return ret; |
136 | } |
137 | |