Attachment #490868 for bug #629062




#if (NV_KMEM_CACHE_CREATE_ARGUMENT_COUNT == 5)
#define NV_KMEM_CACHE_CREATE_FULL(name, size, align, flags, ctor) \
    kmem_cache_create(name, size, align, flags, ctor)
#define NV_KMEM_CACHE_CREATE_FULL_USERCOPY(name, size, align, flags, useroffset, usersize, ctor) \
    kmem_cache_create_usercopy(name, size, align, flags, useroffset, usersize, ctor)
#else
#define NV_KMEM_CACHE_CREATE_FULL(name, size, align, flags, ctor) \
    kmem_cache_create(name, size, align, flags, ctor, NULL)

#define NV_KMEM_CACHE_CREATE(name, type)    \
    NV_KMEM_CACHE_CREATE_FULL(name, sizeof(type), 0, 0, NULL)

#ifdef SLAB_USERCOPY
#define NV_KMEM_CACHE_CREATE_USERCOPY(name, type)    \
    NV_KMEM_CACHE_CREATE_FULL(name, sizeof(type), 0, SLAB_USERCOPY, NULL)
#else
#define NV_KMEM_CACHE_CREATE_USERCOPY(name, type)    \
    NV_KMEM_CACHE_CREATE_FULL_USERCOPY(name, sizeof(type), 0, 0, 0, sizeof(type), NULL)
#endif

#define NV_KMEM_CACHE_DESTROY(kmem_cache)   \
    kmem_cache_destroy(kmem_cache)


Lines 72-78 typedef struct { Link Here

(-)work.orig/kernel/common/inc/nv-modeset-interface.h (-3 / +3 lines)
72	* mix nvidia and nvidia-modeset kernel modules from different	72	* mix nvidia and nvidia-modeset kernel modules from different
73	* releases.	73	* releases.
74	*/	74	*/
75	const char *version_string;	75	// const char *version_string;
76		76
77	/*	77	/*
78	* Return system information.	78	* Return system information.
Lines 115-122 typedef struct { Link Here
115		115
116	int (set_callbacks)(const nvidia_modeset_callbacks_t cb);	116	int (set_callbacks)(const nvidia_modeset_callbacks_t cb);
117		117
118	} nvidia_modeset_rm_ops_t;	118	} __do_const nvidia_modeset_rm_ops_t;
119		119
120	NV_STATUS nvidia_get_rm_ops(nvidia_modeset_rm_ops_t *rm_ops);	120	NV_STATUS nvidia_get_rm_ops(const nvidia_modeset_rm_ops_t rm_ops, const char version_string);
121		121
122	#endif /* _NV_MODESET_INTERFACE_H_ */	122	#endif /* _NV_MODESET_INTERFACE_H_ */

Lines 34-40 typedef struct nvidia_module_s { Link Here

(-)work.orig/kernel/common/inc/nv-register-module.h (-1 / +1 lines)
34	int (ioctl)(struct inode , struct file * file, unsigned int cmd, unsigned long arg);	34	int (ioctl)(struct inode , struct file * file, unsigned int cmd, unsigned long arg);
35	unsigned int (poll)(struct file file, poll_table *wait);	35	unsigned int (poll)(struct file file, poll_table *wait);
36		36
37	} nvidia_module_t;	37	} __do_const nvidia_module_t;
38		38
39	int nvidia_register_module(nvidia_module_t *);	39	int nvidia_register_module(nvidia_module_t *);
40	int nvidia_unregister_module(nvidia_module_t *);	40	int nvidia_unregister_module(nvidia_module_t *);

Lines 682-688 int __init nvidia_init_module(void) Link Here

