Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'drm-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6
* 'drm-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6:
vmwgfx: Fix fb VRAM pinning failure due to fragmentation
vmwgfx: Remove initialisation of dev::devname
vmwgfx: Enable use of the vblank system
vmwgfx: vt-switch (master drop) fixes
drm/vmwgfx: Fix breakage introduced by commit "drm: block userspace under allocating buffer and having drivers overwrite it (v2)"
drm: Hold the mutex when dropping the last GEM reference (v2)
drm/gem: handlecount isn't really a kref so don't make it one.
drm: i810/i830: fix locked ioctl variant
drm/radeon/kms: add quirk for MSI K9A2GM motherboard
drm/radeon/kms: fix potential segfault in r600_ioctl_wait_idle
drm: Prune GEM vma entries
drm/radeon/kms: fix up encoder info messages for DFP6
drm/radeon: fix PCI ID 5657 to be an RV410
+248
-122
+10
-29
drivers/gpu/drm/drm_gem.c
+10
-29
drivers/gpu/drm/drm_gem.c
···
148
148
return -ENOMEM;
149
149
150
150
kref_init(&obj->refcount);
151
-
kref_init(&obj->handlecount);
151
+
atomic_set(&obj->handle_count, 0);
152
152
obj->size = size;
153
153
154
154
atomic_inc(&dev->object_count);
···
462
462
}
463
463
EXPORT_SYMBOL(drm_gem_object_free);
464
464
465
-
/**
466
-
* Called after the last reference to the object has been lost.
467
-
* Must be called without holding struct_mutex
468
-
*
469
-
* Frees the object
470
-
*/
471
-
void
472
-
drm_gem_object_free_unlocked(struct kref *kref)
473
-
{
474
-
struct drm_gem_object *obj = (struct drm_gem_object *) kref;
475
-
struct drm_device *dev = obj->dev;
476
-
477
-
if (dev->driver->gem_free_object_unlocked != NULL)
478
-
dev->driver->gem_free_object_unlocked(obj);
479
-
else if (dev->driver->gem_free_object != NULL) {
480
-
mutex_lock(&dev->struct_mutex);
481
-
dev->driver->gem_free_object(obj);
482
-
mutex_unlock(&dev->struct_mutex);
483
-
}
484
-
}
485
-
EXPORT_SYMBOL(drm_gem_object_free_unlocked);
486
-
487
465
static void drm_gem_object_ref_bug(struct kref *list_kref)
488
466
{
489
467
BUG();
···
474
496
* called before drm_gem_object_free or we'll be touching
475
497
* freed memory
476
498
*/
477
-
void
478
-
drm_gem_object_handle_free(struct kref *kref)
499
+
void drm_gem_object_handle_free(struct drm_gem_object *obj)
479
500
{
480
-
struct drm_gem_object *obj = container_of(kref,
481
-
struct drm_gem_object,
482
-
handlecount);
483
501
struct drm_device *dev = obj->dev;
484
502
485
503
/* Remove any name for this object */
···
502
528
struct drm_gem_object *obj = vma->vm_private_data;
503
529
504
530
drm_gem_object_reference(obj);
531
+
532
+
mutex_lock(&obj->dev->struct_mutex);
533
+
drm_vm_open_locked(vma);
534
+
mutex_unlock(&obj->dev->struct_mutex);
505
535
}
506
536
EXPORT_SYMBOL(drm_gem_vm_open);
507
537
···
513
535
{
514
536
struct drm_gem_object *obj = vma->vm_private_data;
515
537
516
-
drm_gem_object_unreference_unlocked(obj);
538
+
mutex_lock(&obj->dev->struct_mutex);
539
+
drm_vm_close_locked(vma);
540
+
drm_gem_object_unreference(obj);
541
+
mutex_unlock(&obj->dev->struct_mutex);
517
542
}
518
543
EXPORT_SYMBOL(drm_gem_vm_close);
519
544
+1
-1
drivers/gpu/drm/drm_info.c
+1
-1
drivers/gpu/drm/drm_info.c
+20
-12
drivers/gpu/drm/drm_vm.c
+20
-12
drivers/gpu/drm/drm_vm.c
···
433
433
mutex_unlock(&dev->struct_mutex);
434
434
}
435
435
436
+
void drm_vm_close_locked(struct vm_area_struct *vma)
437
+
{
438
+
struct drm_file *priv = vma->vm_file->private_data;
439
+
struct drm_device *dev = priv->minor->dev;
440
+
struct drm_vma_entry *pt, *temp;
441
+
442
+
DRM_DEBUG("0x%08lx,0x%08lx\n",
443
+
vma->vm_start, vma->vm_end - vma->vm_start);
444
+
atomic_dec(&dev->vma_count);
445
+
446
+
list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
447
+
if (pt->vma == vma) {
448
+
list_del(&pt->head);
449
+
kfree(pt);
450
+
break;
451
+
}
452
+
}
453
+
}
454
+
436
455
/**
437
456
* \c close method for all virtual memory types.
438
457
*
···
464
445
{
465
446
struct drm_file *priv = vma->vm_file->private_data;
466
447
struct drm_device *dev = priv->minor->dev;
467
-
struct drm_vma_entry *pt, *temp;
468
-
469
-
DRM_DEBUG("0x%08lx,0x%08lx\n",
470
-
vma->vm_start, vma->vm_end - vma->vm_start);
471
-
atomic_dec(&dev->vma_count);
472
448
473
449
mutex_lock(&dev->struct_mutex);
474
-
list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
475
-
if (pt->vma == vma) {
476
-
list_del(&pt->head);
477
-
kfree(pt);
478
-
break;
479
-
}
480
-
}
450
+
drm_vm_close_locked(vma);
481
451
mutex_unlock(&dev->struct_mutex);
482
452
}
483
453
+1
-1
drivers/gpu/drm/i810/i810_dma.c
+1
-1
drivers/gpu/drm/i810/i810_dma.c
+1
-1
drivers/gpu/drm/i830/i830_dma.c
+1
-1
drivers/gpu/drm/i830/i830_dma.c
+2
-4
drivers/gpu/drm/i915/i915_gem.c
+2
-4
drivers/gpu/drm/i915/i915_gem.c
···
136
136
return -ENOMEM;
137
137
138
138
ret = drm_gem_handle_create(file_priv, obj, &handle);
139
+
/* drop reference from allocate - handle holds it now */
140
+
drm_gem_object_unreference_unlocked(obj);
139
141
if (ret) {
140
-
drm_gem_object_unreference_unlocked(obj);
141
142
return ret;
142
143
}
143
-
144
-
/* Sink the floating reference from kref_init(handlecount) */
145
-
drm_gem_object_handle_unreference_unlocked(obj);
146
144
147
145
args->handle = handle;
148
146
return 0;
+3
-1
drivers/gpu/drm/i915/intel_fb.c
+3
-1
drivers/gpu/drm/i915/intel_fb.c
+1
drivers/gpu/drm/nouveau/nouveau_fbcon.c
+1
drivers/gpu/drm/nouveau/nouveau_fbcon.c
+2
-4
drivers/gpu/drm/nouveau/nouveau_gem.c
+2
-4
drivers/gpu/drm/nouveau/nouveau_gem.c
···
167
167
goto out;
168
168
169
169
ret = drm_gem_handle_create(file_priv, nvbo->gem, &req->info.handle);
170
+
/* drop reference from allocate - handle holds it now */
171
+
drm_gem_object_unreference_unlocked(nvbo->gem);
170
172
out:
171
-
drm_gem_object_handle_unreference_unlocked(nvbo->gem);
172
-
173
-
if (ret)
174
-
drm_gem_object_unreference_unlocked(nvbo->gem);
175
173
return ret;
176
174
}
177
175
+1
drivers/gpu/drm/nouveau/nouveau_notifier.c
+1
drivers/gpu/drm/nouveau/nouveau_notifier.c
···
79
79
mutex_lock(&dev->struct_mutex);
80
80
nouveau_bo_unpin(chan->notifier_bo);
81
81
mutex_unlock(&dev->struct_mutex);
82
+
drm_gem_object_handle_unreference_unlocked(chan->notifier_bo->gem);
82
83
drm_gem_object_unreference_unlocked(chan->notifier_bo->gem);
83
84
drm_mm_takedown(&chan->notifier_heap);
84
85
}
+2
-1
drivers/gpu/drm/radeon/r600.c
+2
-1
drivers/gpu/drm/radeon/r600.c
···
3528
3528
/* r7xx hw bug. write to HDP_DEBUG1 followed by fb read
3529
3529
* rather than write to HDP_REG_COHERENCY_FLUSH_CNTL
3530
3530
*/
3531
-
if ((rdev->family >= CHIP_RV770) && (rdev->family <= CHIP_RV740)) {
3531
+
if ((rdev->family >= CHIP_RV770) && (rdev->family <= CHIP_RV740) &&
3532
+
rdev->vram_scratch.ptr) {
3532
3533
void __iomem *ptr = (void *)rdev->vram_scratch.ptr;
3533
3534
u32 tmp;
3534
3535
+9
drivers/gpu/drm/radeon/radeon_atombios.c
+9
drivers/gpu/drm/radeon/radeon_atombios.c
···
317
317
*connector_type = DRM_MODE_CONNECTOR_DVID;
318
318
}
319
319
320
+
/* MSI K9A2GM V2/V3 board has no HDMI or DVI */
321
+
if ((dev->pdev->device == 0x796e) &&
322
+
(dev->pdev->subsystem_vendor == 0x1462) &&
323
+
(dev->pdev->subsystem_device == 0x7302)) {
324
+
if ((supported_device == ATOM_DEVICE_DFP2_SUPPORT) ||
325
+
(supported_device == ATOM_DEVICE_DFP3_SUPPORT))
326
+
return false;
327
+
}
328
+
320
329
/* a-bit f-i90hd - ciaranm on #radeonhd - this board has no DVI */
321
330
if ((dev->pdev->device == 0x7941) &&
322
331
(dev->pdev->subsystem_vendor == 0x147b) &&
+4
-1
drivers/gpu/drm/radeon/radeon_display.c
+4
-1
drivers/gpu/drm/radeon/radeon_display.c
···
349
349
DRM_INFO(" DFP4: %s\n", encoder_names[radeon_encoder->encoder_id]);
350
350
if (devices & ATOM_DEVICE_DFP5_SUPPORT)
351
351
DRM_INFO(" DFP5: %s\n", encoder_names[radeon_encoder->encoder_id]);
352
+
if (devices & ATOM_DEVICE_DFP6_SUPPORT)
353
+
DRM_INFO(" DFP6: %s\n", encoder_names[radeon_encoder->encoder_id]);
352
354
if (devices & ATOM_DEVICE_TV1_SUPPORT)
353
355
DRM_INFO(" TV1: %s\n", encoder_names[radeon_encoder->encoder_id]);
354
356
if (devices & ATOM_DEVICE_CV_SUPPORT)
···
843
841
{
844
842
struct radeon_framebuffer *radeon_fb = to_radeon_framebuffer(fb);
845
843
846
-
if (radeon_fb->obj)
844
+
if (radeon_fb->obj) {
847
845
drm_gem_object_unreference_unlocked(radeon_fb->obj);
846
+
}
848
847
drm_framebuffer_cleanup(fb);
849
848
kfree(radeon_fb);
850
849
}
+4
-10
drivers/gpu/drm/radeon/radeon_fb.c
+4
-10
drivers/gpu/drm/radeon/radeon_fb.c
···
94
94
ret = radeon_bo_reserve(rbo, false);
95
95
if (likely(ret == 0)) {
96
96
radeon_bo_kunmap(rbo);
97
+
radeon_bo_unpin(rbo);
97
98
radeon_bo_unreserve(rbo);
98
99
}
100
+
drm_gem_object_handle_unreference(gobj);
99
101
drm_gem_object_unreference_unlocked(gobj);
100
102
}
101
103
···
327
325
{
328
326
struct fb_info *info;
329
327
struct radeon_framebuffer *rfb = &rfbdev->rfb;
330
-
struct radeon_bo *rbo;
331
-
int r;
332
328
333
329
if (rfbdev->helper.fbdev) {
334
330
info = rfbdev->helper.fbdev;
···
338
338
}
339
339
340
340
if (rfb->obj) {
341
-
rbo = rfb->obj->driver_private;
342
-
r = radeon_bo_reserve(rbo, false);
343
-
if (likely(r == 0)) {
344
-
radeon_bo_kunmap(rbo);
345
-
radeon_bo_unpin(rbo);
346
-
radeon_bo_unreserve(rbo);
347
-
}
348
-
drm_gem_object_unreference_unlocked(rfb->obj);
341
+
radeonfb_destroy_pinned_object(rfb->obj);
342
+
rfb->obj = NULL;
349
343
}
350
344
drm_fb_helper_fini(&rfbdev->helper);
351
345
drm_framebuffer_cleanup(&rfb->base);
+2
-2
drivers/gpu/drm/radeon/radeon_gem.c
+2
-2
drivers/gpu/drm/radeon/radeon_gem.c
···
201
201
return r;
202
202
}
203
203
r = drm_gem_handle_create(filp, gobj, &handle);
204
+
/* drop reference from allocate - handle holds it now */
205
+
drm_gem_object_unreference_unlocked(gobj);
204
206
if (r) {
205
-
drm_gem_object_unreference_unlocked(gobj);
206
207
return r;
207
208
}
208
-
drm_gem_object_handle_unreference_unlocked(gobj);
209
209
args->handle = handle;
210
210
return 0;
211
211
}
+110
-35
drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
+110
-35
drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
···
148
148
{0, 0, 0}
149
149
};
150
150
151
-
static char *vmw_devname = "vmwgfx";
151
+
static int enable_fbdev;
152
152
153
153
static int vmw_probe(struct pci_dev *, const struct pci_device_id *);
154
154
static void vmw_master_init(struct vmw_master *);
155
155
static int vmwgfx_pm_notifier(struct notifier_block *nb, unsigned long val,
156
156
void *ptr);
157
+
158
+
MODULE_PARM_DESC(enable_fbdev, "Enable vmwgfx fbdev");
159
+
module_param_named(enable_fbdev, enable_fbdev, int, 0600);
157
160
158
161
static void vmw_print_capabilities(uint32_t capabilities)
159
162
{
···
195
192
{
196
193
int ret;
197
194
198
-
vmw_kms_save_vga(dev_priv);
199
-
200
195
ret = vmw_fifo_init(dev_priv, &dev_priv->fifo);
201
196
if (unlikely(ret != 0)) {
202
197
DRM_ERROR("Unable to initialize FIFO.\n");
···
207
206
static void vmw_release_device(struct vmw_private *dev_priv)
208
207
{
209
208
vmw_fifo_release(dev_priv, &dev_priv->fifo);
210
-
vmw_kms_restore_vga(dev_priv);
211
209
}
212
210
211
+
int vmw_3d_resource_inc(struct vmw_private *dev_priv)
212
+
{
213
+
int ret = 0;
214
+
215
+
mutex_lock(&dev_priv->release_mutex);
216
+
if (unlikely(dev_priv->num_3d_resources++ == 0)) {
217
+
ret = vmw_request_device(dev_priv);
218
+
if (unlikely(ret != 0))
219
+
--dev_priv->num_3d_resources;
220
+
}
221
+
mutex_unlock(&dev_priv->release_mutex);
222
+
return ret;
223
+
}
224
+
225
+
226
+
void vmw_3d_resource_dec(struct vmw_private *dev_priv)
227
+
{
228
+
int32_t n3d;
229
+
230
+
mutex_lock(&dev_priv->release_mutex);
231
+
if (unlikely(--dev_priv->num_3d_resources == 0))
232
+
vmw_release_device(dev_priv);
233
+
n3d = (int32_t) dev_priv->num_3d_resources;
234
+
mutex_unlock(&dev_priv->release_mutex);
235
+
236
+
BUG_ON(n3d < 0);
237
+
}
213
238
214
239
static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
215
240
{
···
255
228
dev_priv->last_read_sequence = (uint32_t) -100;
256
229
mutex_init(&dev_priv->hw_mutex);
257
230
mutex_init(&dev_priv->cmdbuf_mutex);
231
+
mutex_init(&dev_priv->release_mutex);
258
232
rwlock_init(&dev_priv->resource_lock);
259
233
idr_init(&dev_priv->context_idr);
260
234
idr_init(&dev_priv->surface_idr);
···
271
243
dev_priv->io_start = pci_resource_start(dev->pdev, 0);
272
244
dev_priv->vram_start = pci_resource_start(dev->pdev, 1);
273
245
dev_priv->mmio_start = pci_resource_start(dev->pdev, 2);
246
+
247
+
dev_priv->enable_fb = enable_fbdev;
274
248
275
249
mutex_lock(&dev_priv->hw_mutex);
276
250
···
373
343
374
344
dev->dev_private = dev_priv;
375
345
376
-
if (!dev->devname)
377
-
dev->devname = vmw_devname;
378
-
379
-
if (dev_priv->capabilities & SVGA_CAP_IRQMASK) {
380
-
ret = drm_irq_install(dev);
381
-
if (unlikely(ret != 0)) {
382
-
DRM_ERROR("Failed installing irq: %d\n", ret);
383
-
goto out_no_irq;
384
-
}
385
-
}
386
-
387
346
ret = pci_request_regions(dev->pdev, "vmwgfx probe");
388
347
dev_priv->stealth = (ret != 0);
389
348
if (dev_priv->stealth) {
···
388
369
goto out_no_device;
389
370
}
390
371
}
391
-
ret = vmw_request_device(dev_priv);
372
+
ret = vmw_kms_init(dev_priv);
392
373
if (unlikely(ret != 0))
393
-
goto out_no_device;
394
-
vmw_kms_init(dev_priv);
374
+
goto out_no_kms;
395
375
vmw_overlay_init(dev_priv);
396
-
vmw_fb_init(dev_priv);
376
+
if (dev_priv->enable_fb) {
377
+
ret = vmw_3d_resource_inc(dev_priv);
378
+
if (unlikely(ret != 0))
379
+
goto out_no_fifo;
380
+
vmw_kms_save_vga(dev_priv);
381
+
vmw_fb_init(dev_priv);
382
+
DRM_INFO("%s", vmw_fifo_have_3d(dev_priv) ?
383
+
"Detected device 3D availability.\n" :
384
+
"Detected no device 3D availability.\n");
385
+
} else {
386
+
DRM_INFO("Delayed 3D detection since we're not "
387
+
"running the device in SVGA mode yet.\n");
388
+
}
389
+
390
+
if (dev_priv->capabilities & SVGA_CAP_IRQMASK) {
391
+
ret = drm_irq_install(dev);
392
+
if (unlikely(ret != 0)) {
393
+
DRM_ERROR("Failed installing irq: %d\n", ret);
394
+
goto out_no_irq;
395
+
}
396
+
}
397
397
398
398
dev_priv->pm_nb.notifier_call = vmwgfx_pm_notifier;
399
399
register_pm_notifier(&dev_priv->pm_nb);
400
400
401
-
DRM_INFO("%s", vmw_fifo_have_3d(dev_priv) ? "Have 3D\n" : "No 3D\n");
402
-
403
401
return 0;
404
402
405
-
out_no_device:
406
-
if (dev_priv->capabilities & SVGA_CAP_IRQMASK)
407
-
drm_irq_uninstall(dev_priv->dev);
408
-
if (dev->devname == vmw_devname)
409
-
dev->devname = NULL;
410
403
out_no_irq:
404
+
if (dev_priv->enable_fb) {
405
+
vmw_fb_close(dev_priv);
406
+
vmw_kms_restore_vga(dev_priv);
407
+
vmw_3d_resource_dec(dev_priv);
408
+
}
409
+
out_no_fifo:
410
+
vmw_overlay_close(dev_priv);
411
+
vmw_kms_close(dev_priv);
412
+
out_no_kms:
413
+
if (dev_priv->stealth)
414
+
pci_release_region(dev->pdev, 2);
415
+
else
416
+
pci_release_regions(dev->pdev);
417
+
out_no_device:
411
418
ttm_object_device_release(&dev_priv->tdev);
412
419
out_err4:
413
420
iounmap(dev_priv->mmio_virt);
···
460
415
461
416
unregister_pm_notifier(&dev_priv->pm_nb);
462
417
463
-
vmw_fb_close(dev_priv);
418
+
if (dev_priv->capabilities & SVGA_CAP_IRQMASK)
419
+
drm_irq_uninstall(dev_priv->dev);
420
+
if (dev_priv->enable_fb) {
421
+
vmw_fb_close(dev_priv);
422
+
vmw_kms_restore_vga(dev_priv);
423
+
vmw_3d_resource_dec(dev_priv);
424
+
}
464
425
vmw_kms_close(dev_priv);
465
426
vmw_overlay_close(dev_priv);
466
-
vmw_release_device(dev_priv);
467
427
if (dev_priv->stealth)
468
428
pci_release_region(dev->pdev, 2);
469
429
else
470
430
pci_release_regions(dev->pdev);
471
431
472
-
if (dev_priv->capabilities & SVGA_CAP_IRQMASK)
473
-
drm_irq_uninstall(dev_priv->dev);
474
-
if (dev->devname == vmw_devname)
475
-
dev->devname = NULL;
476
432
ttm_object_device_release(&dev_priv->tdev);
477
433
iounmap(dev_priv->mmio_virt);
478
434
drm_mtrr_del(dev_priv->mmio_mtrr, dev_priv->mmio_start,
···
546
500
struct drm_ioctl_desc *ioctl =
547
501
&vmw_ioctls[nr - DRM_COMMAND_BASE];
548
502
549
-
if (unlikely(ioctl->cmd != cmd)) {
503
+
if (unlikely(ioctl->cmd_drv != cmd)) {
550
504
DRM_ERROR("Invalid command format, ioctl %d\n",
551
505
nr - DRM_COMMAND_BASE);
552
506
return -EINVAL;
···
635
589
struct vmw_master *vmaster = vmw_master(file_priv->master);
636
590
int ret = 0;
637
591
592
+
if (!dev_priv->enable_fb) {
593
+
ret = vmw_3d_resource_inc(dev_priv);
594
+
if (unlikely(ret != 0))
595
+
return ret;
596
+
vmw_kms_save_vga(dev_priv);
597
+
mutex_lock(&dev_priv->hw_mutex);
598
+
vmw_write(dev_priv, SVGA_REG_TRACES, 0);
599
+
mutex_unlock(&dev_priv->hw_mutex);
600
+
}
601
+
638
602
if (active) {
639
603
BUG_ON(active != &dev_priv->fbdev_master);
640
604
ret = ttm_vt_lock(&active->lock, false, vmw_fp->tfile);
···
673
617
return 0;
674
618
675
619
out_no_active_lock:
676
-
vmw_release_device(dev_priv);
620
+
if (!dev_priv->enable_fb) {
621
+
mutex_lock(&dev_priv->hw_mutex);
622
+
vmw_write(dev_priv, SVGA_REG_TRACES, 1);
623
+
mutex_unlock(&dev_priv->hw_mutex);
624
+
vmw_kms_restore_vga(dev_priv);
625
+
vmw_3d_resource_dec(dev_priv);
626
+
}
677
627
return ret;
678
628
}
679
629
···
707
645
708
646
ttm_lock_set_kill(&vmaster->lock, true, SIGTERM);
709
647
648
+
if (!dev_priv->enable_fb) {
649
+
ret = ttm_bo_evict_mm(&dev_priv->bdev, TTM_PL_VRAM);
650
+
if (unlikely(ret != 0))
651
+
DRM_ERROR("Unable to clean VRAM on master drop.\n");
652
+
mutex_lock(&dev_priv->hw_mutex);
653
+
vmw_write(dev_priv, SVGA_REG_TRACES, 1);
654
+
mutex_unlock(&dev_priv->hw_mutex);
655
+
vmw_kms_restore_vga(dev_priv);
656
+
vmw_3d_resource_dec(dev_priv);
657
+
}
658
+
710
659
dev_priv->active_master = &dev_priv->fbdev_master;
711
660
ttm_lock_set_kill(&dev_priv->fbdev_master.lock, false, SIGTERM);
712
661
ttm_vt_unlock(&dev_priv->fbdev_master.lock);
713
662
714
-
vmw_fb_on(dev_priv);
663
+
if (dev_priv->enable_fb)
664
+
vmw_fb_on(dev_priv);
715
665
}
716
666
717
667
···
796
722
.irq_postinstall = vmw_irq_postinstall,
797
723
.irq_uninstall = vmw_irq_uninstall,
798
724
.irq_handler = vmw_irq_handler,
725
+
.get_vblank_counter = vmw_get_vblank_counter,
799
726
.reclaim_buffers_locked = NULL,
800
727
.get_map_ofs = drm_core_get_map_ofs,
801
728
.get_reg_ofs = drm_core_get_reg_ofs,
+8
drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
+8
drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
···
277
277
278
278
bool stealth;
279
279
bool is_opened;
280
+
bool enable_fb;
280
281
281
282
/**
282
283
* Master management.
···
286
285
struct vmw_master *active_master;
287
286
struct vmw_master fbdev_master;
288
287
struct notifier_block pm_nb;
288
+
289
+
struct mutex release_mutex;
290
+
uint32_t num_3d_resources;
289
291
};
290
292
291
293
static inline struct vmw_private *vmw_priv(struct drm_device *dev)
···
322
318
val = inl(dev_priv->io_start + VMWGFX_VALUE_PORT);
323
319
return val;
324
320
}
321
+
322
+
int vmw_3d_resource_inc(struct vmw_private *dev_priv);
323
+
void vmw_3d_resource_dec(struct vmw_private *dev_priv);
325
324
326
325
/**
327
326
* GMR utilities - vmwgfx_gmr.c
···
518
511
unsigned bbp, unsigned depth);
519
512
int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data,
520
513
struct drm_file *file_priv);
514
+
u32 vmw_get_vblank_counter(struct drm_device *dev, int crtc);
521
515
522
516
/**
523
517
* Overlay control - vmwgfx_overlay.c
+5
drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
+5
drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
···
615
615
if (unlikely(ret != 0))
616
616
goto err_unlock;
617
617
618
+
if (bo->mem.mem_type == TTM_PL_VRAM &&
619
+
bo->mem.mm_node->start < bo->num_pages)
620
+
(void) ttm_bo_validate(bo, &vmw_sys_placement, false,
621
+
false, false);
622
+
618
623
ret = ttm_bo_validate(bo, &ne_placement, false, false, false);
619
624
620
625
/* Could probably bug on */
+3
drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c
+3
drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c
···
106
106
mutex_lock(&dev_priv->hw_mutex);
107
107
dev_priv->enable_state = vmw_read(dev_priv, SVGA_REG_ENABLE);
108
108
dev_priv->config_done_state = vmw_read(dev_priv, SVGA_REG_CONFIG_DONE);
109
+
dev_priv->traces_state = vmw_read(dev_priv, SVGA_REG_TRACES);
109
110
vmw_write(dev_priv, SVGA_REG_ENABLE, 1);
110
111
111
112
min = 4;
···
176
175
dev_priv->config_done_state);
177
176
vmw_write(dev_priv, SVGA_REG_ENABLE,
178
177
dev_priv->enable_state);
178
+
vmw_write(dev_priv, SVGA_REG_TRACES,
179
+
dev_priv->traces_state);
179
180
180
181
mutex_unlock(&dev_priv->hw_mutex);
181
182
vmw_fence_queue_takedown(&fifo->fence_queue);
+17
drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
+17
drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
···
898
898
save->width = vmw_read(vmw_priv, SVGA_REG_DISPLAY_WIDTH);
899
899
save->height = vmw_read(vmw_priv, SVGA_REG_DISPLAY_HEIGHT);
900
900
vmw_write(vmw_priv, SVGA_REG_DISPLAY_ID, SVGA_ID_INVALID);
901
+
if (i == 0 && vmw_priv->num_displays == 1 &&
902
+
save->width == 0 && save->height == 0) {
903
+
904
+
/*
905
+
* It should be fairly safe to assume that these
906
+
* values are uninitialized.
907
+
*/
908
+
909
+
save->width = vmw_priv->vga_width - save->pos_x;
910
+
save->height = vmw_priv->vga_height - save->pos_y;
911
+
}
901
912
}
913
+
902
914
return 0;
903
915
}
904
916
···
995
983
out_unlock:
996
984
ttm_read_unlock(&vmaster->lock);
997
985
return ret;
986
+
}
987
+
988
+
u32 vmw_get_vblank_counter(struct drm_device *dev, int crtc)
989
+
{
990
+
return 0;
998
991
}
+17
-10
drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
+17
-10
drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
···
27
27
28
28
#include "vmwgfx_kms.h"
29
29
30
+
#define VMWGFX_LDU_NUM_DU 8
31
+
30
32
#define vmw_crtc_to_ldu(x) \
31
33
container_of(x, struct vmw_legacy_display_unit, base.crtc)
32
34
#define vmw_encoder_to_ldu(x) \
···
538
536
539
537
int vmw_kms_init_legacy_display_system(struct vmw_private *dev_priv)
540
538
{
539
+
struct drm_device *dev = dev_priv->dev;
540
+
int i;
541
+
int ret;
542
+
541
543
if (dev_priv->ldu_priv) {
542
544
DRM_INFO("ldu system already on\n");
543
545
return -EINVAL;
···
559
553
560
554
drm_mode_create_dirty_info_property(dev_priv->dev);
561
555
562
-
vmw_ldu_init(dev_priv, 0);
563
-
/* for old hardware without multimon only enable one display */
564
556
if (dev_priv->capabilities & SVGA_CAP_MULTIMON) {
565
-
vmw_ldu_init(dev_priv, 1);
566
-
vmw_ldu_init(dev_priv, 2);
567
-
vmw_ldu_init(dev_priv, 3);
568
-
vmw_ldu_init(dev_priv, 4);
569
-
vmw_ldu_init(dev_priv, 5);
570
-
vmw_ldu_init(dev_priv, 6);
571
-
vmw_ldu_init(dev_priv, 7);
557
+
for (i = 0; i < VMWGFX_LDU_NUM_DU; ++i)
558
+
vmw_ldu_init(dev_priv, i);
559
+
ret = drm_vblank_init(dev, VMWGFX_LDU_NUM_DU);
560
+
} else {
561
+
/* for old hardware without multimon only enable one display */
562
+
vmw_ldu_init(dev_priv, 0);
563
+
ret = drm_vblank_init(dev, 1);
572
564
}
573
565
574
-
return 0;
566
+
return ret;
575
567
}
576
568
577
569
int vmw_kms_close_legacy_display_system(struct vmw_private *dev_priv)
578
570
{
571
+
struct drm_device *dev = dev_priv->dev;
572
+
573
+
drm_vblank_cleanup(dev);
579
574
if (!dev_priv->ldu_priv)
580
575
return -ENOSYS;
581
576
+4
drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
+4
drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
···
211
211
cmd->body.cid = cpu_to_le32(res->id);
212
212
213
213
vmw_fifo_commit(dev_priv, sizeof(*cmd));
214
+
vmw_3d_resource_dec(dev_priv);
214
215
}
215
216
216
217
static int vmw_context_init(struct vmw_private *dev_priv,
···
248
247
cmd->body.cid = cpu_to_le32(res->id);
249
248
250
249
vmw_fifo_commit(dev_priv, sizeof(*cmd));
250
+
(void) vmw_3d_resource_inc(dev_priv);
251
251
vmw_resource_activate(res, vmw_hw_context_destroy);
252
252
return 0;
253
253
}
···
408
406
cmd->body.sid = cpu_to_le32(res->id);
409
407
410
408
vmw_fifo_commit(dev_priv, sizeof(*cmd));
409
+
vmw_3d_resource_dec(dev_priv);
411
410
}
412
411
413
412
void vmw_surface_res_free(struct vmw_resource *res)
···
476
473
}
477
474
478
475
vmw_fifo_commit(dev_priv, submit_size);
476
+
(void) vmw_3d_resource_inc(dev_priv);
479
477
vmw_resource_activate(res, vmw_hw_surface_destroy);
480
478
return 0;
481
479
}
+20
-9
include/drm/drmP.h
+20
-9
include/drm/drmP.h
···
612
612
struct kref refcount;
613
613
614
614
/** Handle count of this object. Each handle also holds a reference */
615
-
struct kref handlecount;
615
+
atomic_t handle_count; /* number of handles on this object */
616
616
617
617
/** Related drm device */
618
618
struct drm_device *dev;
···
808
808
*/
809
809
int (*gem_init_object) (struct drm_gem_object *obj);
810
810
void (*gem_free_object) (struct drm_gem_object *obj);
811
-
void (*gem_free_object_unlocked) (struct drm_gem_object *obj);
812
811
813
812
/* vga arb irq handler */
814
813
void (*vgaarb_irq)(struct drm_device *dev, bool state);
···
1174
1175
extern int drm_mmap(struct file *filp, struct vm_area_struct *vma);
1175
1176
extern int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma);
1176
1177
extern void drm_vm_open_locked(struct vm_area_struct *vma);
1178
+
extern void drm_vm_close_locked(struct vm_area_struct *vma);
1177
1179
extern resource_size_t drm_core_get_map_ofs(struct drm_local_map * map);
1178
1180
extern resource_size_t drm_core_get_reg_ofs(struct drm_device *dev);
1179
1181
extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait);
···
1455
1455
void drm_gem_destroy(struct drm_device *dev);
1456
1456
void drm_gem_object_release(struct drm_gem_object *obj);
1457
1457
void drm_gem_object_free(struct kref *kref);
1458
-
void drm_gem_object_free_unlocked(struct kref *kref);
1459
1458
struct drm_gem_object *drm_gem_object_alloc(struct drm_device *dev,
1460
1459
size_t size);
1461
1460
int drm_gem_object_init(struct drm_device *dev,
1462
1461
struct drm_gem_object *obj, size_t size);
1463
-
void drm_gem_object_handle_free(struct kref *kref);
1462
+
void drm_gem_object_handle_free(struct drm_gem_object *obj);
1464
1463
void drm_gem_vm_open(struct vm_area_struct *vma);
1465
1464
void drm_gem_vm_close(struct vm_area_struct *vma);
1466
1465
int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma);
···
1482
1483
static inline void
1483
1484
drm_gem_object_unreference_unlocked(struct drm_gem_object *obj)
1484
1485
{
1485
-
if (obj != NULL)
1486
-
kref_put(&obj->refcount, drm_gem_object_free_unlocked);
1486
+
if (obj != NULL) {
1487
+
struct drm_device *dev = obj->dev;
1488
+
mutex_lock(&dev->struct_mutex);
1489
+
kref_put(&obj->refcount, drm_gem_object_free);
1490
+
mutex_unlock(&dev->struct_mutex);
1491
+
}
1487
1492
}
1488
1493
1489
1494
int drm_gem_handle_create(struct drm_file *file_priv,
···
1498
1495
drm_gem_object_handle_reference(struct drm_gem_object *obj)
1499
1496
{
1500
1497
drm_gem_object_reference(obj);
1501
-
kref_get(&obj->handlecount);
1498
+
atomic_inc(&obj->handle_count);
1502
1499
}
1503
1500
1504
1501
static inline void
···
1507
1504
if (obj == NULL)
1508
1505
return;
1509
1506
1507
+
if (atomic_read(&obj->handle_count) == 0)
1508
+
return;
1510
1509
/*
1511
1510
* Must bump handle count first as this may be the last
1512
1511
* ref, in which case the object would disappear before we
1513
1512
* checked for a name
1514
1513
*/
1515
-
kref_put(&obj->handlecount, drm_gem_object_handle_free);
1514
+
if (atomic_dec_and_test(&obj->handle_count))
1515
+
drm_gem_object_handle_free(obj);
1516
1516
drm_gem_object_unreference(obj);
1517
1517
}
1518
1518
···
1525
1519
if (obj == NULL)
1526
1520
return;
1527
1521
1522
+
if (atomic_read(&obj->handle_count) == 0)
1523
+
return;
1524
+
1528
1525
/*
1529
1526
* Must bump handle count first as this may be the last
1530
1527
* ref, in which case the object would disappear before we
1531
1528
* checked for a name
1532
1529
*/
1533
-
kref_put(&obj->handlecount, drm_gem_object_handle_free);
1530
+
1531
+
if (atomic_dec_and_test(&obj->handle_count))
1532
+
drm_gem_object_handle_free(obj);
1534
1533
drm_gem_object_unreference_unlocked(obj);
1535
1534
}
1536
1535
+1
-1
include/drm/drm_pciids.h
+1
-1
include/drm/drm_pciids.h
···
85
85
{0x1002, 0x5460, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \
86
86
{0x1002, 0x5462, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \
87
87
{0x1002, 0x5464, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \
88
-
{0x1002, 0x5657, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
89
88
{0x1002, 0x5548, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \
90
89
{0x1002, 0x5549, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \
91
90
{0x1002, 0x554A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \
···
102
103
{0x1002, 0x564F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
103
104
{0x1002, 0x5652, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
104
105
{0x1002, 0x5653, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
106
+
{0x1002, 0x5657, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \
105
107
{0x1002, 0x5834, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP}, \
106
108
{0x1002, 0x5835, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP|RADEON_IS_MOBILITY}, \
107
109
{0x1002, 0x5954, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS480|RADEON_IS_IGP|RADEON_IS_MOBILITY|RADEON_IS_IGPGART}, \