1 2 #include <sys/cdefs.h> 3 #include <dev/drm2/drmP.h> 4 5 #include <dev/agp/agpreg.h> 6 #include <dev/pci/pcireg.h> 7 8 MALLOC_DEFINE(DRM_MEM_DMA, "drm_dma", "DRM DMA Data Structures"); 9 MALLOC_DEFINE(DRM_MEM_SAREA, "drm_sarea", "DRM SAREA Data Structures"); 10 MALLOC_DEFINE(DRM_MEM_DRIVER, "drm_driver", "DRM DRIVER Data Structures"); 11 MALLOC_DEFINE(DRM_MEM_MAGIC, "drm_magic", "DRM MAGIC Data Structures"); 12 MALLOC_DEFINE(DRM_MEM_MINOR, "drm_minor", "DRM MINOR Data Structures"); 13 MALLOC_DEFINE(DRM_MEM_IOCTLS, "drm_ioctls", "DRM IOCTL Data Structures"); 14 MALLOC_DEFINE(DRM_MEM_MAPS, "drm_maps", "DRM MAP Data Structures"); 15 MALLOC_DEFINE(DRM_MEM_BUFS, "drm_bufs", "DRM BUFFER Data Structures"); 16 MALLOC_DEFINE(DRM_MEM_SEGS, "drm_segs", "DRM SEGMENTS Data Structures"); 17 MALLOC_DEFINE(DRM_MEM_PAGES, "drm_pages", "DRM PAGES Data Structures"); 18 MALLOC_DEFINE(DRM_MEM_FILES, "drm_files", "DRM FILE Data Structures"); 19 MALLOC_DEFINE(DRM_MEM_QUEUES, "drm_queues", "DRM QUEUE Data Structures"); 20 MALLOC_DEFINE(DRM_MEM_CMDS, "drm_cmds", "DRM COMMAND Data Structures"); 21 MALLOC_DEFINE(DRM_MEM_MAPPINGS, "drm_mapping", "DRM MAPPING Data Structures"); 22 MALLOC_DEFINE(DRM_MEM_BUFLISTS, "drm_buflists", "DRM BUFLISTS Data Structures"); 23 MALLOC_DEFINE(DRM_MEM_AGPLISTS, "drm_agplists", "DRM AGPLISTS Data Structures"); 24 MALLOC_DEFINE(DRM_MEM_CTXBITMAP, "drm_ctxbitmap", 25 "DRM CTXBITMAP Data Structures"); 26 MALLOC_DEFINE(DRM_MEM_SGLISTS, "drm_sglists", "DRM SGLISTS Data Structures"); 27 MALLOC_DEFINE(DRM_MEM_MM, "drm_sman", "DRM MEMORY MANAGER Data Structures"); 28 MALLOC_DEFINE(DRM_MEM_HASHTAB, "drm_hashtab", "DRM HASHTABLE Data Structures"); 29 MALLOC_DEFINE(DRM_MEM_KMS, "drm_kms", "DRM KMS Data Structures"); 30 MALLOC_DEFINE(DRM_MEM_VBLANK, "drm_vblank", "DRM VBLANK Handling Data"); 31 32 const char *fb_mode_option = NULL; 33 34 #define NSEC_PER_USEC 1000L 35 #define NSEC_PER_SEC 1000000000L 36 37 int64_t 38 timeval_to_ns(const struct timeval *tv) 39 { 40 return ((int64_t)tv->tv_sec * NSEC_PER_SEC) + 41 tv->tv_usec * NSEC_PER_USEC; 42 } 43 44 struct timeval 45 ns_to_timeval(const int64_t nsec) 46 { 47 struct timeval tv; 48 long rem; 49 50 if (nsec == 0) { 51 tv.tv_sec = 0; 52 tv.tv_usec = 0; 53 return (tv); 54 } 55 56 tv.tv_sec = nsec / NSEC_PER_SEC; 57 rem = nsec % NSEC_PER_SEC; 58 if (rem < 0) { 59 tv.tv_sec--; 60 rem += NSEC_PER_SEC; 61 } 62 tv.tv_usec = rem / 1000; 63 return (tv); 64 } 65 66 /* Copied from OFED. */ 67 unsigned long drm_linux_timer_hz_mask; 68 69 static void 70 drm_linux_timer_init(void *arg) 71 { 72 73 /* 74 * Compute an internal HZ value which can divide 2**32 to 75 * avoid timer rounding problems when the tick value wraps 76 * around 2**32: 77 */ 78 drm_linux_timer_hz_mask = 1; 79 while (drm_linux_timer_hz_mask < (unsigned long)hz) 80 drm_linux_timer_hz_mask *= 2; 81 drm_linux_timer_hz_mask--; 82 } 83 SYSINIT(drm_linux_timer, SI_SUB_DRIVERS, SI_ORDER_FIRST, drm_linux_timer_init, NULL); 84 85 static const drm_pci_id_list_t * 86 drm_find_description(int vendor, int device, const drm_pci_id_list_t *idlist) 87 { 88 int i = 0; 89 90 for (i = 0; idlist[i].vendor != 0; i++) { 91 if ((idlist[i].vendor == vendor) && 92 ((idlist[i].device == device) || 93 (idlist[i].device == 0))) { 94 return (&idlist[i]); 95 } 96 } 97 return (NULL); 98 } 99 100 /* 101 * drm_probe_helper: called by a driver at the end of its probe 102 * method. 103 */ 104 int 105 drm_probe_helper(device_t kdev, const drm_pci_id_list_t *idlist) 106 { 107 const drm_pci_id_list_t *id_entry; 108 int vendor, device; 109 110 vendor = pci_get_vendor(kdev); 111 device = pci_get_device(kdev); 112 113 if (pci_get_class(kdev) != PCIC_DISPLAY || 114 (pci_get_subclass(kdev) != PCIS_DISPLAY_VGA && 115 pci_get_subclass(kdev) != PCIS_DISPLAY_OTHER)) 116 return (-ENXIO); 117 118 id_entry = drm_find_description(vendor, device, idlist); 119 if (id_entry != NULL) { 120 if (device_get_desc(kdev) == NULL) { 121 DRM_DEBUG("%s desc: %s\n", 122 device_get_nameunit(kdev), id_entry->name); 123 device_set_desc(kdev, id_entry->name); 124 } 125 #if !defined(__arm__) 126 DRM_OBSOLETE(kdev); 127 #endif 128 return (-BUS_PROBE_GENERIC); 129 } 130 131 return (-ENXIO); 132 } 133 134 /* 135 * drm_attach_helper: called by a driver at the end of its attach 136 * method. 137 */ 138 int 139 drm_attach_helper(device_t kdev, const drm_pci_id_list_t *idlist, 140 struct drm_driver *driver) 141 { 142 struct drm_device *dev; 143 int vendor, device; 144 int ret; 145 146 dev = device_get_softc(kdev); 147 148 vendor = pci_get_vendor(kdev); 149 device = pci_get_device(kdev); 150 dev->id_entry = drm_find_description(vendor, device, idlist); 151 152 ret = drm_get_pci_dev(kdev, dev, driver); 153 154 return (ret); 155 } 156 157 int 158 drm_generic_suspend(device_t kdev) 159 { 160 struct drm_device *dev; 161 int error; 162 163 DRM_DEBUG_KMS("Starting suspend\n"); 164 165 dev = device_get_softc(kdev); 166 if (dev->driver->suspend) { 167 pm_message_t state; 168 169 state.event = PM_EVENT_SUSPEND; 170 error = -dev->driver->suspend(dev, state); 171 if (error) 172 goto out; 173 } 174 175 error = bus_generic_suspend(kdev); 176 177 out: 178 DRM_DEBUG_KMS("Finished suspend: %d\n", error); 179 180 return error; 181 } 182 183 int 184 drm_generic_resume(device_t kdev) 185 { 186 struct drm_device *dev; 187 int error; 188 189 DRM_DEBUG_KMS("Starting resume\n"); 190 191 dev = device_get_softc(kdev); 192 if (dev->driver->resume) { 193 error = -dev->driver->resume(dev); 194 if (error) 195 goto out; 196 } 197 198 error = bus_generic_resume(kdev); 199 200 out: 201 DRM_DEBUG_KMS("Finished resume: %d\n", error); 202 203 return error; 204 } 205 206 int 207 drm_generic_detach(device_t kdev) 208 { 209 struct drm_device *dev; 210 int i; 211 212 dev = device_get_softc(kdev); 213 214 drm_put_dev(dev); 215 216 /* Clean up PCI resources allocated by drm_bufs.c. We're not really 217 * worried about resource consumption while the DRM is inactive (between 218 * lastclose and firstopen or unload) because these aren't actually 219 * taking up KVA, just keeping the PCI resource allocated. 220 */ 221 for (i = 0; i < DRM_MAX_PCI_RESOURCE; i++) { 222 if (dev->pcir[i] == NULL) 223 continue; 224 bus_release_resource(dev->dev, SYS_RES_MEMORY, 225 dev->pcirid[i], dev->pcir[i]); 226 dev->pcir[i] = NULL; 227 } 228 229 if (pci_disable_busmaster(dev->dev)) 230 DRM_ERROR("Request to disable bus-master failed.\n"); 231 232 return (0); 233 } 234 235 int 236 drm_add_busid_modesetting(struct drm_device *dev, struct sysctl_ctx_list *ctx, 237 struct sysctl_oid *top) 238 { 239 struct sysctl_oid *oid; 240 241 snprintf(dev->busid_str, sizeof(dev->busid_str), 242 "pci:%04x:%02x:%02x.%d", dev->pci_domain, dev->pci_bus, 243 dev->pci_slot, dev->pci_func); 244 oid = SYSCTL_ADD_STRING(ctx, SYSCTL_CHILDREN(top), OID_AUTO, "busid", 245 CTLFLAG_RD, dev->busid_str, 0, NULL); 246 if (oid == NULL) 247 return (-ENOMEM); 248 dev->modesetting = (dev->driver->driver_features & DRIVER_MODESET) != 0; 249 oid = SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(top), OID_AUTO, 250 "modesetting", CTLFLAG_RD, &dev->modesetting, 0, NULL); 251 if (oid == NULL) 252 return (-ENOMEM); 253 254 return (0); 255 } 256 257 static int 258 drm_device_find_capability(struct drm_device *dev, int cap) 259 { 260 261 return (pci_find_cap(dev->dev, cap, NULL) == 0); 262 } 263 264 int 265 drm_pci_device_is_agp(struct drm_device *dev) 266 { 267 if (dev->driver->device_is_agp != NULL) { 268 int ret; 269 270 /* device_is_agp returns a tristate, 0 = not AGP, 1 = definitely 271 * AGP, 2 = fall back to PCI capability 272 */ 273 ret = (*dev->driver->device_is_agp)(dev); 274 if (ret != DRM_MIGHT_BE_AGP) 275 return ret; 276 } 277 278 return (drm_device_find_capability(dev, PCIY_AGP)); 279 } 280 281 int 282 drm_pci_device_is_pcie(struct drm_device *dev) 283 { 284 285 return (drm_device_find_capability(dev, PCIY_EXPRESS)); 286 } 287 288 static bool 289 dmi_found(const struct dmi_system_id *dsi) 290 { 291 char *hw_vendor, *hw_prod; 292 int i, slot; 293 bool res; 294 295 hw_vendor = kern_getenv("smbios.planar.maker"); 296 hw_prod = kern_getenv("smbios.planar.product"); 297 res = true; 298 for (i = 0; i < nitems(dsi->matches); i++) { 299 slot = dsi->matches[i].slot; 300 switch (slot) { 301 case DMI_NONE: 302 break; 303 case DMI_SYS_VENDOR: 304 case DMI_BOARD_VENDOR: 305 if (hw_vendor != NULL && 306 !strcmp(hw_vendor, dsi->matches[i].substr)) { 307 break; 308 } else { 309 res = false; 310 goto out; 311 } 312 case DMI_PRODUCT_NAME: 313 case DMI_BOARD_NAME: 314 if (hw_prod != NULL && 315 !strcmp(hw_prod, dsi->matches[i].substr)) { 316 break; 317 } else { 318 res = false; 319 goto out; 320 } 321 default: 322 res = false; 323 goto out; 324 } 325 } 326 out: 327 freeenv(hw_vendor); 328 freeenv(hw_prod); 329 330 return (res); 331 } 332 333 bool 334 dmi_check_system(const struct dmi_system_id *sysid) 335 { 336 const struct dmi_system_id *dsi; 337 bool res; 338 339 for (res = false, dsi = sysid; dsi->matches[0].slot != 0 ; dsi++) { 340 if (dmi_found(dsi)) { 341 res = true; 342 if (dsi->callback != NULL && dsi->callback(dsi)) 343 break; 344 } 345 } 346 return (res); 347 } 348 349 #if __OS_HAS_MTRR 350 int 351 drm_mtrr_add(unsigned long offset, unsigned long size, unsigned int flags) 352 { 353 int act; 354 struct mem_range_desc mrdesc; 355 356 mrdesc.mr_base = offset; 357 mrdesc.mr_len = size; 358 mrdesc.mr_flags = flags; 359 act = MEMRANGE_SET_UPDATE; 360 strlcpy(mrdesc.mr_owner, "drm", sizeof(mrdesc.mr_owner)); 361 return (-mem_range_attr_set(&mrdesc, &act)); 362 } 363 364 int 365 drm_mtrr_del(int handle __unused, unsigned long offset, unsigned long size, 366 unsigned int flags) 367 { 368 int act; 369 struct mem_range_desc mrdesc; 370 371 mrdesc.mr_base = offset; 372 mrdesc.mr_len = size; 373 mrdesc.mr_flags = flags; 374 act = MEMRANGE_SET_REMOVE; 375 strlcpy(mrdesc.mr_owner, "drm", sizeof(mrdesc.mr_owner)); 376 return (-mem_range_attr_set(&mrdesc, &act)); 377 } 378 #endif 379 380 void 381 drm_clflush_pages(vm_page_t *pages, unsigned long num_pages) 382 { 383 384 #if defined(__i386__) || defined(__amd64__) 385 pmap_invalidate_cache_pages(pages, num_pages); 386 #else 387 DRM_ERROR("drm_clflush_pages not implemented on this architecture"); 388 #endif 389 } 390 391 void 392 drm_clflush_virt_range(char *addr, unsigned long length) 393 { 394 395 #if defined(__i386__) || defined(__amd64__) 396 pmap_force_invalidate_cache_range((vm_offset_t)addr, 397 (vm_offset_t)addr + length); 398 #else 399 DRM_ERROR("drm_clflush_virt_range not implemented on this architecture"); 400 #endif 401 } 402 403 void 404 hex_dump_to_buffer(const void *buf, size_t len, int rowsize, int groupsize, 405 char *linebuf, size_t linebuflen, bool ascii __unused) 406 { 407 int i, j, c; 408 409 i = j = 0; 410 411 while (i < len && j <= linebuflen) { 412 c = ((const char *)buf)[i]; 413 414 if (i != 0) { 415 if (i % rowsize == 0) { 416 /* Newline required. */ 417 sprintf(linebuf + j, "\n"); 418 ++j; 419 } else if (i % groupsize == 0) { 420 /* Space required. */ 421 sprintf(linebuf + j, " "); 422 ++j; 423 } 424 } 425 426 if (j > linebuflen - 4) 427 break; 428 429 sprintf(linebuf + j, "%02X", c); 430 j += 2; 431 432 ++i; 433 } 434 435 if (j <= linebuflen) 436 sprintf(linebuf + j, "\n"); 437 } 438 439 #if DRM_LINUX 440 441 #include <sys/sysproto.h> 442 443 MODULE_DEPEND(DRIVER_NAME, linux, 1, 1, 1); 444 445 #define LINUX_IOCTL_DRM_MIN 0x6400 446 #define LINUX_IOCTL_DRM_MAX 0x64ff 447 448 static linux_ioctl_function_t drm_linux_ioctl; 449 static struct linux_ioctl_handler drm_handler = {drm_linux_ioctl, 450 LINUX_IOCTL_DRM_MIN, LINUX_IOCTL_DRM_MAX}; 451 452 /* The bits for in/out are switched on Linux */ 453 #define LINUX_IOC_IN IOC_OUT 454 #define LINUX_IOC_OUT IOC_IN 455 456 static int 457 drm_linux_ioctl(DRM_STRUCTPROC *p, struct linux_ioctl_args* args) 458 { 459 int error; 460 int cmd = args->cmd; 461 462 args->cmd &= ~(LINUX_IOC_IN | LINUX_IOC_OUT); 463 if (cmd & LINUX_IOC_IN) 464 args->cmd |= IOC_IN; 465 if (cmd & LINUX_IOC_OUT) 466 args->cmd |= IOC_OUT; 467 468 error = ioctl(p, (struct ioctl_args *)args); 469 470 return error; 471 } 472 #endif /* DRM_LINUX */ 473 474 static int 475 drm_modevent(module_t mod, int type, void *data) 476 { 477 478 switch (type) { 479 case MOD_LOAD: 480 TUNABLE_INT_FETCH("drm.debug", &drm_debug); 481 TUNABLE_INT_FETCH("drm.notyet", &drm_notyet); 482 break; 483 } 484 return (0); 485 } 486 487 static moduledata_t drm_mod = { 488 "drmn", 489 drm_modevent, 490 0 491 }; 492 493 DECLARE_MODULE(drmn, drm_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST); 494 MODULE_VERSION(drmn, 1); 495 MODULE_DEPEND(drmn, agp, 1, 1, 1); 496 MODULE_DEPEND(drmn, pci, 1, 1, 1); 497 MODULE_DEPEND(drmn, mem, 1, 1, 1); 498 MODULE_DEPEND(drmn, iicbus, 1, 1, 1); 499