(-)work.orig/kernel/nvidia/nv.c (-1 / +1 lines)
682		682
683	nv_memdbg_init();	683	nv_memdbg_init();
684		684
685	nvidia_stack_t_cache = NV_KMEM_CACHE_CREATE(nvidia_stack_cache_name,	685	nvidia_stack_t_cache = NV_KMEM_CACHE_CREATE_USERCOPY(nvidia_stack_cache_name,
686	nvidia_stack_t);	686	nvidia_stack_t);
687	if (nvidia_stack_t_cache == NULL)	687	if (nvidia_stack_t_cache == NULL)
688	{	688	{

Lines 20-27 int nv_register_chrdev(void *param) Link Here

(-)work.orig/kernel/nvidia/nv-chrdev.c (-2 lines)
20	{	20	{
21	nvidia_module_t module = (nvidia_module_t )param;	21	nvidia_module_t module = (nvidia_module_t )param;
22		22
23	module->instance = nv_module_instance;
24
25	return (nvidia_register_module(module));	23	return (nvidia_register_module(module));
26	}	24	}
27		25

Lines 51-56 struct pci_driver nv_pci_driver = { Link Here

(-)work.orig/kernel/nvidia/nv-instance.c (+1 lines)
51	nvidia_module_t nv_fops = {	51	nvidia_module_t nv_fops = {
52	.owner = THIS_MODULE,	52	.owner = THIS_MODULE,
53	.module_name = MODULE_NAME,	53	.module_name = MODULE_NAME,
		54	.instance = MODULE_INSTANCE_NUMBER,
54	.open = nvidia_open,	55	.open = nvidia_open,
55	.close = nvidia_close,	56	.close = nvidia_close,
56	.ioctl = nvidia_ioctl,	57	.ioctl = nvidia_ioctl,




}

#if defined(NV_VM_OPERATIONS_STRUCT_HAS_ACCESS)
static ssize_t
nvidia_vma_access(
    struct vm_area_struct *vma,
    unsigned long addr,
    void *buffer,
    size_t length,
    int write
)
{




 * _NVRM_COPYRIGHT_END_
 */

#include "nv-modeset-interface.h"

#include "nv-misc.h"
#include "os-interface.h"
#include "nv-linux.h"
#include "nvstatus.h"
#include "nv.h"

#include "nv-modeset-interface.h"

static const nvidia_modeset_callbacks_t *nv_modeset_callbacks;

static int nvidia_modeset_rm_ops_alloc_stack(nvidia_stack_t **sp)

    return count;
}

NV_STATUS nvidia_get_rm_ops(const nvidia_modeset_rm_ops_t **rm_ops, const char **version_string)
{
    static const nvidia_modeset_rm_ops_t local_rm_ops = {
        .version_string = NV_VERSION_STRING,
        .system_info    = {
            .allow_write_combining = NV_FALSE,
        },

        .set_callbacks  = nvidia_modeset_set_callbacks,
    };

    static const nvidia_modeset_rm_ops_t local_rm_ops_wc = {
        .system_info    = {
            .allow_write_combining = NV_TRUE,
        },
        .alloc_stack    = nvidia_modeset_rm_ops_alloc_stack,
        .free_stack     = nvidia_modeset_rm_ops_free_stack,
        .enumerate_gpus = nvidia_modeset_enumerate_gpus,
        .open_gpu       = nvidia_dev_get,
        .close_gpu      = nvidia_dev_put,
        .op             = rm_kernel_rmapi_op, /* provided by nv-kernel.o */
        .set_callbacks  = nvidia_modeset_set_callbacks,
    };

    if (strcmp(*version_string, NV_VERSION_STRING) != 0)
    {
        *version_string = NV_VERSION_STRING;
        return NV_ERR_GENERIC;
    }

    *rm_ops = NV_ALLOW_WRITE_COMBINING(NV_MEMORY_TYPE_FRAMEBUFFER) ? &local_rm_ops_wc : &local_rm_ops;

    if (NV_ALLOW_WRITE_COMBINING(NV_MEMORY_TYPE_FRAMEBUFFER)) {
        rm_ops->system_info.allow_write_combining = NV_TRUE;
    }

    return NV_OK;
}

Lines 716-721 static void nvidia_update_drm_driver_fea Link Here

(-)work.orig/kernel/nvidia-drm/nvidia-drm-drv.c (+2 lines)
716	return;	716	return;
717	}	717	}
718		718
		719	pax_open_kernel();
719	nv_drm_driver.driver_features \|= DRIVER_MODESET \| DRIVER_ATOMIC;	720	nv_drm_driver.driver_features \|= DRIVER_MODESET \| DRIVER_ATOMIC;
720		721
721	nv_drm_driver.master_set = nvidia_drm_master_set;	722	nv_drm_driver.master_set = nvidia_drm_master_set;
Lines 726-731 static void nvidia_update_drm_driver_fea Link Here
726	nv_drm_driver.dumb_destroy = drm_gem_dumb_destroy;	727	nv_drm_driver.dumb_destroy = drm_gem_dumb_destroy;
727		728
728	nv_drm_driver.gem_vm_ops = &nv_drm_gem_vma_ops;	729	nv_drm_driver.gem_vm_ops = &nv_drm_gem_vma_ops;
		730	pax_close_kernel();
729	#endif /* NV_DRM_ATOMIC_MODESET_AVAILABLE */	731	#endif /* NV_DRM_ATOMIC_MODESET_AVAILABLE */
730	}	732	}
731		733




 * Interface with resman.
 *************************************************************************/

