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