base.c

  1/*
  2 * Copyright 2012 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 * Authors: Ben Skeggs
 23 */
 24#include "priv.h"
 25#include "ram.h"
 26
 27#include <core/memory.h>
 28#include <core/option.h>
 29#include <subdev/bios.h>
 30#include <subdev/bios/M0203.h>
 31#include <engine/gr.h>
 32#include <engine/mpeg.h>
 33
 34void
 35nvkm_fb_tile_fini(struct nvkm_fb *fb, int region, struct nvkm_fb_tile *tile)
 36{
 37	fb->func->tile.fini(fb, region, tile);
 38}
 39
 40void
 41nvkm_fb_tile_init(struct nvkm_fb *fb, int region, u32 addr, u32 size,
 42		  u32 pitch, u32 flags, struct nvkm_fb_tile *tile)
 43{
 44	fb->func->tile.init(fb, region, addr, size, pitch, flags, tile);
 45}
 46
 47void
 48nvkm_fb_tile_prog(struct nvkm_fb *fb, int region, struct nvkm_fb_tile *tile)
 49{
 50	struct nvkm_device *device = fb->subdev.device;
 51	if (fb->func->tile.prog) {
 52		fb->func->tile.prog(fb, region, tile);
 53		if (device->gr)
 54			nvkm_engine_tile(&device->gr->engine, region);
 55		if (device->mpeg)
 56			nvkm_engine_tile(device->mpeg, region);
 57	}
 58}
 59
 60static void
 61nvkm_fb_sysmem_flush_page_init(struct nvkm_device *device)
 62{
 63	struct nvkm_fb *fb = device->fb;
 64
 65	if (fb->func->sysmem.flush_page_init)
 66		fb->func->sysmem.flush_page_init(fb);
 67}
 68
 69int
 70nvkm_fb_bios_memtype(struct nvkm_bios *bios)
 71{
 72	struct nvkm_subdev *subdev = &bios->subdev;
 73	struct nvkm_device *device = subdev->device;
 74	const u8 ramcfg = (nvkm_rd32(device, 0x101000) & 0x0000003c) >> 2;
 75	struct nvbios_M0203E M0203E;
 76	u8 ver, hdr;
 77
 78	if (nvbios_M0203Em(bios, ramcfg, &ver, &hdr, &M0203E)) {
 79		switch (M0203E.type) {
 80		case M0203E_TYPE_DDR2  : return NVKM_RAM_TYPE_DDR2;
 81		case M0203E_TYPE_DDR3  : return NVKM_RAM_TYPE_DDR3;
 82		case M0203E_TYPE_GDDR3 : return NVKM_RAM_TYPE_GDDR3;
 83		case M0203E_TYPE_GDDR5 : return NVKM_RAM_TYPE_GDDR5;
 84		case M0203E_TYPE_GDDR5X: return NVKM_RAM_TYPE_GDDR5X;
 85		case M0203E_TYPE_GDDR6 : return NVKM_RAM_TYPE_GDDR6;
 86		case M0203E_TYPE_HBM2  : return NVKM_RAM_TYPE_HBM2;
 87		default:
 88			nvkm_warn(subdev, "M0203E type %02x\n", M0203E.type);
 89			return NVKM_RAM_TYPE_UNKNOWN;
 90		}
 91	}
 92
 93	nvkm_warn(subdev, "M0203E not matched!\n");
 94	return NVKM_RAM_TYPE_UNKNOWN;
 95}
 96
 97static void
 98nvkm_fb_intr(struct nvkm_subdev *subdev)
 99{
100	struct nvkm_fb *fb = nvkm_fb(subdev);
101	if (fb->func->intr)
102		fb->func->intr(fb);
103}
104
105static int
106nvkm_fb_oneinit(struct nvkm_subdev *subdev)
107{
108	struct nvkm_fb *fb = nvkm_fb(subdev);
109	u32 tags = 0;
110
111	if (fb->func->ram_new) {
112		int ret = fb->func->ram_new(fb, &fb->ram);
113		if (ret) {
114			nvkm_error(subdev, "vram setup failed, %d\n", ret);
115			return ret;
116		}
117	}
118
119	if (fb->func->oneinit) {
120		int ret = fb->func->oneinit(fb);
121		if (ret)
122			return ret;
123	}
124
125	/* Initialise compression tag allocator.
126	 *
127	 * LTC oneinit() will override this on Fermi and newer.
128	 */
129	if (fb->func->tags) {
130		tags = fb->func->tags(fb);
131		nvkm_debug(subdev, "%d comptags\n", tags);
132	}
133
134	return nvkm_mm_init(&fb->tags.mm, 0, 0, tags, 1);
135}
136
137int
138nvkm_fb_mem_unlock(struct nvkm_fb *fb)
139{
140	struct nvkm_subdev *subdev = &fb->subdev;
141	int ret;
142
143	if (!fb->func->vpr.scrub_required)
144		return 0;
145
146	ret = nvkm_subdev_oneinit(subdev);
147	if (ret)
148		return ret;
149
150	if (!fb->func->vpr.scrub_required(fb)) {
151		nvkm_debug(subdev, "VPR not locked\n");
152		return 0;
153	}
154
155	nvkm_debug(subdev, "VPR locked, running scrubber binary\n");
156
157	if (!fb->vpr_scrubber.fw.img) {
158		nvkm_warn(subdev, "VPR locked, but no scrubber binary!\n");
159		return 0;
160	}
161
162	ret = fb->func->vpr.scrub(fb);
163	if (ret) {
164		nvkm_error(subdev, "VPR scrubber binary failed\n");
165		return ret;
166	}
167
168	if (fb->func->vpr.scrub_required(fb)) {
169		nvkm_error(subdev, "VPR still locked after scrub!\n");
170		return -EIO;
171	}
172
173	nvkm_debug(subdev, "VPR scrubber binary successful\n");
174	return 0;
175}
176
177u64
178nvkm_fb_vidmem_size(struct nvkm_device *device)
179{
180	struct nvkm_fb *fb = device->fb;
181
182	if (fb && fb->func->vidmem.size)
183		return fb->func->vidmem.size(fb);
184
185	WARN_ON(1);
186	return 0;
187}
188
189static int
190nvkm_fb_init(struct nvkm_subdev *subdev)
191{
192	struct nvkm_fb *fb = nvkm_fb(subdev);
193	int ret, i;
194
195	if (fb->ram) {
196		ret = nvkm_ram_init(fb->ram);
197		if (ret)
198			return ret;
199	}
200
201	for (i = 0; i < fb->tile.regions; i++)
202		fb->func->tile.prog(fb, i, &fb->tile.region[i]);
203
204	nvkm_fb_sysmem_flush_page_init(subdev->device);
205
206	if (fb->func->init)
207		fb->func->init(fb);
208
209	if (fb->func->init_remapper)
210		fb->func->init_remapper(fb);
211
212	if (fb->func->init_page) {
213		ret = fb->func->init_page(fb);
214		if (WARN_ON(ret))
215			return ret;
216	}
217
218	if (fb->func->init_unkn)
219		fb->func->init_unkn(fb);
220
221	return 0;
222}
223
224static int
225nvkm_fb_preinit(struct nvkm_subdev *subdev)
226{
227	nvkm_fb_sysmem_flush_page_init(subdev->device);
228	return 0;
229}
230
231static void *
232nvkm_fb_dtor(struct nvkm_subdev *subdev)
233{
234	struct nvkm_fb *fb = nvkm_fb(subdev);
235	int i;
236
237	nvkm_memory_unref(&fb->mmu_wr);
238	nvkm_memory_unref(&fb->mmu_rd);
239
240	for (i = 0; i < fb->tile.regions; i++)
241		fb->func->tile.fini(fb, i, &fb->tile.region[i]);
242
243	nvkm_mm_fini(&fb->tags.mm);
244	mutex_destroy(&fb->tags.mutex);
245
246	nvkm_ram_del(&fb->ram);
247
248	nvkm_falcon_fw_dtor(&fb->vpr_scrubber);
249
250	if (fb->sysmem.flush_page) {
251		dma_unmap_page(subdev->device->dev, fb->sysmem.flush_page_addr,
252			       PAGE_SIZE, DMA_BIDIRECTIONAL);
253		__free_page(fb->sysmem.flush_page);
254	}
255
256	if (fb->func->dtor)
257		return fb->func->dtor(fb);
258
259	return fb;
260}
261
262static const struct nvkm_subdev_func
263nvkm_fb = {
264	.dtor = nvkm_fb_dtor,
265	.preinit = nvkm_fb_preinit,
266	.oneinit = nvkm_fb_oneinit,
267	.init = nvkm_fb_init,
268	.intr = nvkm_fb_intr,
269};
270
271int
272nvkm_fb_ctor(const struct nvkm_fb_func *func, struct nvkm_device *device,
273	     enum nvkm_subdev_type type, int inst, struct nvkm_fb *fb)
274{
275	nvkm_subdev_ctor(&nvkm_fb, device, type, inst, &fb->subdev);
276	fb->func = func;
277	fb->tile.regions = fb->func->tile.regions;
278	fb->page = nvkm_longopt(device->cfgopt, "NvFbBigPage", fb->func->default_bigpage);
279	mutex_init(&fb->tags.mutex);
280
281	if (func->sysmem.flush_page_init) {
282		fb->sysmem.flush_page = alloc_page(GFP_KERNEL | GFP_DMA32 | __GFP_ZERO);
283		if (!fb->sysmem.flush_page)
284			return -ENOMEM;
285
286		fb->sysmem.flush_page_addr = dma_map_page(device->dev, fb->sysmem.flush_page,
287							  0, PAGE_SIZE, DMA_BIDIRECTIONAL);
288		if (dma_mapping_error(device->dev, fb->sysmem.flush_page_addr))
289			return -EFAULT;
290	}
291
292	return 0;
293}
294
295int
296nvkm_fb_new_(const struct nvkm_fb_func *func, struct nvkm_device *device,
297	     enum nvkm_subdev_type type, int inst, struct nvkm_fb **pfb)
298{
299	if (!(*pfb = kzalloc(sizeof(**pfb), GFP_KERNEL)))
300		return -ENOMEM;
301	return nvkm_fb_ctor(func, device, type, inst, *pfb);
302}