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 34 DEFINE_DRM_GEM_FOPS(lsdc_gem_fops); 35 36 static 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 53 static 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 61 static 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 120 static const struct drm_mode_config_helper_funcs lsdc_mode_config_helper_funcs = { 121 .atomic_commit_tail = drm_atomic_helper_commit_tail, 122 }; 123 124 static 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 */ 158 static 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 191 static struct lsdc_device * 192 lsdc_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 256 static 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 261 static 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 323 static 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 331 static void lsdc_pci_shutdown(struct pci_dev *pdev) 332 { 333 drm_atomic_helper_shutdown(pci_get_drvdata(pdev)); 334 } 335 336 static 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 384 static 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 392 static 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 400 static int lsdc_pm_thaw(struct device *dev) 401 { 402 return lsdc_drm_resume(dev); 403 } 404 405 static 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 422 static 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 436 static 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 445 static 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 451 struct 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 460 MODULE_DEVICE_TABLE(pci, lsdc_pciid_list); 461 MODULE_AUTHOR(DRIVER_AUTHOR); 462 MODULE_DESCRIPTION(DRIVER_DESC); 463 MODULE_LICENSE("GPL"); 464