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 | |
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 | |
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(dev: 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 | */ |
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(domain: pci_domain_nr(bus: pdev_dc->bus), |
170 | bus: 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 (size > SZ_1M) ? 0 : -ENODEV; |
188 | } |
189 | |
190 | static struct lsdc_device * |
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(ptr: ldev)) |
201 | return ldev; |
202 | |
203 | ldev->dc = pdev; |
204 | ldev->descp = descp; |
205 | |
206 | ddev = &ldev->base; |
207 | |
208 | loongson_gfxpll_create(ddev, ppout: &ldev->gfxpll); |
209 | |
210 | ret = lsdc_get_dedicated_vram(ldev, pdev_dc: pdev, descp); |
211 | if (ret) { |
212 | drm_err(ddev, "Init VRAM failed: %d\n" , ret); |
213 | return ERR_PTR(error: ret); |
214 | } |
215 | |
216 | ret = drm_aperture_remove_conflicting_framebuffers(base: ldev->vram_base, |
217 | size: ldev->vram_size, |
218 | req_driver: driver); |
219 | if (ret) { |
220 | drm_err(ddev, "Remove firmware framebuffers failed: %d\n" , ret); |
221 | return ERR_PTR(error: 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(error: 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, bar: 0, maxlen: 0); |
234 | if (!ldev->reg_base) |
235 | return ERR_PTR(error: -ENODEV); |
236 | |
237 | spin_lock_init(&ldev->reglock); |
238 | |
239 | ret = lsdc_mode_config_init(ddev, descp); |
240 | if (ret) |
241 | return ERR_PTR(error: ret); |
242 | |
243 | ret = lsdc_modeset_init(ldev, num_crtc: descp->num_of_crtc, funcs: descp->funcs, |
244 | has_vblank: loongson_vblank); |
245 | if (ret) |
246 | return ERR_PTR(error: ret); |
247 | |
248 | drm_mode_config_reset(dev: ddev); |
249 | |
250 | return ldev; |
251 | } |
252 | |
253 | /* For multiple GPU driver instance co-exixt in the system */ |
254 | |
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 | |
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, chip: ent->driver_data); |
268 | if (IS_ERR_OR_NULL(ptr: descp)) |
269 | return -ENODEV; |
270 | |
271 | pci_set_master(dev: pdev); |
272 | |
273 | ret = dma_set_mask_and_coherent(dev: &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, driver: &lsdc_drm_driver); |
285 | if (IS_ERR(ptr: ldev)) |
286 | return PTR_ERR(ptr: ldev); |
287 | |
288 | ddev = &ldev->base; |
289 | |
290 | pci_set_drvdata(pdev, data: ddev); |
291 | |
292 | vga_client_register(pdev, set_decode: lsdc_vga_set_decode); |
293 | |
294 | drm_kms_helper_poll_init(dev: ddev); |
295 | |
296 | if (loongson_vblank) { |
297 | ret = drm_vblank_init(dev: ddev, num_crtcs: descp->num_of_crtc); |
298 | if (ret) |
299 | return ret; |
300 | |
301 | ret = devm_request_irq(dev: &pdev->dev, irq: pdev->irq, |
302 | handler: descp->funcs->irq_handler, |
303 | IRQF_SHARED, |
304 | devname: dev_name(dev: &pdev->dev), dev_id: 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(dev: ddev, flags: 0); |
314 | if (ret) |
315 | return ret; |
316 | |
317 | drm_fbdev_generic_setup(dev: ddev, preferred_bpp: 32); |
318 | |
319 | return 0; |
320 | } |
321 | |
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(dev: ddev); |
327 | drm_atomic_helper_shutdown(dev: ddev); |
328 | } |
329 | |
330 | static void lsdc_pci_shutdown(struct pci_dev *pdev) |
331 | { |
332 | drm_atomic_helper_shutdown(dev: pci_get_drvdata(pdev)); |
333 | } |
334 | |
335 | static int lsdc_drm_freeze(struct drm_device *ddev) |
336 | { |
337 | struct lsdc_device *ldev = to_lsdc(ddev); |
338 | struct lsdc_bo *lbo; |
339 | int ret; |
340 | |
341 | /* unpin all of buffers in the VRAM */ |
342 | mutex_lock(&ldev->gem.mutex); |
343 | list_for_each_entry(lbo, &ldev->gem.objects, list) { |
344 | struct ttm_buffer_object *tbo = &lbo->tbo; |
345 | struct ttm_resource *resource = tbo->resource; |
346 | unsigned int pin_count = tbo->pin_count; |
347 | |
348 | drm_dbg(ddev, "bo[%p], size: %zuKiB, type: %s, pin count: %u\n" , |
349 | lbo, lsdc_bo_size(lbo) >> 10, |
350 | lsdc_mem_type_to_str(resource->mem_type), pin_count); |
351 | |
352 | if (!pin_count) |
353 | continue; |
354 | |
355 | if (resource->mem_type == TTM_PL_VRAM) { |
356 | ret = lsdc_bo_reserve(lbo); |
357 | if (unlikely(ret)) { |
358 | drm_err(ddev, "bo reserve failed: %d\n" , ret); |
359 | continue; |
360 | } |
361 | |
362 | do { |
363 | lsdc_bo_unpin(lbo); |
364 | --pin_count; |
365 | } while (pin_count); |
366 | |
367 | lsdc_bo_unreserve(lbo); |
368 | } |
369 | } |
370 | mutex_unlock(lock: &ldev->gem.mutex); |
371 | |
372 | lsdc_bo_evict_vram(ddev); |
373 | |
374 | ret = drm_mode_config_helper_suspend(dev: ddev); |
375 | if (unlikely(ret)) { |
376 | drm_err(ddev, "Freeze error: %d" , ret); |
377 | return ret; |
378 | } |
379 | |
380 | return 0; |
381 | } |
382 | |
383 | static int lsdc_drm_resume(struct device *dev) |
384 | { |
385 | struct pci_dev *pdev = to_pci_dev(dev); |
386 | struct drm_device *ddev = pci_get_drvdata(pdev); |
387 | |
388 | return drm_mode_config_helper_resume(dev: ddev); |
389 | } |
390 | |
391 | static int lsdc_pm_freeze(struct device *dev) |
392 | { |
393 | struct pci_dev *pdev = to_pci_dev(dev); |
394 | struct drm_device *ddev = pci_get_drvdata(pdev); |
395 | |
396 | return lsdc_drm_freeze(ddev); |
397 | } |
398 | |
399 | static int lsdc_pm_thaw(struct device *dev) |
400 | { |
401 | return lsdc_drm_resume(dev); |
402 | } |
403 | |
404 | static int lsdc_pm_suspend(struct device *dev) |
405 | { |
406 | struct pci_dev *pdev = to_pci_dev(dev); |
407 | int error; |
408 | |
409 | error = lsdc_pm_freeze(dev); |
410 | if (error) |
411 | return error; |
412 | |
413 | pci_save_state(dev: pdev); |
414 | /* Shut down the device */ |
415 | pci_disable_device(dev: pdev); |
416 | pci_set_power_state(dev: pdev, PCI_D3hot); |
417 | |
418 | return 0; |
419 | } |
420 | |
421 | static int lsdc_pm_resume(struct device *dev) |
422 | { |
423 | struct pci_dev *pdev = to_pci_dev(dev); |
424 | |
425 | pci_set_power_state(dev: pdev, PCI_D0); |
426 | |
427 | pci_restore_state(dev: pdev); |
428 | |
429 | if (pcim_enable_device(pdev)) |
430 | return -EIO; |
431 | |
432 | return lsdc_pm_thaw(dev); |
433 | } |
434 | |
435 | static const struct dev_pm_ops lsdc_pm_ops = { |
436 | .suspend = lsdc_pm_suspend, |
437 | .resume = lsdc_pm_resume, |
438 | .freeze = lsdc_pm_freeze, |
439 | .thaw = lsdc_pm_thaw, |
440 | .poweroff = lsdc_pm_freeze, |
441 | .restore = lsdc_pm_resume, |
442 | }; |
443 | |
444 | static const struct pci_device_id lsdc_pciid_list[] = { |
445 | {PCI_VDEVICE(LOONGSON, 0x7a06), CHIP_LS7A1000}, |
446 | {PCI_VDEVICE(LOONGSON, 0x7a36), CHIP_LS7A2000}, |
447 | { } |
448 | }; |
449 | |
450 | struct pci_driver lsdc_pci_driver = { |
451 | .name = DRIVER_NAME, |
452 | .id_table = lsdc_pciid_list, |
453 | .probe = lsdc_pci_probe, |
454 | .remove = lsdc_pci_remove, |
455 | .shutdown = lsdc_pci_shutdown, |
456 | .driver.pm = &lsdc_pm_ops, |
457 | }; |
458 | |
459 | MODULE_DEVICE_TABLE(pci, lsdc_pciid_list); |
460 | MODULE_AUTHOR(DRIVER_AUTHOR); |
461 | MODULE_DESCRIPTION(DRIVER_DESC); |
462 | MODULE_LICENSE("GPL" ); |
463 | |