static const nvidia_modeset_rm_ops_t *__rm_ops;
static nvidia_modeset_callbacks_t nvkms_rm_callbacks = {
    .suspend = nvkms_suspend,
    .resume = nvkms_resume
};

static int nvkms_alloc_rm(void)
{
    NV_STATUS nvstatus;
    int ret;
    const char *version_string = NV_VERSION_STRING;

    nvstatus = nvidia_get_rm_ops(&__rm_ops, &version_string);

    nvstatus = nvidia_get_rm_ops(&__rm_ops);

    if (nvstatus != NV_OK) {
        printk(KERN_ERR NVKMS_LOG_PREFIX "Version mismatch: "
               "nvidia.ko(%s) nvidia-modeset.ko(%s)\n",
               version_string, NV_VERSION_STRING);
        return -EINVAL;
    }

    ret = __rm_ops->set_callbacks(&nvkms_rm_callbacks);
    if (ret < 0) {
        printk(KERN_ERR NVKMS_LOG_PREFIX "Failed to register callbacks\n");
        return ret;


static void nvkms_free_rm(void)
{
    __rm_ops->set_callbacks(NULL);
}

void NVKMS_API_CALL nvkms_call_rm(void *ops)
{
    nvidia_modeset_stack_ptr stack = NULL;

    if (__rm_ops->alloc_stack(&stack) != 0) {
        return;
    }

    __rm_ops->op(stack, ops);

    __rm_ops->free_stack(stack);
}

/*************************************************************************

    nvidia_modeset_stack_ptr stack = NULL;
    NvBool ret;

    if (__rm_ops->alloc_stack(&stack) != 0) {
        return NV_FALSE;
    }

    ret = __rm_ops->open_gpu(gpuId, stack) == 0;

    __rm_ops->free_stack(stack);

    return ret;
}

{
    nvidia_modeset_stack_ptr stack = NULL;

    if (__rm_ops->alloc_stack(&stack) != 0) {
        return;
    }

    __rm_ops->close_gpu(gpuId, stack);

    __rm_ops->free_stack(stack);
}

NvU32 NVKMS_API_CALL nvkms_enumerate_gpus(nv_gpu_info_t *gpu_info)
{
    return __rm_ops->enumerate_gpus(gpu_info);
}

NvBool NVKMS_API_CALL nvkms_allow_write_combining(void)
{
    return __rm_ops->system_info.allow_write_combining;
}

/*************************************************************************




#include "nv_uvm_interface.h"

uvm_global_t g_uvm_global;
static struct UvmOpsUvmEvents g_exported_uvm8_ops = {
    .startDevice = NULL,
    .stopDevice  = NULL,
    .isrTopHalf  = uvm8_isr_top_half,
};
static bool g_ops_registered = false;

static NV_STATUS uvm8_register_callbacks(void)
{
    NV_STATUS status = NV_OK;

    g_exported_uvm8_ops.startDevice = NULL;
    g_exported_uvm8_ops.stopDevice  = NULL;
    g_exported_uvm8_ops.isrTopHalf  = uvm8_isr_top_half;

    // Register the UVM callbacks with the main GPU driver:
    status = uvm_rm_locked_call(nvUvmInterfaceRegisterUvmCallbacks(&g_exported_uvm8_ops));
    if (status != NV_OK)

Lines 368-374 void uvm_gpu_semaphore_set_payload(uvm_g Link Here

(-)work.orig/kernel/nvidia-uvm/uvm8_gpu_semaphore.c (-1 / +1 lines)
368	// being optimized out on non-SMP configs (we need them for interacting with	368	// being optimized out on non-SMP configs (we need them for interacting with
369	// the GPU correctly even on non-SMP).	369	// the GPU correctly even on non-SMP).
370	mb();	370	mb();
371	ACCESS_ONCE(*semaphore->payload) = payload;	371	ACCESS_ONCE_RW(*semaphore->payload) = payload;
372	}	372	}
373		373
374	// This function is intended to catch channels which have been left dangling in	374	// This function is intended to catch channels which have been left dangling in

Lines 437-443 typedef struct Link Here

(-)work.orig/kernel/nvidia-uvm/uvm8_hal.h (-1 / +1 lines)
437	uvm_access_counter_buffer_hal_t access_counter_buffer_ops;	437	uvm_access_counter_buffer_hal_t access_counter_buffer_ops;
438		438
439	} u;	439	} u;
440	} uvm_hal_class_ops_t;	440	} __do_const uvm_hal_class_ops_t;
441		441
442	NV_STATUS uvm_hal_init_table(void);	442	NV_STATUS uvm_hal_init_table(void);
443	NV_STATUS uvm_hal_init_gpu(uvm_gpu_t *gpu);	443	NV_STATUS uvm_hal_init_gpu(uvm_gpu_t *gpu);

Lines 24-30 Link Here

(-)work.orig/kernel/nvidia-uvm/uvm8_mmu.h (-1 lines)
24	#ifndef __UVM8_MMU_H__	24	#ifndef __UVM8_MMU_H__
25	#define __UVM8_MMU_H__	25	#define __UVM8_MMU_H__
26		26
27	#include "uvm8_forward_decl.h"
28	#include "uvm8_hal_types.h"	27	#include "uvm8_hal_types.h"
29	#include "uvm8_pmm_gpu.h"	28	#include "uvm8_pmm_gpu.h"
30	#include "uvmtypes.h"	29	#include "uvmtypes.h"

Lines 40-46 Link Here

(-)work.orig/kernel/nvidia-uvm/uvm_common.c (-1 lines)
40	#define UVM_SPIN_LOOP_PRINT_TIMEOUT_SEC 30ULL	40	#define UVM_SPIN_LOOP_PRINT_TIMEOUT_SEC 30ULL
41		41
42	static dev_t g_uvmBaseDev;	42	static dev_t g_uvmBaseDev;
43	struct UvmOpsUvmEvents g_exportedUvmOps;
44		43
45	static char* uvm_driver_mode = "8";	44	static char* uvm_driver_mode = "8";
46		45

Lines 438-444 static inline NvU64 NV_GETTIME(void) Link Here

(-)work.orig/kernel/nvidia-uvm/uvm_linux.h (-1 / +1 lines)
438		438
439	// WRITE_ONCE/READ_ONCE have incompatible definitions across versions, which produces warnings.	439	// WRITE_ONCE/READ_ONCE have incompatible definitions across versions, which produces warnings.
440	// Therefore, we define our own macros	440	// Therefore, we define our own macros
441	#define UVM_WRITE_ONCE(x, val) (ACCESS_ONCE(x) = (val))	441	#define UVM_WRITE_ONCE(x, val) (ACCESS_ONCE_RW(x) = (val))
442	#define UVM_READ_ONCE(x) ACCESS_ONCE(x)	442	#define UVM_READ_ONCE(x) ACCESS_ONCE(x)
443		443
444	// Added in 3.11	444	// Added in 3.11

Return to bug 629062

Lines 1194-1200 extern void *nvidia_stack_t_cache; Link Here

(-)work.orig/kernel/common/inc/nv-linux.h (-1 / +10 lines)
1194	#if (NV_KMEM_CACHE_CREATE_ARGUMENT_COUNT == 5)	1194	#if (NV_KMEM_CACHE_CREATE_ARGUMENT_COUNT == 5)
1195	#define NV_KMEM_CACHE_CREATE_FULL(name, size, align, flags, ctor) \	1195	#define NV_KMEM_CACHE_CREATE_FULL(name, size, align, flags, ctor) \
1196	kmem_cache_create(name, size, align, flags, ctor)	1196	kmem_cache_create(name, size, align, flags, ctor)
1197		1197	#define NV_KMEM_CACHE_CREATE_FULL_USERCOPY(name, size, align, flags, useroffset, usersize, ctor) \
		1198	kmem_cache_create_usercopy(name, size, align, flags, useroffset, usersize, ctor)
1198	#else	1199	#else
1199	#define NV_KMEM_CACHE_CREATE_FULL(name, size, align, flags, ctor) \	1200	#define NV_KMEM_CACHE_CREATE_FULL(name, size, align, flags, ctor) \
1200	kmem_cache_create(name, size, align, flags, ctor, NULL)	1201	kmem_cache_create(name, size, align, flags, ctor, NULL)
Lines 1203-1208 extern void *nvidia_stack_t_cache; Link Here
1203	#define NV_KMEM_CACHE_CREATE(name, type) \	1204	#define NV_KMEM_CACHE_CREATE(name, type) \
1204	NV_KMEM_CACHE_CREATE_FULL(name, sizeof(type), 0, 0, NULL)	1205	NV_KMEM_CACHE_CREATE_FULL(name, sizeof(type), 0, 0, NULL)
1205		1206
		1207	#ifdef SLAB_USERCOPY
		1208	#define NV_KMEM_CACHE_CREATE_USERCOPY(name, type) \
		1209	NV_KMEM_CACHE_CREATE_FULL(name, sizeof(type), 0, SLAB_USERCOPY, NULL)
		1210	#else
		1211	#define NV_KMEM_CACHE_CREATE_USERCOPY(name, type) \
		1212	NV_KMEM_CACHE_CREATE_FULL_USERCOPY(name, sizeof(type), 0, 0, 0, sizeof(type), NULL)
		1213	#endif
		1214
1206	#define NV_KMEM_CACHE_DESTROY(kmem_cache) \	1215	#define NV_KMEM_CACHE_DESTROY(kmem_cache) \
1207	kmem_cache_destroy(kmem_cache)	1216	kmem_cache_destroy(kmem_cache)
1208		1217

Lines 102-113 nvidia_vma_release(struct vm_area_struct Link Here

(-)work.orig/kernel/nvidia/nv-mmap.c (-2 / +2 lines)
102	}	102	}
103		103
104	#if defined(NV_VM_OPERATIONS_STRUCT_HAS_ACCESS)	104	#if defined(NV_VM_OPERATIONS_STRUCT_HAS_ACCESS)
105	static int	105	static ssize_t
106	nvidia_vma_access(	106	nvidia_vma_access(
107	struct vm_area_struct *vma,	107	struct vm_area_struct *vma,
108	unsigned long addr,	108	unsigned long addr,
109	void *buffer,	109	void *buffer,
110	int length,	110	size_t length,
111	int write	111	int write
112	)	112	)
113	{	113	{

Lines 335-363 static void nvkms_resume(NvU32 gpuId) Link Here

(-)work.orig/kernel/nvidia-modeset/nvidia-modeset-linux.c (-20 / +19 lines)
335	* Interface with resman.	335	* Interface with resman.
336	*************************************************************************/	336	*************************************************************************/
337		337
338	static nvidia_modeset_rm_ops_t __rm_ops = { 0 };	338	static const nvidia_modeset_rm_ops_t *__rm_ops;
339	static nvidia_modeset_callbacks_t nvkms_rm_callbacks = {	339	static nvidia_modeset_callbacks_t nvkms_rm_callbacks = {
340	nvkms_suspend,	340	.suspend = nvkms_suspend,
341	nvkms_resume	341	.resume = nvkms_resume
342	};	342	};
343		343
344	static int nvkms_alloc_rm(void)	344	static int nvkms_alloc_rm(void)
345	{	345	{
346	NV_STATUS nvstatus;	346	NV_STATUS nvstatus;
347	int ret;	347	int ret;
		348	const char *version_string = NV_VERSION_STRING;
348		349
349	__rm_ops.version_string = NV_VERSION_STRING;	350	nvstatus = nvidia_get_rm_ops(&__rm_ops, &version_string);
350
351	nvstatus = nvidia_get_rm_ops(&__rm_ops);
352		351
353	if (nvstatus != NV_OK) {	352	if (nvstatus != NV_OK) {
354	printk(KERN_ERR NVKMS_LOG_PREFIX "Version mismatch: "	353	printk(KERN_ERR NVKMS_LOG_PREFIX "Version mismatch: "
355	"nvidia.ko(%s) nvidia-modeset.ko(%s)\n",	354	"nvidia.ko(%s) nvidia-modeset.ko(%s)\n",
356	__rm_ops.version_string, NV_VERSION_STRING);	355	version_string, NV_VERSION_STRING);
357	return -EINVAL;	356	return -EINVAL;
358	}	357	}
359		358
360	ret = __rm_ops.set_callbacks(&nvkms_rm_callbacks);	359	ret = __rm_ops->set_callbacks(&nvkms_rm_callbacks);
361	if (ret < 0) {	360	if (ret < 0) {
362	printk(KERN_ERR NVKMS_LOG_PREFIX "Failed to register callbacks\n");	361	printk(KERN_ERR NVKMS_LOG_PREFIX "Failed to register callbacks\n");
363	return ret;	362	return ret;
Lines 368-387 static int nvkms_alloc_rm(void) Link Here
368		367
369	static void nvkms_free_rm(void)	368	static void nvkms_free_rm(void)
370	{	369	{
371	__rm_ops.set_callbacks(NULL);	370	__rm_ops->set_callbacks(NULL);
372	}	371	}
373		372
374	void NVKMS_API_CALL nvkms_call_rm(void *ops)	373	void NVKMS_API_CALL nvkms_call_rm(void *ops)
375	{	374	{
376	nvidia_modeset_stack_ptr stack = NULL;	375	nvidia_modeset_stack_ptr stack = NULL;
377		376
378	if (__rm_ops.alloc_stack(&stack) != 0) {	377	if (__rm_ops->alloc_stack(&stack) != 0) {
379	return;	378	return;
380	}	379	}
381		380
382	__rm_ops.op(stack, ops);	381	__rm_ops->op(stack, ops);
383		382
384	__rm_ops.free_stack(stack);	383	__rm_ops->free_stack(stack);
385	}	384	}
386		385
387	/*************************************************************************	386	/*************************************************************************
Lines 705-717 NvBool NVKMS_API_CALL nvkms_open_gpu(NvU Link Here
705	nvidia_modeset_stack_ptr stack = NULL;	704	nvidia_modeset_stack_ptr stack = NULL;
706	NvBool ret;	705	NvBool ret;
707		706
708	if (__rm_ops.alloc_stack(&stack) != 0) {	707	if (__rm_ops->alloc_stack(&stack) != 0) {
709	return NV_FALSE;	708	return NV_FALSE;
710	}	709	}
711		710
712	ret = __rm_ops.open_gpu(gpuId, stack) == 0;	711	ret = __rm_ops->open_gpu(gpuId, stack) == 0;
713		712
714	__rm_ops.free_stack(stack);	713	__rm_ops->free_stack(stack);
715		714
716	return ret;	715	return ret;
717	}	716	}
Lines 720-742 void NVKMS_API_CALL nvkms_close_gpu(NvU3 Link Here
720	{	719	{
721	nvidia_modeset_stack_ptr stack = NULL;	720	nvidia_modeset_stack_ptr stack = NULL;
722		721
723	if (__rm_ops.alloc_stack(&stack) != 0) {	722	if (__rm_ops->alloc_stack(&stack) != 0) {
724	return;	723	return;
725	}	724	}
726		725
727	__rm_ops.close_gpu(gpuId, stack);	726	__rm_ops->close_gpu(gpuId, stack);
728		727
729	__rm_ops.free_stack(stack);	728	__rm_ops->free_stack(stack);
730	}	729	}
731		730
732	NvU32 NVKMS_API_CALL nvkms_enumerate_gpus(nv_gpu_info_t *gpu_info)	731	NvU32 NVKMS_API_CALL nvkms_enumerate_gpus(nv_gpu_info_t *gpu_info)
733	{	732	{
734	return __rm_ops.enumerate_gpus(gpu_info);	733	return __rm_ops->enumerate_gpus(gpu_info);
735	}	734	}
736		735
737	NvBool NVKMS_API_CALL nvkms_allow_write_combining(void)	736	NvBool NVKMS_API_CALL nvkms_allow_write_combining(void)
738	{	737	{
739	return __rm_ops.system_info.allow_write_combining;	738	return __rm_ops->system_info.allow_write_combining;
740	}	739	}
741		740
742	/*************************************************************************	741	/*************************************************************************

Lines 8-21 Link Here

(-)work.orig/kernel/nvidia/nv-modeset-interface.c (-12 / +20 lines)
8	* _NVRM_COPYRIGHT_END_	8	* _NVRM_COPYRIGHT_END_
9	*/	9	*/
10		10
11	#include "nv-modeset-interface.h"
12
13	#include "nv-misc.h"	11	#include "nv-misc.h"
14	#include "os-interface.h"	12	#include "os-interface.h"
15	#include "nv-linux.h"	13	#include "nv-linux.h"
16	#include "nvstatus.h"	14	#include "nvstatus.h"
17	#include "nv.h"	15	#include "nv.h"
18		16
		17	#include "nv-modeset-interface.h"
		18
19	static const nvidia_modeset_callbacks_t *nv_modeset_callbacks;	19	static const nvidia_modeset_callbacks_t *nv_modeset_callbacks;
20		20
21	static int nvidia_modeset_rm_ops_alloc_stack(nvidia_stack_t **sp)	21	static int nvidia_modeset_rm_ops_alloc_stack(nvidia_stack_t **sp)
Lines 100-109 static NvU32 nvidia_modeset_enumerate_gp Link Here
100	return count;	100	return count;
101	}	101	}
102		102
103	NV_STATUS nvidia_get_rm_ops(nvidia_modeset_rm_ops_t *rm_ops)	103	NV_STATUS nvidia_get_rm_ops(const nvidia_modeset_rm_ops_t rm_ops, const char version_string)
104	{	104	{
105	const nvidia_modeset_rm_ops_t local_rm_ops = {	105	static const nvidia_modeset_rm_ops_t local_rm_ops = {
106	.version_string = NV_VERSION_STRING,
107	.system_info = {	106	.system_info = {
108	.allow_write_combining = NV_FALSE,	107	.allow_write_combining = NV_FALSE,
109	},	108	},
Lines 116-132 NV_STATUS nvidia_get_rm_ops(nvidia_modes Link Here
116	.set_callbacks = nvidia_modeset_set_callbacks,	115	.set_callbacks = nvidia_modeset_set_callbacks,
117	};	116	};
118		117
119	if (strcmp(rm_ops->version_string, NV_VERSION_STRING) != 0)	118	static const nvidia_modeset_rm_ops_t local_rm_ops_wc = {
		119	.system_info = {
		120	.allow_write_combining = NV_TRUE,
		121	},
		122	.alloc_stack = nvidia_modeset_rm_ops_alloc_stack,
		123	.free_stack = nvidia_modeset_rm_ops_free_stack,
		124	.enumerate_gpus = nvidia_modeset_enumerate_gpus,
		125	.open_gpu = nvidia_dev_get,
		126	.close_gpu = nvidia_dev_put,
		127	.op = rm_kernel_rmapi_op, /* provided by nv-kernel.o */
		128	.set_callbacks = nvidia_modeset_set_callbacks,
		129	};
		130
		131	if (strcmp(*version_string, NV_VERSION_STRING) != 0)
120	{	132	{
121	rm_ops->version_string = NV_VERSION_STRING;	133	*version_string = NV_VERSION_STRING;
122	return NV_ERR_GENERIC;	134	return NV_ERR_GENERIC;
123	}	135	}
124		136
125	*rm_ops = local_rm_ops;	137	*rm_ops = NV_ALLOW_WRITE_COMBINING(NV_MEMORY_TYPE_FRAMEBUFFER) ? &local_rm_ops_wc : &local_rm_ops;
126
127	if (NV_ALLOW_WRITE_COMBINING(NV_MEMORY_TYPE_FRAMEBUFFER)) {
128	rm_ops->system_info.allow_write_combining = NV_TRUE;
129	}
130		138
131	return NV_OK;	139	return NV_OK;
132	}	140	}

Lines 35-51 Link Here

(-)work.orig/kernel/nvidia-uvm/uvm8_global.c (-5 / +5 lines)
35	#include "nv_uvm_interface.h"	35	#include "nv_uvm_interface.h"
36		36
37	uvm_global_t g_uvm_global;	37	uvm_global_t g_uvm_global;
38	static struct UvmOpsUvmEvents g_exported_uvm8_ops;	38	static struct UvmOpsUvmEvents g_exported_uvm8_ops = {
		39	.startDevice = NULL,
		40	.stopDevice = NULL,
		41	.isrTopHalf = uvm8_isr_top_half,
		42	};
39	static bool g_ops_registered = false;	43	static bool g_ops_registered = false;
40		44
41	static NV_STATUS uvm8_register_callbacks(void)	45	static NV_STATUS uvm8_register_callbacks(void)
42	{	46	{
43	NV_STATUS status = NV_OK;	47	NV_STATUS status = NV_OK;
44		48
45	g_exported_uvm8_ops.startDevice = NULL;
46	g_exported_uvm8_ops.stopDevice = NULL;
47	g_exported_uvm8_ops.isrTopHalf = uvm8_isr_top_half;
48
49	// Register the UVM callbacks with the main GPU driver:	49	// Register the UVM callbacks with the main GPU driver:
50	status = uvm_rm_locked_call(nvUvmInterfaceRegisterUvmCallbacks(&g_exported_uvm8_ops));	50	status = uvm_rm_locked_call(nvUvmInterfaceRegisterUvmCallbacks(&g_exported_uvm8_ops));
51	if (status != NV_OK)	51	if (status != NV_OK)