lsdc_drv.c

  1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 * Copyright (C) 2023 Loongson Technology Corporation Limited
  4 */
  5
  6#include <linux/aperture.h>
  7#include <linux/pci.h>
  8#include <linux/vgaarb.h>
  9
 10#include <drm/clients/drm_client_setup.h>
 11#include <drm/drm_atomic.h>
 12#include <drm/drm_atomic_helper.h>
 13#include <drm/drm_drv.h>
 14#include <drm/drm_fbdev_ttm.h>
 15#include <drm/drm_gem_framebuffer_helper.h>
 16#include <drm/drm_ioctl.h>
 17#include <drm/drm_modeset_helper.h>
 18#include <drm/drm_print.h>
 19#include <drm/drm_probe_helper.h>
 20#include <drm/drm_vblank.h>
 21
 22#include "loongson_module.h"
 23#include "lsdc_drv.h"
 24#include "lsdc_gem.h"
 25#include "lsdc_ttm.h"
 26
 27#define DRIVER_AUTHOR               "Sui Jingfeng <suijingfeng@loongson.cn>"
 28#define DRIVER_NAME                 "loongson"
 29#define DRIVER_DESC                 "drm driver for loongson graphics"
 30#define DRIVER_MAJOR                1
 31#define DRIVER_MINOR                0
 32#define DRIVER_PATCHLEVEL           0
 33
 34DEFINE_DRM_GEM_FOPS(lsdc_gem_fops);
 35
 36static const struct drm_driver lsdc_drm_driver = {
 37	.driver_features = DRIVER_MODESET | DRIVER_RENDER | DRIVER_GEM | DRIVER_ATOMIC,
 38	.fops = &lsdc_gem_fops,
 39
 40	.name = DRIVER_NAME,
 41	.desc = DRIVER_DESC,
 42	.major = DRIVER_MAJOR,
 43	.minor = DRIVER_MINOR,
 44	.patchlevel = DRIVER_PATCHLEVEL,
 45
 46	.debugfs_init = lsdc_debugfs_init,
 47	.dumb_create = lsdc_dumb_create,
 48	.dumb_map_offset = lsdc_dumb_map_offset,
 49	.gem_prime_import_sg_table = lsdc_prime_import_sg_table,
 50	DRM_FBDEV_TTM_DRIVER_OPS,
 51};
 52
 53static const struct drm_mode_config_funcs lsdc_mode_config_funcs = {
 54	.fb_create = drm_gem_fb_create,
 55	.atomic_check = drm_atomic_helper_check,
 56	.atomic_commit = drm_atomic_helper_commit,
 57};
 58
 59/* Display related */
 60
 61static int lsdc_modeset_init(struct lsdc_device *ldev,
 62			     unsigned int num_crtc,
 63			     const struct lsdc_kms_funcs *funcs,
 64			     bool has_vblank)
 65{
 66	struct drm_device *ddev = &ldev->base;
 67	struct lsdc_display_pipe *dispipe;
 68	unsigned int i;
 69	int ret;
 70
 71	for (i = 0; i < num_crtc; i++) {
 72		dispipe = &ldev->dispipe[i];
 73
 74		/* We need an index before crtc is initialized */
 75		dispipe->index = i;
 76
 77		ret = funcs->create_i2c(ddev, dispipe, i);
 78		if (ret)
 79			return ret;
 80	}
 81
 82	for (i = 0; i < num_crtc; i++) {
 83		struct i2c_adapter *ddc = NULL;
 84
 85		dispipe = &ldev->dispipe[i];
 86		if (dispipe->li2c)
 87			ddc = &dispipe->li2c->adapter;
 88
 89		ret = funcs->output_init(ddev, dispipe, ddc, i);
 90		if (ret)
 91			return ret;
 92
 93		ldev->num_output++;
 94	}
 95
 96	for (i = 0; i < num_crtc; i++) {
 97		dispipe = &ldev->dispipe[i];
 98
 99		ret = funcs->primary_plane_init(ddev, &dispipe->primary.base, i);
100		if (ret)
101			return ret;
102
103		ret = funcs->cursor_plane_init(ddev, &dispipe->cursor.base, i);
104		if (ret)
105			return ret;
106
107		ret = funcs->crtc_init(ddev, &dispipe->crtc.base,
108				       &dispipe->primary.base,
109				       &dispipe->cursor.base,
110				       i, has_vblank);
111		if (ret)
112			return ret;
113	}
114
115	drm_info(ddev, "Total %u outputs\n", ldev->num_output);
116
117	return 0;
118}
119
120static const struct drm_mode_config_helper_funcs lsdc_mode_config_helper_funcs = {
121	.atomic_commit_tail = drm_atomic_helper_commit_tail,
122};
123
124static int lsdc_mode_config_init(struct drm_device *ddev,
125				 const struct lsdc_desc *descp)
126{
127	int ret;
128
129	ret = drmm_mode_config_init(ddev);
130	if (ret)
131		return ret;
132
133	ddev->mode_config.funcs = &lsdc_mode_config_funcs;
134	ddev->mode_config.min_width = 1;
135	ddev->mode_config.min_height = 1;
136	ddev->mode_config.max_width = descp->max_width * LSDC_NUM_CRTC;
137	ddev->mode_config.max_height = descp->max_height * LSDC_NUM_CRTC;
138	ddev->mode_config.preferred_depth = 24;
139	ddev->mode_config.prefer_shadow = 1;
140
141	ddev->mode_config.cursor_width = descp->hw_cursor_h;
142	ddev->mode_config.cursor_height = descp->hw_cursor_h;
143
144	ddev->mode_config.helper_private = &lsdc_mode_config_helper_funcs;
145
146	if (descp->has_vblank_counter)
147		ddev->max_vblank_count = 0xffffffff;
148
149	return ret;
150}
151
152/*
153 * The GPU and display controller in the LS7A1000/LS7A2000/LS2K2000 are
154 * separated PCIE devices. They are two devices, not one. Bar 2 of the GPU
155 * device contains the base address and size of the VRAM, both the GPU and
156 * the DC could access the on-board VRAM.
157 */
158static int lsdc_get_dedicated_vram(struct lsdc_device *ldev,
159				   struct pci_dev *pdev_dc,
160				   const struct lsdc_desc *descp)
161{
162	struct drm_device *ddev = &ldev->base;
163	struct pci_dev *pdev_gpu;
164	resource_size_t base, size;
165
166	/*
167	 * The GPU has 00:06.0 as its BDF, while the DC has 00:06.1
168	 * This is true for the LS7A1000, LS7A2000 and LS2K2000.
169	 */
170	pdev_gpu = pci_get_domain_bus_and_slot(pci_domain_nr(pdev_dc->bus),
171					       pdev_dc->bus->number,
172					       PCI_DEVFN(6, 0));
173	if (!pdev_gpu) {
174		drm_err(ddev, "No GPU device, then no VRAM\n");
175		return -ENODEV;
176	}
177
178	base = pci_resource_start(pdev_gpu, 2);
179	size = pci_resource_len(pdev_gpu, 2);
180
181	ldev->vram_base = base;
182	ldev->vram_size = size;
183	ldev->gpu = pdev_gpu;
184
185	drm_info(ddev, "Dedicated vram start: 0x%llx, size: %uMiB\n",
186		 (u64)base, (u32)(size >> 20));
187
188	return (size > SZ_1M) ? 0 : -ENODEV;
189}
190
191static struct lsdc_device *
192lsdc_create_device(struct pci_dev *pdev,
193		   const struct lsdc_desc *descp,
194		   const struct drm_driver *driver)
195{
196	struct lsdc_device *ldev;
197	struct drm_device *ddev;
198	int ret;
199
200	ldev = devm_drm_dev_alloc(&pdev->dev, driver, struct lsdc_device, base);
201	if (IS_ERR(ldev))
202		return ldev;
203
204	ldev->dc = pdev;
205	ldev->descp = descp;
206
207	ddev = &ldev->base;
208
209	loongson_gfxpll_create(ddev, &ldev->gfxpll);
210
211	ret = lsdc_get_dedicated_vram(ldev, pdev, descp);
212	if (ret) {
213		drm_err(ddev, "Init VRAM failed: %d\n", ret);
214		return ERR_PTR(ret);
215	}
216
217	ret = aperture_remove_conflicting_devices(ldev->vram_base,
218						  ldev->vram_size,
219						  driver->name);
220	if (ret) {
221		drm_err(ddev, "Remove firmware framebuffers failed: %d\n", ret);
222		return ERR_PTR(ret);
223	}
224
225	ret = lsdc_ttm_init(ldev);
226	if (ret) {
227		drm_err(ddev, "Memory manager init failed: %d\n", ret);
228		return ERR_PTR(ret);
229	}
230
231	lsdc_gem_init(ddev);
232
233	/* Bar 0 of the DC device contains the MMIO register's base address */
234	ldev->reg_base = pcim_iomap_region(pdev, 0, "lsdc");
235	if (IS_ERR(ldev->reg_base))
236		return ldev->reg_base;
237
238	spin_lock_init(&ldev->reglock);
239
240	ret = lsdc_mode_config_init(ddev, descp);
241	if (ret)
242		return ERR_PTR(ret);
243
244	ret = lsdc_modeset_init(ldev, descp->num_of_crtc, descp->funcs,
245				loongson_vblank);
246	if (ret)
247		return ERR_PTR(ret);
248
249	drm_mode_config_reset(ddev);
250
251	return ldev;
252}
253
254/* For multiple GPU driver instance co-exixt in the system */
255
256static unsigned int lsdc_vga_set_decode(struct pci_dev *pdev, bool state)
257{
258	return VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
259}
260
261static int lsdc_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
262{
263	const struct lsdc_desc *descp;
264	struct drm_device *ddev;
265	struct lsdc_device *ldev;
266	int ret;
267
268	descp = lsdc_device_probe(pdev, ent->driver_data);
269	if (IS_ERR_OR_NULL(descp))
270		return -ENODEV;
271
272	pci_set_master(pdev);
273
274	ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(40));
275	if (ret)
276		return ret;
277
278	ret = pcim_enable_device(pdev);
279	if (ret)
280		return ret;
281
282	dev_info(&pdev->dev, "Found %s, revision: %u",
283		 to_loongson_gfx(descp)->model, pdev->revision);
284
285	ldev = lsdc_create_device(pdev, descp, &lsdc_drm_driver);
286	if (IS_ERR(ldev))
287		return PTR_ERR(ldev);
288
289	ddev = &ldev->base;
290
291	pci_set_drvdata(pdev, ddev);
292
293	vga_client_register(pdev, lsdc_vga_set_decode);
294
295	drm_kms_helper_poll_init(ddev);
296
297	if (loongson_vblank) {
298		ret = drm_vblank_init(ddev, descp->num_of_crtc);
299		if (ret)
300			return ret;
301
302		ret = devm_request_irq(&pdev->dev, pdev->irq,
303				       descp->funcs->irq_handler,
304				       IRQF_SHARED,
305				       dev_name(&pdev->dev), ddev);
306		if (ret) {
307			drm_err(ddev, "Failed to register interrupt: %d\n", ret);
308			return ret;
309		}
310
311		drm_info(ddev, "registered irq: %u\n", pdev->irq);
312	}
313
314	ret = drm_dev_register(ddev, 0);
315	if (ret)
316		return ret;
317
318	drm_client_setup(ddev, NULL);
319
320	return 0;
321}
322
323static void lsdc_pci_remove(struct pci_dev *pdev)
324{
325	struct drm_device *ddev = pci_get_drvdata(pdev);
326
327	drm_dev_unregister(ddev);
328	drm_atomic_helper_shutdown(ddev);
329}
330
331static void lsdc_pci_shutdown(struct pci_dev *pdev)
332{
333	drm_atomic_helper_shutdown(pci_get_drvdata(pdev));
334}
335
336static int lsdc_drm_freeze(struct drm_device *ddev)
337{
338	struct lsdc_device *ldev = to_lsdc(ddev);
339	struct lsdc_bo *lbo;
340	int ret;
341
342	/* unpin all of buffers in the VRAM */
343	mutex_lock(&ldev->gem.mutex);
344	list_for_each_entry(lbo, &ldev->gem.objects, list) {
345		struct ttm_buffer_object *tbo = &lbo->tbo;
346		struct ttm_resource *resource = tbo->resource;
347		unsigned int pin_count = tbo->pin_count;
348
349		drm_dbg(ddev, "bo[%p], size: %zuKiB, type: %s, pin count: %u\n",
350			lbo, lsdc_bo_size(lbo) >> 10,
351			lsdc_mem_type_to_str(resource->mem_type), pin_count);
352
353		if (!pin_count)
354			continue;
355
356		if (resource->mem_type == TTM_PL_VRAM) {
357			ret = lsdc_bo_reserve(lbo);
358			if (unlikely(ret)) {
359				drm_err(ddev, "bo reserve failed: %d\n", ret);
360				continue;
361			}
362
363			do {
364				lsdc_bo_unpin(lbo);
365				--pin_count;
366			} while (pin_count);
367
368			lsdc_bo_unreserve(lbo);
369		}
370	}
371	mutex_unlock(&ldev->gem.mutex);
372
373	lsdc_bo_evict_vram(ddev);
374
375	ret = drm_mode_config_helper_suspend(ddev);
376	if (unlikely(ret)) {
377		drm_err(ddev, "Freeze error: %d", ret);
378		return ret;
379	}
380
381	return 0;
382}
383
384static int lsdc_drm_resume(struct device *dev)
385{
386	struct pci_dev *pdev = to_pci_dev(dev);
387	struct drm_device *ddev = pci_get_drvdata(pdev);
388
389	return drm_mode_config_helper_resume(ddev);
390}
391
392static int lsdc_pm_freeze(struct device *dev)
393{
394	struct pci_dev *pdev = to_pci_dev(dev);
395	struct drm_device *ddev = pci_get_drvdata(pdev);
396
397	return lsdc_drm_freeze(ddev);
398}
399
400static int lsdc_pm_thaw(struct device *dev)
401{
402	return lsdc_drm_resume(dev);
403}
404
405static int lsdc_pm_suspend(struct device *dev)
406{
407	struct pci_dev *pdev = to_pci_dev(dev);
408	int error;
409
410	error = lsdc_pm_freeze(dev);
411	if (error)
412		return error;
413
414	pci_save_state(pdev);
415	/* Shut down the device */
416	pci_disable_device(pdev);
417	pci_set_power_state(pdev, PCI_D3hot);
418
419	return 0;
420}
421
422static int lsdc_pm_resume(struct device *dev)
423{
424	struct pci_dev *pdev = to_pci_dev(dev);
425
426	pci_set_power_state(pdev, PCI_D0);
427
428	pci_restore_state(pdev);
429
430	if (pcim_enable_device(pdev))
431		return -EIO;
432
433	return lsdc_pm_thaw(dev);
434}
435
436static const struct dev_pm_ops lsdc_pm_ops = {
437	.suspend = lsdc_pm_suspend,
438	.resume = lsdc_pm_resume,
439	.freeze = lsdc_pm_freeze,
440	.thaw = lsdc_pm_thaw,
441	.poweroff = lsdc_pm_freeze,
442	.restore = lsdc_pm_resume,
443};
444
445static const struct pci_device_id lsdc_pciid_list[] = {
446	{PCI_VDEVICE(LOONGSON, 0x7a06), CHIP_LS7A1000},
447	{PCI_VDEVICE(LOONGSON, 0x7a36), CHIP_LS7A2000},
448	{ }
449};
450
451struct pci_driver lsdc_pci_driver = {
452	.name = DRIVER_NAME,
453	.id_table = lsdc_pciid_list,
454	.probe = lsdc_pci_probe,
455	.remove = lsdc_pci_remove,
456	.shutdown = lsdc_pci_shutdown,
457	.driver.pm = &lsdc_pm_ops,
458};
459
460MODULE_DEVICE_TABLE(pci, lsdc_pciid_list);
461MODULE_AUTHOR(DRIVER_AUTHOR);
462MODULE_DESCRIPTION(DRIVER_DESC);
463MODULE_LICENSE("GPL");