Attachment #22558 for bug #36286




# This Makefile is automatically generated; do not edit
#   Generated on 'builder3.nvidia.com' on Wed Dec 17 13:54:52 PST 2003

LINUX_MODULE=nv-linux.o
DEFINES=-D__KERNEL__ -DMODULE -D_LOOSE_KERNEL_NAMES -DNTRM -D_GNU_SOURCE -D_LOOSE_KERNEL_NAMES -D__KERNEL__ -DMODULE  -DNV_MAJOR_VERSION=1 -DNV_MINOR_VERSION=0 -DNV_PATCHLEVEL=5328  -DNV_UNIX   -DNV_LINUX   -DNV_INT64_OK   -DNVCPU_X86     
INCLUDES=-I.

OBJECTS=nv.o os-agp.o os-interface.o os-registry.o 
HEADERS=os-agp.h os-interface.h nv-linux.h nv-misc.h nv-memdbg.h nv.h  rmretval.h nvtypes.h  $(VERSION_HDR)

CFLAGS=-Wall -Wimplicit -Wreturn-type -Wswitch -Wformat -Wchar-subscripts -Wparentheses -Wpointer-arith  -Wno-multichar  -Werror -O -MD $(DEFINES) $(INCLUDES) -Wno-cast-qual -Wno-error

RESMAN_KERNEL_MODULE=nv-kernel.o

KERNDIR=/lib/modules/$(shell uname -r)

# check for newer paths. if found, use them, otherwise use old paths
# these wouldn't work with the gnu make included with rh6.2
# KERNINC=$(if -d $(KERNDIR)/build, $(KERNDIR)/build/include, /usr/src/linux/include)
# INSTALLDIR=$(if -d $(KERNDIR)/kernel, $(KERNDIR)/kernel/drivers/video, $(KERNDIR)/video)

# this is slightly more brain-dead, but works..
ifeq ($(shell if test -d $(KERNDIR)/build; then echo yes; fi),yes)
KERNINC=$(KERNDIR)/build/include
else
KERNINC=/usr/src/linux/include
endif

ifeq ($(shell if test -d $(KERNDIR)/kernel; then echo yes; fi),yes)
INSTALLDIR=$(KERNDIR)/kernel/drivers/video
else
INSTALLDIR=$(KERNDIR)/video
endif

ifeq ($(shell echo $(NVDEBUG)),1)
  ifeq ($(shell test -z $(RMDEBUG) && echo yes),yes)
    RMDEBUG=1
  endif
endif

ifeq ($(shell echo $(RMDEBUG)),1)
CFLAGS += -DDEBUG -g -fno-common
endif

# this is just plain wrong, get rid of it
BROKENDIR=$(KERNDIR)/kernel/video

INSTALL=$(shell which install)

# allow specification of alternate include file tree on command line and extra defines
ifdef SYSINCLUDE
INCLUDES += -I$(SYSINCLUDE)
else
INCLUDES += -I$(KERNINC)
endif

ifeq ($(shell sh conftest.sh remap_page_range $(INCLUDES)), 5)
  DEFINES += -DREMAP_PAGE_RANGE_5
endif

ifeq ($(shell sh conftest.sh remap_page_range $(INCLUDES)), 4)
  DEFINES += -DREMAP_PAGE_RANGE_4
endif

DEFINES+=$(EXTRA_DEFINES)

# allow build parameters to be passed in through the environment
ifdef BUILD_PARAMS
    DEFINES+=-D$(BUILD_PARAMS)
endif

VERSION_HDR=nv_compiler.h

all: install

install: package-install

package-install: nvidia.o rmmod-check
	@if [ `id -ur` != 0 ]; then \
		echo Please run \"make install\" as root.; \
	else \
		if [ -d $(BROKENDIR) ]; then \
			rm -f $(BROKENDIR)/NVdriver; \
			rmdir --ignore-fail-on-non-empty $(BROKENDIR); \
		fi && \
		mkdir -p $(INSTALLDIR) && \
		rm -f $(INSTALLDIR)/NVdriver && \
		$(INSTALL) -m 0664 -o root -g root nvidia.o $(INSTALLDIR)/nvidia.o$(O) && \
		PATH="$(PATH):/bin:/sbin" depmod -a && \
                PATH="$(PATH):/bin:/sbin" modprobe nvidia && \
		sh makedevices.sh && \
		echo "nvidia.o installed successfully."; \
	fi

RMMOD_ERROR=\
	echo ""; \
	echo "Unable to remove existing NVIDIA kernel module."; \
	echo "Please be sure you have exited X before attempting"; \
	echo "to install the NVIDIA kernel module."; \
	echo ""; \
	echo -en "\033[1;31m"; \
	echo -e  "*** Failed rmmod sanity check. Bailing out! ***"; \
	echo -en "\033[0m"; \
	exit 1;

rmmod-check:
	@if PATH="$(PATH):/bin:/sbin" lsmod | grep -w nvidia > /dev/null; then \
		if ! PATH="($PATH):/bin:/sbin" rmmod nvidia > /dev/null; then $(RMMOD_ERROR) fi \
	fi; \
	if PATH="$(PATH):/bin:/sbin" lsmod | grep -w NVdriver > /dev/null; then \
		if ! PATH="$(PATH):/bin:/sbin" rmmod NVdriver > /dev/null; then $(RMMOD_ERROR) fi \
	fi

gcc-check:
	@if ! sh conftest.sh cc_sanity_check full_output $(CC); then exit 1; fi

nvidia.o: gcc-check $(LINUX_MODULE) $(RESMAN_KERNEL_MODULE) 
	ld -r -o $@ $(LINUX_MODULE) $(RESMAN_KERNEL_MODULE)

$(VERSION_HDR): 
	echo \#define NV_COMPILER \"`$(CC) -v 2>&1 | tail -n 1`\" > $@

$(LINUX_MODULE): $(OBJECTS)
	ld -r -o $@ $(OBJECTS)

%.o: %.c $(HEADERS)
	$(CC) -c $(CFLAGS) $<

# debug tool to preprocess the file and leave .i to make it easier to untangle #defines
%.i: %.c
	$(CC) $(CFLAGS) -E $< > $@

%.s: %.c
	$(CC) $(CFLAGS) -S $< > $@


clean:
	$(RM) $(OBJECTS) $(LINUX_MODULE) $(VERSION_HDR) *.d NVdriver nvidia.o


-include $(OBJECTS:%.o=%.d)




#
# KBUILD Makefile for the NVIDIA Linux kernel module.
#
# The motivation for replacing the original Makefile is the hope that this
# version will simplify the build and installation process. In the past,
# many architectural and cosmetic changes to the Linux kernel have made it
# difficult to maintain compatibility or required duplication of logic.
#
# Linux 2.5 introduces numerous such changes, many of which impact modules.
# Relying on KBUILD, some aspects of the build system otherwise difficult
# to support (for example, module versioning) are abstracted away and dealt
# with elsewhere, making life significantly easier here.
#
# The new approach currently has its own share of problems, some of which
# are architectural difficulties with KBUILD, others minor annoyances. For
# this reason, an improved version of the NVIDIA Makefile is available to
# those experiencing difficulties.
#
# Please report any problems you may be experiencing with this experimental
# Makefile to either one (or, preferably, both) of us:
#
# Alistair J Strachan (alistair@devzero.co.uk) (first pass, enhancements)
# Christian Zander (zander@mail.minion.de) (enhancements)
#

all: install
install: package-install

#
# The NVIDIA kernel module base name and static file names. KBUILD will go
# ahead and append ".o" or ".ko" to form the final module name.
#

MODULE_NAME := nvidia
VERSION_HEADER := nv_compiler.h

#
# List of object files to link into NVIDIA kernel module; make sure KBUILD
# understands that we want a module.
#

RESMAN_CORE_OBJS := nv-kernel.o
RESMAN_GLUE_OBJS := nv.o os-agp.o os-interface.o os-registry.o

$(MODULE_NAME)-objs := $(RESMAN_CORE_OBJS) $(RESMAN_GLUE_OBJS)

#
# A bug in KBUILD 2.4 means that leaving obj-m set in top-level context
# will cause Rules.make to call pathdown.sh, which is wrong. So, we only
# set this conditional of a kernel-level instance.
#

ifdef TOPDIR
obj-m += $(MODULE_NAME).o
endif

#
# Include local source directory in $(CC)'s include path and set disable any
# warning types that are of little interest to us.
#

EXTRA_CFLAGS += -I$(src)
EXTRA_CFLAGS += -Wno-cast-qual -Wno-strict-prototypes

#
# Determine location of the Linux kernel source tree. Allow users to override
# the default (i.e. automatically determined) kernel source location with the
# KERNDIR directive; this new directive replaces NVIDIA's SYSINCLUDE.
#

ifdef KERNDIR
  KERNEL_SOURCES := $(KERNDIR)
  KERNEL_HEADERS := -I$(KERNEL_SOURCES)/include
  MODULE_ROOT    := /lib/modules/$(shell uname -r)/kernel/drivers # XXX
else
  KERNEL_SOURCES := /lib/modules/$(shell uname -r)/build
  KERNEL_HEADERS := -I$(KERNEL_SOURCES)/include
  MODULE_ROOT    := /lib/modules/$(shell uname -r)/kernel/drivers
endif

#
# We rely on these two definitions below; if they aren't set, we set them to
# reasonable defaults (Linux 2.4's KBUILD, and top-level passes will not set
# these).
#

src ?= .
obj ?= .

#
# Sets any internal variables left unset by KBUILD (e.g. this happens during
# a top-level run).
#

TOPDIR ?= $(KERNEL_SOURCES)
PATCHLEVEL ?= $(shell sh $(src)/conftest.sh kernel_patch_level $(TOPDIR))

#
# Linux 2.4 uses the .o module extension. Linux 2.5, however, uses the .ko
# module extension. Handle these gracefully.
#

ifeq ($(PATCHLEVEL), 4)
  MODULE_OBJECT := $(MODULE_NAME).o
else
  MODULE_OBJECT := $(MODULE_NAME).ko
endif

#
# NVIDIA specific CFLAGS and #define's. The remap_page_range check has become
# necessary with the introduction of the five argument version to Linux 2.4
# distribution kernels; this conflicting change cannot be detected at compile
# time.
#

EXTRA_CFLAGS += -D__KERNEL__ -DMODULE -D_LOOSE_KERNEL_NAMES -DNTRM -D_GNU_SOURCE -D_LOOSE_KERNEL_NAMES -D__KERNEL__ -DMODULE  -DNV_MAJOR_VERSION=1 -DNV_MINOR_VERSION=0 -DNV_PATCHLEVEL=5328  -DNV_UNIX   -DNV_LINUX   -DNV_INT64_OK   -DNVCPU_X86

ifeq ($(shell echo $(NVDEBUG)),1)
  ifeq ($(shell test -z $(RMDEBUG) && echo yes),yes)
    RMDEBUG=1
  endif
endif

ifeq ($(shell echo $(RMDEBUG)),1)
  EXTRA_CFLAGS += -DDEBUG -g -fno-common
endif

ifeq ($(shell sh $(src)/conftest.sh remap_page_range $(KERNEL_HEADERS)), 5)
  EXTRA_CFLAGS += -DREMAP_PAGE_RANGE_5
endif

ifeq ($(shell sh $(src)/conftest.sh remap_page_range $(KERNEL_HEADERS)), 4)
  EXTRA_CFLAGS += -DREMAP_PAGE_RANGE_4
endif

#
# NVIDIA binary object file includes .common section.
#

EXTRA_LDFLAGS := -d

#
# Miscellaneous NVIDIA kernel module build support targets. They are needed
# to satisfy KBUILD requirements and to support NVIDIA specifics.
#

$(obj)/nv-kernel.o:
	cp $(src)/$(RESMAN_CORE_OBJS) $(obj)/$(RESMAN_CORE_OBJS)

$(obj)/$(VERSION_HEADER):
	echo \#define NV_COMPILER \"`$(CC) -v 2>&1 | tail -n 1`\" > $@

$(obj)/nv.o: $(obj)/$(VERSION_HEADER)

#
# More quirks for Linux 2.4 KBUILD, which doesn't link automatically.
#

ifeq ($(PATCHLEVEL), 4)
$(obj)/$(MODULE_NAME).o: $($(MODULE_NAME)-objs)
	$(LD) $(EXTRA_LDFLAGS) -r -o $@ $($(MODULE_NAME)-objs)
endif

#
# KBUILD build parameters.
#

KBUILD_PARAMS := -C $(KERNEL_SOURCES) SUBDIRS=$(PWD)

#
# NVIDIA sanity checks.
#

suser-sanity-check:
	@if ! sh conftest.sh suser_sanity_check; then \
	  echo; \
	  echo "You have insufficient privileges for this operation. Please "; \
	  echo "run \"make install\" as root!                               "; \
	  echo; \
	  exit 1; \
	fi

rmmod-sanity-check:
	@if ! sh conftest.sh rmmod_sanity_check $(MODULE_NAME); then \
	  echo; \
	  echo "Unable to unload the currently loaded NVIDIA kernel module! "; \
	  echo "Please be certain that you have exited X before attempting  "; \
	  echo "to install this version.                                    "; \
	  echo; \
	  exit 1; \
	fi

cc-sanity-check:
	@if ! sh conftest.sh cc_sanity_check full_output $(CC); then \
		exit 1; \
	fi

#
# Build the NVIDIA kernel module using Linux KBUILD. This target is used by
# the "package-install" target below.
#

module: cc-sanity-check
	@make $(KBUILD_PARAMS) modules; \
	if ! [ -f $(MODULE_OBJECT) ]; then \
	  echo "$(MODULE_OBJECT) failed to build!"; \
	  exit 1; \
	fi

#
# Build the NVIDIA kernel module with KBUILD. Verify that the user posesses
# sufficient privileges. Rebuild the module dependency file.
#

module-install: suser-sanity-check module
	@mkdir -p $(MODULE_ROOT)/video; \
	install -m 0664 -o root -g root $(MODULE_OBJECT) $(MODULE_ROOT)/video; \
	/sbin/depmod -ae;

#
# This target builds, then installs, then creates device nodes and inserts
# the module, if successful.
#

package-install: module-install rmmod-sanity-check
	@sh makedevices.sh; \
	/sbin/modprobe $(MODULE_NAME) && \
	echo "$(MODULE_OBJECT) installed successfully.";

#
# Support hack, KBUILD isn't prepared to clean up after external modules.
#

clean:
	@rm -f $(RESMAN_GLUE_OBJS) .*.{cmd,flags}
	@rm -f $(MODULE_NAME).{o,ko,mod.{o,c}} built-in.o $(VERSION_HEADER) *~

#
# Linux 2.4 KBUILD requires the inclusion of Rules.make; Linux 2.5's KBUILD
# includes dependencies automatically.
#

ifeq ($(PATCHLEVEL), 4)
include $(KERNEL_SOURCES)/Rules.make
endif




# This Makefile is automatically generated; do not edit
#   Generated on 'builder3.nvidia.com' on Thu Jun 19 04:05:35 PDT 2003

LINUX_MODULE=nv-linux.o
DEFINES=-D__KERNEL__ -DMODULE -D_LOOSE_KERNEL_NAMES -DKBUILD_MODNAME="nvidia" -DNTRM -D_GNU_SOURCE -D_LOOSE_KERNEL_NAMES -D__KERNEL__ -DMODULE  -DNV_MAJOR_VERSION=1 -DNV_MINOR_VERSION=0 -DNV_PATCHLEVEL=5328     -DNV_UNIX   -DNV_LINUX   -DNV_INT64_OK   -DNVCPU_X86
INCLUDES=-I.

OBJECTS=nv.o os-agp.o os-interface.o os-registry.o 
HEADERS=os-agp.h os-interface.h nv-linux.h nv-misc.h nv-memdbg.h nv.h  rmretval.h nvtypes.h  $(VERSION_HDR)

CFLAGS=-Wall -Wimplicit -Wreturn-type -Wswitch -Wformat -Wchar-subscripts -Wparentheses -Wcast-qual -Wno-multichar  -O -MD $(DEFINES) $(INCLUDES) -Wno-cast-qual

RESMAN_KERNEL_MODULE=nv-kernel.o

KERNDIR=/lib/modules/$(shell uname -r)

# check for newer paths. if found, use them, otherwise use old paths
# these wouldn't work with the gnu make included with rh6.2
# KERNINC=$(if -d $(KERNDIR)/build, $(KERNDIR)/build/include, /usr/src/linux/include)
# INSTALLDIR=$(if -d $(KERNDIR)/kernel, $(KERNDIR)/kernel/drivers/video, $(KERNDIR)/video)

# this is slightly more brain-dead, but works..
ifeq ($(shell if test -d $(KERNDIR)/build; then echo yes; fi),yes)
KERNINC=$(KERNDIR)/build/include
else
KERNINC=/usr/src/linux/include
endif

ifeq ($(shell if test -d $(KERNDIR)/kernel; then echo yes; fi),yes)
INSTALLDIR=$(KERNDIR)/kernel/drivers/video
else
INSTALLDIR=$(KERNDIR)/video
endif

ifeq ($(shell echo $(NVDEBUG)),1)
  ifeq ($(shell test -z $(RMDEBUG) && echo yes),yes)
    RMDEBUG=1
  endif
endif

ifeq ($(shell echo $(RMDEBUG)),1)
CFLAGS += -DDEBUG -g -fno-common
endif

# this is just plain wrong, get rid of it
BROKENDIR=$(KERNDIR)/kernel/video

INSTALL=$(shell which install)

# allow specification of alternate include file tree on command line and extra defines
ifdef SYSINCLUDE
INCLUDES += -I$(SYSINCLUDE)
INCLUDES += -I$(SYSINCLUDE)/asm/mach-default
else
INCLUDES += -I$(KERNINC)
INCLUDES += -I$(KERNINC)/asm/mach-default
endif

ifeq ($(shell sh conftest.sh remap_page_range $(INCLUDES)), 5)
  DEFINES += -DREMAP_PAGE_RANGE_5
endif

ifeq ($(shell sh conftest.sh remap_page_range $(INCLUDES)), 4)
  DEFINES += -DREMAP_PAGE_RANGE_4
endif

DEFINES+=$(EXTRA_DEFINES)

# allow build parameters to be passed in through the environment
ifdef BUILD_PARAMS
    DEFINES+=-D$(BUILD_PARAMS)
endif

VERSION_HDR=nv_compiler.h

all: install

install: package-install

suser-sanity-check:
	@if ! sh conftest.sh suser_sanity_check; then \
	  echo; \
	  echo "You have insufficient privileges for this operation. Please "; \
	  echo "run \"make install\" as root!                               "; \
	  echo; \
	  exit 1; \
	fi

rmmod-sanity-check:
	@if ! sh conftest.sh rmmod_sanity_check nvidia; then \
	  echo; \
	  echo "Unable to unload the currently loaded NVIDIA kernel module! "; \
	  echo "Please be certain that you have exited X before attempting  "; \
	  echo "to install this version.                                    "; \
	  echo; \
	  exit 1; \
	fi

cc-sanity-check:
	@if ! sh conftest.sh cc_sanity_check full_output $(CC); then exit 1; fi

package-install: suser-sanity-check nvidia.o rmmod-sanity-check
	if [ -d $(BROKENDIR) ]; then \
		rm -f $(BROKENDIR)/NVdriver; \
		rmdir --ignore-fail-on-non-empty $(BROKENDIR); \
	fi && \
	mkdir -p $(INSTALLDIR) && \
	rm -f $(INSTALLDIR)/NVdriver && \
	$(INSTALL) -m 0664 -o root -g root nvidia.o $(INSTALLDIR)/nvidia.o$(O) && \
	/sbin/depmod -a && \
	/sbin/modprobe nvidia && \
	sh makedevices.sh && \
	echo "nvidia.o installed successfully."; \

nvidia.o: cc-sanity-check $(LINUX_MODULE) $(RESMAN_KERNEL_MODULE) 
	ld -d -r -o $@ $(LINUX_MODULE) $(RESMAN_KERNEL_MODULE)

$(VERSION_HDR): 
	echo \#define NV_COMPILER \"`$(CC) -v 2>&1 | tail -n 1`\" > $@

$(LINUX_MODULE): $(OBJECTS)
	ld -r -o $@ $(OBJECTS)

%.o: %.c $(HEADERS)
	$(CC) -c $(CFLAGS) $<

# debug tool to preprocess the file and leave .i to make it easier to untangle #defines
%.i: %.c
	$(CC) $(CFLAGS) -E $< > $@

%.s: %.c
	$(CC) $(CFLAGS) -S $< > $@


clean:
	$(RM) $(OBJECTS) $(LINUX_MODULE) $(VERSION_HDR) *.d NVdriver nvidia.o


-include $(OBJECTS:%.o=%.d)




            exit 0
        fi
    ;;

    cc_sanity_check)
        shift
        #
        # Verify that the same compiler is used for the kernel and kernel
        # module.
        #
        if test -n "$IGNORE_CC_MISMATCH" -o -n "$KERNDIR"; then
          #
          # The user chose to disable the gcc sanity test or is building
          # the module for a kernel not currently running, which renders
          # our test meaningless.
          #
          exit 0
        fi

        VERSION="^Linux version.* (.*) (\(gcc.*\)).*"
        KERNEL=$(cat /proc/version | sed "s/$VERSION/\1/")
        MODULE=$($* -v 2>&1 | tail -n 1)

        if test "$KERNEL" != "$MODULE"; then
          #
          # The kernel seems to have been built with a different version
          # of the C compiler, which may be a problem.
          #
          exit 1
        else
          exit 0
        fi
    ;;

    kernel_patch_level)
        shift
        #
        # Determine the kernel's major patch level; this is only done if we
        # aren't told by KBUILD.
        #
        echo $(cat "$1"/Makefile | grep "PATCHLEVEL =" | cut -d " " -f 3)
        exit 0
    ;;

    suser_sanity_check)
        shift
        #
        # Determine the caller's user id to determine if we have sufficient
        # privileges for the requested operation.
        #
        if test $(id -ur) != 0; then
          exit 1
        else
          exit 0
        fi
    ;;

    rmmod_sanity_check)
        shift
        #
        # Make sure that any currently loaded NVIDIA kernel module can be
        # unloaded.
        #
        if /sbin/lsmod | grep -q "$1"; then
          /sbin/rmmod "$1" >& /dev/null
        fi

        if /sbin/lsmod | grep -q "$1"; then
          #
          # The NVIDIA kernel module is still loaded, most likely because
          # it is busy.
          #
          exit 1
        else
          exit 0
        fi
    ;;
esac





# create a temporary file
tmp=`(mktemp -q /tmp/nvidia.XXXXXX) 2> /dev/null` || tmp="/tmp/nvidia.$$"

modconfs=" /etc/modutils/aliases    \
           /etc/modules.conf        \
           /etc/modprobe.d/aliases  \
           /etc/modprobe.conf       \
           /etc/conf.modules        "

#
# Pass the -p option to cp to preserve the permissions of $modconf and
# /etc/rc.d/rc.modules across the update. Update all relevant files
# including those eventually regenerated to avoid the need for awkward
# logic here.
#
for modconf in $modconfs; do
   if [ -f "$modconf" ]; then
     cp -p $modconf $tmp
     sed '/^alias.*\(NVdriver\|nvidia\)/d'  < $modconf   > $tmp

     # make sure the last character in the file is a newline
     [ `tail -n 1 $tmp | wc -l` = 0 ] && echo "" >> $tmp

     if [ -c /dev/.devfsd ]; then
       echo "alias /dev/nvidia* nvidia" >> $tmp
     else
       if [ `uname -r | cut -d '.' -f 2` = 6 ]; then
           echo "alias	char-major-195*	nvidia" >> $tmp
       else
           echo "alias	char-major-195	nvidia" >> $tmp
       fi
     fi
     mv -f $tmp $modconf
     test -x /sbin/update-modules && /sbin/update-modules
   fi
done

if [ -f /etc/rc.d/rc.modules ]; then
  cp -p /etc/rc.d/rc.modules $tmp
  sed '/.*\(NVdriver\|nvidia\).*/d' < /etc/rc.d/rc.modules > $tmp

  # make sure the last character in the file is a newline
  [ `tail -n 1 $tmp | wc -l` = 0 ] && echo "" >> $tmp

  echo -e "\n/sbin/modprobe nvidia" >> $tmp
  mv -f $tmp /etc/rc.d/rc.modules
   if [ -c /dev/.devfsd ]; then
     echo "alias /dev/nvidia*   nvidia" >> $tmp
   else
     echo "alias char-major-195 nvidia" >> $tmp
   fi
   mv -f $tmp $modconf
   test -x /sbin/update-modules && /sbin/update-modules
else
  if [ -f /etc/rc.d/rc.modules ]; then
    # Initialize the permissions on $tmp so that we don't change the
    # permissions of /etc/rc.d/rc.modules when we mv it into place
    cp -p /etc/rc.d/rc.modules $tmp
    sed '/.*\(NVdriver\|nvidia\).*/d' < /etc/rc.d/rc.modules > $tmp

    # make sure the last character in the file is a newline
    [ `tail -n 1 $tmp | wc -l` = 0 ] && echo "" >> $tmp 

    echo "/sbin/modprobe nvidia" >> $tmp
    mv -f $tmp /etc/rc.d/rc.modules
  fi
fi

if [ ! -c /dev/.devfsd ]; then




#  define MODVERSIONS
#endif

#if defined (MODVERSIONS)
#include <linux/modversions.h>
#endif

#include <linux/kernel.h>
#include <linux/module.h>

#if   LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 0)
#  error This driver does not support 2.2.x kernels!
#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 0)
#  define KERNEL_2_2
#  warning NVIDIA is considering dropping support for linux-2.2 
#  warning kernels. While end users are free to maintain their 
#  warning own patches, or stick with current drivers, our new 
#  warning drivers will not work "out of the box." If you are 
#  warning concerned about lack of support for 2.2 kernels, 
#  warning please let us know at linux-bugs@nvidia.com; we would
#  warning like to know how many users would be seriously 
#  warning impacted by this decision.
#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 0)
#  error This driver does not support 2.3.x kernels!
#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
#  define KERNEL_2_4
#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
#  error This driver does not support 2.5.x kernels!
#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 7, 0)
#  define KERNEL_2_6
#else
#  error This driver does not support development kernels!
#endif

#if defined (__ia64)

#define __SMP__
#endif

#if defined (MODVERSIONS) && !defined (KERNEL_2_6)
#include <linux/modversions.h>
#endif

#include <linux/types.h>            /* pic_t, size_t, __u32, etc        */
#include <linux/errno.h>            /* error codes                      */
#include <linux/list.h>             /* circular linked list             */
#include <linux/stddef.h>           /* NULL, offsetof                   */
#include <linux/wait.h>             /* wait queues                      */
#include <linux/tqueue.h>           /* struct tq_struct                 */

#include <linux/slab.h>             /* kmalloc, kfree, etc              */
#include <linux/vmalloc.h>          /* vmalloc, vfree, etc              */

#include <linux/poll.h>             /* poll_wait                        */
#include <linux/delay.h>            /* mdelay, udelay                   */

#ifdef KERNEL_2_6
#include <linux/sched.h>            /* suser(), capable() replacement   */
#include <linux/moduleparam.h>      /* module_param()                   */
#include <linux/smp_lock.h>         /* kernel_locked                    */
#include <asm/kmap_types.h>         /* page table entry lookup          */
#endif

#include <linux/pci.h>              /* pci_find_class, etc              */
#include <linux/interrupt.h>        /* tasklets, interrupt helpers      */
#include <linux/interrupt.h>        /* mark_bh, init_bh, remove_bh      */
#include <linux/timer.h>

#include <asm/system.h>             /* cli, sli, save_flags             */

#include <asm/page.h>               /* PAGE_OFFSET                      */
#include <asm/pgtable.h>            /* pte bit definitions              */

#if !defined (KERNEL_2_2)
#include <linux/spinlock.h>
#include <asm/semaphore.h>
#include <linux/highmem.h>
#else
#include <asm/spinlock.h>
#include <asm/semaphore.h>
#endif

#ifdef CONFIG_PROC_FS
#include <linux/proc_fs.h>


#endif /* !defined NVWATCH */

#define GET_MODULE_SYMBOL(mod,sym)      (const void *) inter_module_get(sym)
#define PUT_MODULE_SYMBOL(sym)          (inter_module_put((char *) sym))

#ifdef KERNEL_2_6
# define NV_IS_SUSER()                  capable(CAP_SYS_ADMIN)
# define NV_PCI_DEVICE_NAME(x)          ((x)->pretty_name)
# define NV_CLI()                       local_irq_disable()
# define NV_SAVE_FLAGS(x)               local_save_flags(x)
# define NV_RESTORE_FLAGS(x)            local_irq_restore(x)
# define NV_MAY_SLEEP()                 (!in_interrupt() && !in_atomic())
# define NV_SMP_NUM_CPUS                num_online_cpus()
# define NV_MODULE_PARAMETER(x)         module_param(x, int, 0)
#else
# define NV_IS_SUSER()                  suser()
# define NV_PCI_DEVICE_NAME(x)          ((x)->name)
# define NV_CLI()                       cli()
# define NV_SAVE_FLAGS(x)               save_flags(x)
# define NV_RESTORE_FLAGS(x)            restore_flags(x)
# define NV_MAY_SLEEP()                 (!in_interrupt())
# define NV_SMP_NUM_CPUS                smp_num_cpus
# define NV_MODULE_PARAMETER(x)         MODULE_PARM(x, "i")
#endif

#define NV_DEVICE_NUMBER(x)             minor((x)->i_rdev)
#define NV_VMA_OFFSET(x)                (((x)->vm_pgoff) << PAGE_SHIFT)
#define NV_VMA_PRIVATE(x)               ((x)->vm_private_data)
#define NV_IS_CONTROL_DEVICE(x)         (minor((x)->i_rdev) == 255)

#ifndef minor
/*
 * XXX Is this correct for all possible target kernels? We need this to
 * support older 2.4 and some 2.6 kernels.
 */
# define minor(x) MINOR(x)
#endif

#ifndef KERNEL_2_6
  typedef void irqreturn_t;
# define IRQ_NONE
# define IRQ_RETVAL(x)
# define IRQ_HANDLED
#else
#ifdef AGPGART
  typedef struct agp_kern_info agp_kern_info;
  typedef struct agp_memory agp_memory;
#endif
  typedef void* devfs_handle_t;
#endif

#ifdef KERNEL_2_6
#define NV_DEVFS_REGISTER(_name, _minor)                            \
({                                                                  \
    devfs_handle_t __handle = NULL;                                 \
    devfs_mk_cdev(MKDEV(NV_MAJOR_DEVICE_NUMBER, _minor),            \
            S_IFCHR | S_IRUGO | S_IWUGO, _name);                    \
    __handle;                                                       \
})

#define NV_DEVFS_REMOVE_DEVICE(i) devfs_remove("nvidia%d", i)
#define NV_DEVFS_REMOVE_CONTROL() devfs_remove("nvidiactl")
#else
#define NV_DEVFS_REGISTER(_name, _minor)                            \
({                                                                  \
    devfs_handle_t __handle =                                       \
        devfs_register(NULL, _name, DEVFS_FL_DEFAULT,               \
                NV_MAJOR_DEVICE_NUMBER, _minor,                     \
                S_IFCHR | S_IRUGO | S_IWUGO, &nv_fops, NULL);       \
    __handle;                                                       \
 })

#define NV_DEVFS_REMOVE_DEVICE(i) devfs_unregister(nv_devfs_handles[i+1])
#define NV_DEVFS_REMOVE_CONTROL() devfs_unregister(nv_devfs_handles[0])
#endif

/*
 * Linux 2.5 introduced the five argument version of remap_page_range, all
 * relevant releases to date use it. This version was backported to 2.4 by
 * RedHat without means to identify the change, hence this hack.
 */
#ifdef KERNEL_2_6
#define NV_REMAP_PAGE_RANGE(a, b...) remap_page_range(vma, a, ## b)
#else
#if defined(REMAP_PAGE_RANGE_5)
#define NV_REMAP_PAGE_RANGE(a, b...) remap_page_range(vma, a, ## b)
#elif defined(REMAP_PAGE_RANGE_4)
#define NV_REMAP_PAGE_RANGE(a, b...) remap_page_range(a, ## b)
#else
#warning "conftest.sh failed, assuming old Linux 2.4 remap_page_range(4)!"

#define NV_REMAP_PAGE_RANGE(a, b...) remap_page_range(a, ## b)
#endif
#endif /* KERNEL_2_6 */

#if defined(pmd_offset_map)
#define NV_PMD_OFFSET(address, pgd, pmd) \
    { \
        pmd = pmd_offset_map(pgd, address); \
    }
#define NV_PMD_UNMAP(pmd) \
    { \
        pmd_unmap(pmd); \
        pte = *pte__; \
        pte_kunmap(pte__); \
    }
#elif defined(pte_offset)
#define NV_PTE_OFFSET(addres, pg_mid_dir, pte) \
    pte = *pte_offset(pg_mid_dir, address)
#else
#define NV_PMD_OFFSET(address, pgd, pmd) \
    { \
        pmd = pmd_offset(pgd, address); \
        pte = *pte__; \
        pte_unmap(pte__); \
    }
#define NV_PMD_UNMAP(pmd)
#endif

#define NV_PMD_PRESENT(pmd) \
    ({ \
        if (pmd) { \
            if (pmd_none(*pmd)) { \
                NV_PMD_UNMAP(pmd); pmd = NULL; \
            } \
        } pmd != NULL; \
    })

#if defined (pte_offset_atomic)
#define NV_PTE_OFFSET(address, pmd, pte) \
    { \
        pte = pte_offset_atomic(pmd, address); \
        NV_PMD_UNMAP(pmd); \
    }
#define NV_PTE_UNMAP(pte) \
    { \
        pte_kunmap(pte); \
    }
#elif defined (pte_offset)
#define NV_PTE_OFFSET(address, pmd, pte) \
    { \
        pte = pte_offset(pmd, address); \
        NV_PMD_UNMAP(pmd); \
    }
#define NV_PTE_UNMAP(pte)
#else
#define NV_PTE_OFFSET(address, pmd, pte) \
    { \
        pte = pte_offset_map(pmd, address); \
        NV_PMD_UNMAP(pmd); \
    }
#define NV_PTE_UNMAP(pte) \
    { \
        pte_unmap(pte); \
    }
#endif

#define NV_PTE_PRESENT(pte) \
    ({ \
        if (pte) { \
            if (!pte_present(*pte)) { \
                NV_PTE_UNMAP(pte); pte = NULL; \
            } \
        } pte != NULL; \
    })

#define NV_PTE_VALUE(pte) \
    ({ \
        unsigned long __pte_value = pte_val(*pte); \
        NV_PTE_UNMAP(pte); \
        __pte_value; \
    })

#define NV_PAGE_ALIGN(addr)             ( ((addr) + PAGE_SIZE - 1) / PAGE_SIZE)
#define NV_MASK_OFFSET(addr)            ( (addr) & (PAGE_SIZE - 1) )

#if defined(NVCPU_IA64)
#define NV_GFP_HW (GFP_KERNEL | __GFP_DMA)

static inline int NV_IRQL_IS_RAISED()
    {
        unsigned long int eflags;
        NV_SAVE_FLAGS(eflags);
        return !(eflags & NV_CPU_INTERRUPT_FLAGS_BIT);
    }
 

    struct pci_dev *dev;
    nv_alloc_t *alloc_queue;

     /* keep track of any pending bottom halfes */
     struct tasklet_struct tasklet;

     /* active bottom half counter */
    atomic_t bh_count;

    /* get a timer callback every second */

    U032 num_events;
    U032 put, get;
    spinlock_t fp_lock;
    wait_queue_head_t waitqueue;
    nv_event_t *event_fifo;     // fifo for storing events
} nv_file_private_t;





#include "nv_compiler.h"
#include "os-agp.h"

MODULE_LICENSE("NVIDIA");

/*
 * our global state; one per device

 */

nv_linux_state_t nv_ctl_device = { { 0 } };
wait_queue_head_t nv_ctl_waitqueue;

// keep track of opened clients and their process id so they
//   can be free'd up on abnormal close
nv_client_t       nv_clients[NV_MAX_CLIENTS];
struct tq_struct  nv_bottom_halves[NV_MAX_CLIENTS];

#ifdef CONFIG_PROC_FS
struct proc_dir_entry *proc_nvidia;
#endif

#ifdef CONFIG_DEVFS_FS
devfs_handle_t nv_devfs_handles[NV_MAX_DEVICES+1];
devfs_handle_t  nv_ctl_handle;
#endif

/*
 * pick apart our minor device number
 * low 3 bits is NV device
 * if 255, then its the control device
 */

#define NV_DEVICE_NUMBER(_minor) ((_minor) & 0x0f)
#define NV_DEVICE_IS_CONTROL_DEVICE(_minor) \
             (((_minor) & 0xFF) == 0xFF)

// #define NV_DBG_MEM 1
#undef NV_DBG_MEM


 *** EXPORTS to Linux Kernel
 ***/

/* linux module interface functions (called by linux kernel) */
int           init_module(void);
void          cleanup_module(void);

/* nv_kern_ functions, interfaces used by linux kernel */
void          nv_kern_vma_open(struct vm_area_struct *vma);
void          nv_kern_vma_release(struct vm_area_struct *vma);

unsigned int  nv_kern_poll(struct file *, poll_table *);
int           nv_kern_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
void          nv_kern_bh(void *);
irqreturn_t   nv_kern_isr(int, void *, struct pt_regs *);
void          nv_kern_rc_timer(unsigned long);
#ifdef CONFIG_PM
int           nv_kern_pm(struct pm_dev *dev, pm_request_t rqst, void *data);

/* character driver entry points */

static struct file_operations nv_fops = {
    owner:          THIS_MODULE,
    poll:           nv_kern_poll,
    ioctl:          nv_kern_ioctl,
    mmap:           nv_kern_mmap,

    {
        nv_printf(NV_DBG_MEMINFO, "  0x%x (0x%x): count %d flags 0x%x\n", 
            page_ptr->phys_addr, page_ptr->dma_addr,
            (virt_to_page(__va(page_ptr->phys_addr)))->count,
            (virt_to_page(__va(page_ptr->phys_addr)))->flags);
        num_pages--;
        page_ptr++;
    }

        phys_addr = virt_to_phys((void *) virt_addr);

        /* lock the page for dma purposes */
        SetPageReserved(virt_to_page(__va(phys_addr)));

        page_ptr->phys_addr = phys_addr;
        page_ptr->virt_addr = virt_addr;

        // but if we failed pci_map_sg, make sure to free this page
        if (page_ptr->virt_addr)
        {
            ClearPageReserved(virt_to_page(__va(page_ptr->phys_addr)));
            NV_SET_PAGE_ATTRIB_CACHED(page_ptr);
#if defined(NVCPU_X86_64)
            // only unmap the page if it really was mapped through


    while (pages_left)
    {
        ClearPageReserved(virt_to_page(__va(page_ptr->phys_addr)));
        page_ptr++;
        pages_left--;
    }

    nv_linux_state_t *nvl;
    nv_linux_state_t *nv_max_devices;

#if defined (KERNEL_2_2)
    struct proc_dir_entry *proc_root_driver;
    proc_root_driver = create_proc_entry("driver", flags, &proc_root);
#endif

    proc_nvidia = create_proc_entry("nvidia", flags, proc_root_driver);
    proc_nvidia_cards = create_proc_entry("cards", flags, proc_nvidia);
    proc_nvidia_agp = create_proc_entry("agp", flags, proc_nvidia);

{
#ifdef CONFIG_PROC_FS
    nvos_proc_remove_all(proc_nvidia);
#if defined (KERNEL_2_2)
    remove_proc_entry("driver", &proc_root);
#endif
#endif
}


 *** EXPORTS to Linux Kernel
 ***/

static int __init nvidia_init_module(void)
{
    nv_linux_state_t *nvl;
    int rc, i;

    memset(nv_linux_devices, 0, sizeof(nv_linux_devices));


    nv_printf(NV_DBG_ERRORS, "nvidia: loading %s\n", pNVRM_ID);

#if defined(CONFIG_DEVFS_FS) && !defined(KERNEL_2_6)
    rc = devfs_register_chrdev(nv_major, "nvidia", &nv_fops);
#else
    rc = register_chrdev(nv_major, "nvidia", &nv_fops);

    }

#ifdef CONFIG_DEVFS_FS
    memset(nv_dev_handle, 0, sizeof(devfs_handle_t) * NV_MAX_DEVICES);
    do {
        /*
         * XXX This code isn't pretty, but neither is dealing with the
         * various Linux devfs implemenation(s). While Linux APIs are
         * known to be anything but stable and oftentimes anything but
         * well designed, the devfs interface has been more painful to
         * deal with than most other APIs.
         */
        char name[10];

        nv_devfs_handles[0] = NV_DEVFS_REGISTER("nvidiactl", 255);
                            DEVFS_FL_DEFAULT, nv_major, 255,
                            S_IFCHR | S_IRUGO | S_IWUGO,
                            &nv_fops, NULL);

        for (i = 0; i < num_nv_devices; i++) {
            sprintf(name, "nvidia%d", i);
            nv_devfs_handles[i+1] = NV_DEVFS_REGISTER(name, i);
                                  DEVFS_FL_DEFAULT, nv_major, i,
                                  S_IFCHR | S_IRUGO | S_IWUGO,
                                  &nv_fops, NULL);
        }
    } while(0);
#endif

    nv_printf(NV_DBG_INFO, "nvidia_init_module: major number %d\n", nv_major);

    /* instantiate tasklets */
    for (i = 0; i < NV_MAX_DEVICES; i++) {
        /*
         * We keep one tasklet per card to avoid latency issues with more
         * than one device; no two instances of a single tasklet are ever
         * executed concurrently.
         */
        atomic_set(&nv_linux_devices[i].tasklet.count, 1);
    }

    // init the nvidia control device

        nv_state_t *nv_ctl = NV_STATE_PTR(&nv_ctl_device);
        nv_ctl->os_state = (void *) &nv_ctl_device;
        nv_lock_init_locks(nv_ctl);
        init_waitqueue_head(&nv_ctl_waitqueue);
    }

#ifdef CONFIG_PM

    /* create /proc/driver/nvidia */
    nvos_proc_create();

#if defined(DEBUG)
    inter_module_register("nv_linux_devices", THIS_MODULE, nv_linux_devices);
#endif

    return 0;

 failed:
#if defined(CONFIG_DEVFS_FS) && !defined(KERNEL_2_6)
    devfs_unregister_chrdev(nv_major, "nvidia");
#else
    unregister_chrdev(nv_major, "nvidia");

    return rc;
}

static void __exit nvidia_exit_module(void)
{
    int rc;
    nv_linux_state_t *nvl, *max_devices;
    nv_linux_state_t *max_devices;

    /* remove /proc/driver/nvidia */
    nvos_proc_remove();

    nv_printf(NV_DBG_INFO, "nvidia_exit_module\n");

#if defined(DEBUG)
    inter_module_unregister("nv_linux_devices");
#endif

#ifdef CONFIG_PM
    do {
        int i;
        for (i = 0; i < num_nv_devices; i++) {
            pm_unregister(pm_nv_dev[i]);
        }
    } while (0);
#endif

    // Shutdown the resource manager

                continue;

            nv_printf(NV_DBG_ERRORS,
                    "still have vm que at nvidia_exit_module(): 0x%x to 0x%x\n",
                    nvl->alloc_queue->vma->vm_start,
                    nvl->alloc_queue->vma->vm_end);
        }
    }

#if defined(CONFIG_DEVFS_FS) && !defined(KERNEL_2_6)
    rc = devfs_unregister_chrdev(nv_major, "nvidia");
#else
    rc = unregister_chrdev(nv_major, "nvidia");
#endif

    if (rc < 0) {
        nv_printf(NV_DBG_ERRORS, "nvidia_exit_module: unregister nv failed\n");
    }

#ifdef CONFIG_DEVFS_FS
    do {
        int i;
        NV_DEVFS_REMOVE_CONTROL();
        for (i = 0; i < num_nv_devices; i++)
            NV_DEVFS_REMOVE_DEVICE(i);
    } while (0);
    devfs_unregister(nv_ctl_handle);
#endif

#if NV_ENABLE_MEM_TRACKING

#endif
}

module_init(nvidia_init_module);
module_exit(nvidia_exit_module);

/* this is only called when the vmas are duplicated.
 * this appears to only happen when the process is cloned to create

nv_kern_vma_open(struct vm_area_struct *vma)
{
    nv_printf(NV_DBG_MEMINFO, "vma_open for 0x%x - 0x%x, offset 0x%x\n",
        vma->vm_start, vma->vm_end, NV_VMA_OFFSET(vma));

    if (NV_VMA_PRIVATE(vma))
    {
        nv_alloc_t *at = (nv_alloc_t *) NV_VMA_PRIVATE(vma);
        at->usage_count++;

        nv_printf(NV_DBG_MEMINFO, "  at 0x%x, usage count %d, page_table 0x%x\n",


        nvos_list_page_count(at->page_table, at->num_pages);
    }

    MOD_INC_USE_COUNT;
}



nv_kern_vma_release(struct vm_area_struct *vma)
{
    nv_printf(NV_DBG_MEMINFO, "vma_release for 0x%x - 0x%x, offset 0x%x\n",
        vma->vm_start, vma->vm_end, NV_VMA_OFFSET(vma));

    if (NV_VMA_PRIVATE(vma))
    {
        nv_alloc_t *at = (nv_alloc_t *) NV_VMA_PRIVATE(vma);

        at->usage_count--;


            if (at->page_table)
                nvos_unlock_pages(at);
            nvos_free_alloc(at);
            NV_VMA_PRIVATE(vma) = NULL;
        }
    }

    MOD_DEC_USE_COUNT;
}


/* at this point, this code just plain won't work with 2.2 kernels.
 * additionally, only ia64 & the 460GX need a nopage handler, and 2.2 doesn't
 * work on ia64 anyways. It's expected that at some point other agp chipsets
 * will work similar to the 460GX (AGP 3.0 spec), so pre-emptively make sure
 * this works on our standard ia32 driver.
 */
#if !defined(KERNEL_2_2)

/* AGP allocations under the 460GX are not mapped to the aperture
 * addresses by the CPU.  This nopage handler will fault on CPU
 * accesses to AGP memory and map the address to the correct page.
 */
struct page *nv_kern_vma_nopage(struct vm_area_struct *vma, unsigned long address, int write_access)
{
#if defined(NVCPU_IA64) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 9))
    nv_alloc_t *at, *tmp;
    nv_linux_state_t *nvl;
    nv_state_t *nv;
    struct page *page_ptr;
    int rm_status, index;

    at = NV_VMA_PRIVATE(vma);
    if (at == NULL)
    {
        nv_printf(NV_DBG_ERRORS, "NVRM: nopage handler called without an at: "

        // far again
        nv_printf(NV_DBG_ERRORS, "NVRM: nopage handler called on a freed"
                  "address: vm_start 0x%x, at 0x%x\n", vma->vm_start, at);
        NV_VMA_PRIVATE(vma) = NULL;
        return NOPAGE_SIGBUS;
    }


    at->page_table[index].virt_addr = (unsigned long) __va(page_to_pfn(page_ptr) << PAGE_SHIFT);

    return page_ptr;
}
#endif
    return NOPAGE_SIGBUS;
}

struct vm_operations_struct nv_vm_ops = {
    nv_kern_vma_open,
    nv_kern_vma_release,  /* "close" */
#if !defined(KERNEL_2_2)
    nv_kern_vma_nopage,
#endif
};

static nv_file_private_t *

    memset(nvfp, 0, sizeof(nv_file_private_t));

    // initialize this file's event queue
    init_waitqueue_head(&nvfp->waitqueue);

    nv_init_lock(nvfp->fp_lock);


    if (nvfp == NULL)
        return;

    FREE_EVENT_QUEUE(nvfp->wqueue);
    NV_VFREE(nvfp->event_fifo, sizeof(nv_event_t) * NV_EVENT_FIFO_SIZE);
    NV_VFREE(nvfp, sizeof(nv_file_private_t));
}


    /* for control device, just jump to its open routine */
    /* after setting up the private data */
    if (NV_IS_CONTROL_DEVICE(inode))
        return nv_kern_ctl_open(inode, file);

    /* what device are we talking about? */
    devnum = NV_DEVICE_NUMBER(inode);
    if (devnum >= NV_MAX_DEVICES)
    {
        rc = -ENODEV;

            goto failed;
        }

        nvl->tasklet.func = (void *) rm_isr_bh;
        nvl->tasklet.data = (unsigned long) nv->pdev;
        tasklet_enable(&nvl->tasklet);

        nv->flags |= NV_FLAG_OPEN;
    }

    nv->usage_count++;
    MOD_INC_USE_COUNT;

 failed:
    nv_unlock(nvl->ldata_lock);


    /* for control device, just jump to its open routine */
    /* after setting up the private data */
    if (NV_IS_CONTROL_DEVICE(inode))
        return nv_kern_ctl_close(inode, file);

    nv_printf(NV_DBG_INFO, "nv_kern_close on device %d\n", NV_DEVICE_NUMBER(inode));

    rm_free_unused_clients(nv, current->pid, (void *) file);

    nv_lock(nvl->ldata_lock);
    if (--nv->usage_count == 0)
    {
        /*
         * The usage count for this device has dropped to zero, it can be shut
         * down safely; disable its interrupts.
         */
        **  or disabled before calling rm_shutdown_adapter() since
        **  it will free up the pdev.  This is hard to see on single
        **  cpu systems, but easy on dual cpu :-)
        */
        rm_disable_adapter(nv);

        /*
         * Disable this device's tasklet to make sure that no bottom half will
         * run with undefined device state.
         */
        tasklet_disable(&nvl->tasklet);
            current->state = TASK_INTERRUPTIBLE;
            schedule_timeout(HZ/50);
            counter++;
        }

        /*
         * Free the IRQ, which may block until all pending interrupt processing
         * has completed.
         */
        free_irq(nv->interrupt_line, (void *) nv);

        rm_shutdown_adapter(nv);

        FILE_PRIVATE(file) = NULL;
    }

    MOD_DEC_USE_COUNT;

    return 0;
}


    nv_printf(NV_DBG_INFO, "mmap([0x%p-0x%p] off=0x%lx)\n",
        vma->vm_start,
        vma->vm_end,
        NV_VMA_OFFSET(vma));

    // be a bit paranoid for now
    if ((NV_MASK_OFFSET(NV_VMA_OFFSET(vma))) ||
        (NV_MASK_OFFSET(vma->vm_start)) ||
        (NV_MASK_OFFSET(vma->vm_end)))
    {



    /* NV reg space */
    if (IS_REG_OFFSET(nv, NV_VMA_OFFSET(vma), vma->vm_end - vma->vm_start))
    {
        /* truncate to size of registers */
        if (pages > nv->regs->size / PAGE_SIZE)


        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
        if (NV_REMAP_PAGE_RANGE(vma->vm_start,
                             phys_to_uncached(NV_VMA_OFFSET(vma)),
                             vma->vm_end - vma->vm_start,
                             vma->vm_page_prot))
            return -EAGAIN;

    }

    /* NV fb space */
    else if (IS_FB_OFFSET(nv, NV_VMA_OFFSET(vma), vma->vm_end - vma->vm_start))
    {

        /* truncate to size of framebuffer */


        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
        if (NV_REMAP_PAGE_RANGE(vma->vm_start,
                             phys_to_uncached(NV_VMA_OFFSET(vma)),
                             vma->vm_end - vma->vm_start,
                             vma->vm_page_prot))
            return -EAGAIN;

    }

    /* AGP allocator */
    else if (IS_AGP_OFFSET(nv, NV_VMA_OFFSET(vma), vma->vm_end - vma->vm_start))
    {
        nv_lock(nvl->at_lock);
        at = nvl_find_alloc(nvl, NV_VMA_OFFSET(vma), NV_ALLOC_TYPE_AGP);

        if (at == NULL)
        {

        }

        at->vma = vma;
        NV_VMA_PRIVATE(vma) = at;
        at->usage_count++;

        if (NV_OSAGP_ENABLED(nv))

    }

    /* Magic allocator */
    else // if (NV_VMA_OFFSET(vma) == NV_MMAP_ALLOCATION_OFFSET)
    {
        unsigned long page = 0, pos, start;
        int i = 0;

        nv_lock(nvl->at_lock);
        at = nvl_find_alloc(nvl, NV_VMA_OFFSET(vma), NV_ALLOC_TYPE_PCI);

        if (at == NULL)
        {

        }

        at->vma = vma;
        NV_VMA_PRIVATE(vma) = at;
        at->usage_count++;

        nv_printf(NV_DBG_INFO, "remapping %d system pages for at 0x%x\n", pages, at);


    vma->vm_file = file;

    /* just increment usage count, rather than calling vma_open */
    MOD_INC_USE_COUNT;

    return 0;
}


    {
        nv_printf(NV_DBG_EVENTINFO, "calling poll_wait\n");
        // add us to the list
        poll_wait(file, &nvfp->waitqueue, wait);
    }

    nv_lock_irq(nvfp->fp_lock, eflags);


    switch (_IOC_NR(cmd))
    {
#if !defined(KERNEL_2_6)
        /* debug tool; zap the module use count so we can unload driver */
        /*             even if it is confused */
        case NV_ESC_MODULE_RESET:
            atomic_set(&__this_module.uc.usecount, 1);
            break;
#endif
        /* pass out info about the card */
        case NV_ESC_CARD_INFO:
        {

 * driver receives an interrupt
 *    if someone waiting, then hand it off.
 */
irqreturn_t nv_kern_isr(
    int   irq,
    void *arg,
    struct pt_regs *regs

    if (need_to_run_bottom_half)
    {
        NV_ATOMIC_INC(nvl->bh_count);
        tasklet_schedule(&nvl->tasklet);
        mark_bh(IMMEDIATE_BH);
    }

    return IRQ_HANDLED;
}

void nv_kern_bh(


    if (nv->usage_count == 0)
    {
        init_waitqueue_head(&nv_ctl_waitqueue);
    }

    MOD_INC_USE_COUNT;

    nv->flags |= NV_FLAG_OPEN + NV_FLAG_CONTROL;

    /* turn off the hotkey occurred bit */


    nv_lock(nvl->ldata_lock);
    if (--nv->usage_count == 0)
    {
        FREE_EVENT_QUEUE(nv_ctl_wqueue);
        nv->flags = 0;

    nv_unlock(nvl->ldata_lock);

    rm_free_unused_clients(nv, current->pid, (void *) file);

        FILE_PRIVATE(file) = NULL;
    }

    MOD_DEC_USE_COUNT;

    return 0;
}


    nv = NV_STATE_PTR(nvl);

    if ( !(file->f_flags & O_NONBLOCK) )
        poll_wait(file, &nv_ctl_waitqueue, wait);

    nv_lock(nvl->ldata_lock);


    nv_ctl_device.nv_state.flags |= NV_FLAG_HOTKEY_OCCURRED;
    nv_unlock(nv_ctl_device.ldata_lock);

    wake_up_interruptible(&nv_ctl_waitqueue);
}

int nv_kern_read_cardinfo(char *page, char **start, off_t off,

        len += sprintf(page+len, "Host Bridge: \t ");

#if defined(CONFIG_PCI_NAMES)
        len += sprintf(page+len, "%s\n", NV_PCI_DEVICE_NAME(dev));
#else
        len += sprintf(page+len, "PCI device %04x:%04x\n",
                dev->vendor, dev->device);

    int kern
)
{
    pgd_t *pgd;
    pmd_t *pmd;
    pte_t *pte;
    unsigned long retval;

    if (kern)
        pgd = pgd_offset_k(address);
    else
        pgd = pgd_offset(current->mm, address);

    if (!pgd || pgd_none(*pgd))
        goto failed;

    NV_PMD_OFFSET(address, pgd, pmd);

    if (!NV_PMD_PRESENT(pmd))
        goto failed;

    NV_PTE_OFFSET(address, pmd, pte);

    if (!NV_PTE_PRESENT(pte))
        goto failed;

    retval = ((NV_PTE_VALUE(pte) & KERN_PAGE_MASK) | NV_MASK_OFFSET(address));

#if defined(NVCPU_X86_64) && defined(_PAGE_NX)
    // mask out the non-executable page bit for the true physical address


    if (nvfp->num_events == NV_EVENT_FIFO_SIZE)
    {
        wake_up_interruptible(&nvfp->waitqueue);
        nv_unlock_irq(nvfp->fp_lock, eflags);
        return;
    }

    if (nvfp->put >= NV_EVENT_FIFO_SIZE)
        nvfp->put = 0;

    wake_up_interruptible(&nvfp->waitqueue);
    nv_unlock_irq(nvfp->fp_lock, eflags);
}


    if ( (NV_AGP_DISABLED(nv)) && (config & NVOS_AGP_CONFIG_NVAGP) )
    {
        /* make sure the user does not have agpgart loaded */
#if !defined (KERNEL_2_2)
        if (inter_module_get("drm_agp")) {
            inter_module_put("drm_agp");
#else
        if (GET_MODULE_SYMBOL(0, __MODULE_STRING(agp_enable))) {
#endif
            nv_printf(NV_DBG_WARNINGS, "NVRM: not using NVAGP, AGPGART is loaded!!\n");
        } else {
#if defined(CONFIG_X86_64) && defined(CONFIG_GART_IOMMU)




    int  ready;
} agp_gart;

typedef struct {
    int           (*backend_acquire)(void);
    void          (*backend_release)(void);
    void          (*copy_info)(agp_kern_info *);
    agp_memory *  (*allocate_memory)(size_t, unsigned int);
    void          (*free_memory)(agp_memory *);
    int           (*bind_memory)(agp_memory *, off_t);
    int           (*unbind_memory)(agp_memory *);
    void          (*enable)(unsigned int);
} agp_operations_struct;

agp_operations_struct agp_ops;
agp_kern_info         agpinfo;
agp_gart              gart;
#if !defined (KERNEL_2_2)
const drm_agp_t       *drm_agp_p;
#endif

#if defined (KERNEL_2_2)
    #define GET_AGPGART_SYMBOL(sym, sym_string)                     \
        sym = (void*) GET_MODULE_SYMBOL(0, sym_string);             \
        if (sym == NULL)                                            \
        {                                                           \
            nv_printf(NV_DBG_ERRORS,                                \
                "NVRM: AGPGART: unable to retrieve symbol %s\n",    \
                sym_string);                                        \
            return 1;                                               \
        }

    #define AGP_BACKEND_ACQUIRE_SYM   __MODULE_STRING(agp_backend_acquire)
    #define AGP_BACKEND_RELEASE_SYM   __MODULE_STRING(agp_backend_release)
    #define AGP_COPY_INFO_SYM         __MODULE_STRING(agp_copy_info)
    #define AGP_ALLOCATE_MEMORY_SYM   __MODULE_STRING(agp_allocate_memory)
    #define AGP_FREE_MEMORY_SYM       __MODULE_STRING(agp_free_memory)
    #define AGP_BIND_MEMORY_SYM       __MODULE_STRING(agp_bind_memory)
    #define AGP_UNBIND_MEMORY_SYM     __MODULE_STRING(agp_unbind_memory)
    #define AGP_ENABLE_SYM            __MODULE_STRING(agp_enable)
#endif

#if defined(CONFIG_MTRR)
#define MTRR_DEL(gart) if ((gart).mtrr > 0) mtrr_del((gart).mtrr, 0, 0);


    memset( (void *) &gart, 0, sizeof(agp_gart));

    /*
     * XXX The inter_module_* mechanism has been deprecated and replaced with
     * a different mechanism in Linux 2.5; it will go away eventually.
     * Also, the Linux 2.5 AGP GART driver is modularized, agpgart.o does not
     * include backend drivers.
     */
    if (!(drm_agp_p = inter_module_get_request("drm_agp", "agpgart")))
    {
        nv_printf(NV_DBG_ERRORS,
            "NVRM: AGPGART: unable to retrieve symbol table\n");
        return 1;
    }
    
    agp_ops.backend_acquire = drm_agp_p->acquire;
    agp_ops.backend_release = drm_agp_p->release;
    agp_ops.allocate_memory = drm_agp_p->allocate_memory;
    agp_ops.free_memory     = drm_agp_p->free_memory;
    agp_ops.bind_memory     = drm_agp_p->bind_memory;
    agp_ops.unbind_memory   = drm_agp_p->unbind_memory;
    agp_ops.enable          = drm_agp_p->enable;

    // looks like some newer kernels (for example mandrake 9.0's 2.4.19-16mdk)
    // have updated copy_info to return an integer value, and of course didn't
    // bother bumping the agpgart revision up. The return value is pretty 
    // harmless (backend_acquire would have already failed and caused us to
    // bail), so cast the function pointer to avoid compiler warnings.
    // we may need to revisit this in the future.
    agp_ops.copy_info       = (void (*)(agp_kern_info *)) drm_agp_p->copy_info;

#else
#if defined(CONFIG_KMOD)
    if ( request_module("agpgart") )
    {
        nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: not loading agpgart.o\n");
        return 1;
    }
#endif

    GET_AGPGART_SYMBOL(agp_ops.backend_acquire, AGP_BACKEND_ACQUIRE_SYM);
    GET_AGPGART_SYMBOL(agp_ops.backend_release, AGP_BACKEND_RELEASE_SYM);
    GET_AGPGART_SYMBOL(agp_ops.copy_info,       AGP_COPY_INFO_SYM);
    GET_AGPGART_SYMBOL(agp_ops.allocate_memory, AGP_ALLOCATE_MEMORY_SYM);
    GET_AGPGART_SYMBOL(agp_ops.free_memory,     AGP_FREE_MEMORY_SYM);
    GET_AGPGART_SYMBOL(agp_ops.bind_memory,     AGP_BIND_MEMORY_SYM);
    GET_AGPGART_SYMBOL(agp_ops.unbind_memory,   AGP_UNBIND_MEMORY_SYM);
    GET_AGPGART_SYMBOL(agp_ops.enable,          AGP_ENABLE_SYM);
#endif

    /* NOTE: from here down, return an error code of '-1'
     * that indicates that agpgart is loaded, but we failed to use it

     * the memory controller.
     */

    if (drm_agp_p->acquire())
    {
        nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: backend in use\n");
        return -1;

        agp_fw = 1;
    agp_fw &= 0x00000001;
    
#if defined(KERNEL_2_4)
    /*
     * The original Linux 2.4 AGP GART driver interface declared copy_info to
     * return nothing. This changed in Linux 2.5, which reports unsupported
     * chipsets via this function. If this Linux 2.4 kernels behaves the same
     * way, we have no way to know.
     */
    drm_agp_p->copy_info(&agpinfo);
#else
    if (drm_agp_p->copy_info(&agpinfo)) {
        drm_agp_p->release();
        inter_module_put("drm_agp");
        return -1;
    }
#endif

#ifdef CONFIG_MTRR
    if ((gart.mtrr = mtrr_add(agpinfo.aper_base,

         */
        nv_printf(NV_DBG_ERRORS, 
            "NVRM: AGPGART: unable to set MTRR write-combining\n");
        drm_agp_p->release();
        inter_module_put("drm_agp");
        return -1;
    }
#endif

    {
        nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: unable to remap aperture\n");
        MTRR_DEL(gart);
        drm_agp_p->release();
        inter_module_put("drm_agp");
        return -1;
    }


        nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: unable to allocate bitmap\n");
        NV_IOUNMAP(gart.aperture, RM_PAGE_SIZE);
        MTRR_DEL(gart);
        drm_agp_p->release();
        inter_module_put("drm_agp");
        return -1;
    }


        os_free_mem(bitmap);
        NV_IOUNMAP(gart.aperture, RM_PAGE_SIZE);
        MTRR_DEL(gart);
        drm_agp_p->release();
        inter_module_put("drm_agp");
        return -1;
    }

    nv_printf(NV_DBG_SETUP,
        "NVRM: AGPGART: aperture: %ldM @ 0x%08lx\n",
        (unsigned long)agpinfo.aper_size,
        (unsigned long)agpinfo.aper_base);

    nv_printf(NV_DBG_SETUP, 
        "NVRM: AGPGART: aperture mapped from 0x%08lx to 0x%08lx\n",
        agpinfo.aper_base,
        (unsigned long) gart.aperture);

    if (!agp_sba) agpinfo.mode &= ~0x00000200;
    if (!agp_fw)  agpinfo.mode &= ~0x00000010;

    if (!(agp_rate & 0x00000004)) agpinfo.mode &= ~0x00000004;
    if (!(agp_rate & 0x00000002)) agpinfo.mode &= ~0x00000002;
    
    drm_agp_p->enable(agpinfo.mode);
    
    if (agpinfo.mode & 0x00000200)
        nv_printf(NV_DBG_SETUP, "NVRM: AGPGART: backend supports sba\n");
    if (agpinfo.mode & 0x00000010)
        nv_printf(NV_DBG_SETUP, "NVRM: AGPGART: backend supports fw\n");
    if (agpinfo.mode & 0x00000004)
        nv_printf(NV_DBG_SETUP, "NVRM: AGPGART: mode 4x\n");
    else if (agpinfo.mode & 0x00000002)
        nv_printf(NV_DBG_SETUP, "NVRM: AGPGART: mode 2x\n");
    else if (agpinfo.mode & 0x00000001)
        nv_printf(NV_DBG_SETUP, "NVRM: AGPGART: mode 1x\n");

    *ap_phys_base   = (void*) agpinfo.aper_base;
    *ap_mapped_base = (void*) gart.aperture;
    *apsize         = (agpinfo.aper_size * 0x100000) - 1;

        NV_IOUNMAP(gart.aperture, RM_PAGE_SIZE);
    }

    drm_agp_p->release();

    /*
     * XXX Same as above; the inter_module_* mechanism will go away at some
     * point, it has been deprecated in Linux 2.5.
     */
    inter_module_put("drm_agp");
#endif

    if (rm_clear_agp_bitmap(nv, &bitmap))
    {

        return RM_ERROR;
    }

    ptr = drm_agp_p->allocate_memory(PageCount, AGP_NORMAL_MEMORY);
    if (ptr == NULL)
    {
        *pAddress = (void*) 0;

        return RM_ERR_NO_FREE_MEM;
    }
    
    err = drm_agp_p->bind_memory(ptr, *Offset);
    if (err)
    {
        // this happens a lot when the aperture itself fills up..

    if (status != RM_OK)
    {
        nv_printf(NV_DBG_ERRORS, "NVRM: memory allocation failed\n");
        drm_agp_p->unbind_memory(ptr);
        goto fail;
    }


    return RM_OK;

fail:
    drm_agp_p->free_memory(ptr);
    *pAddress = (void*) 0;

    return RM_ERROR;

    {
        nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: unable to remap %lu pages\n",
            (unsigned long)agp_data->num_pages);
        drm_agp_p->unbind_memory(agp_data->ptr);
        goto fail;
    }
    

}
#endif

#if !defined(KERNEL_2_2)

RM_STATUS 
KernMapAGPNopage(
    VOID *address,

#endif
}

#endif /* !defined(KERNEL_2_2) */


RM_STATUS KernFreeAGPPages(
    nv_state_t *nv,
    VOID **pAddress,

    {
        size_t pages = ptr->page_count;

        drm_agp_p->unbind_memory(ptr);
        drm_agp_p->free_memory(ptr);

        nv_printf(NV_DBG_INFO, "NVRM: AGPGART: freed %ld pages\n",
            (unsigned long)pages);

Lines 56-62 Link Here

(-)NVIDIA_kernel-1.0-5328/os-interface.c (-19 / +15 lines)
56	PHWINFO pDev	56	PHWINFO pDev
57	)	57	)
58	{	58	{
59	return suser();	59	return NV_IS_SUSER();
60	}	60	}
61		61
62	U032 os_get_page_size(VOID)	62	U032 os_get_page_size(VOID)
Lines 211-216 Link Here
211	{	211	{
212	NV_MEM_TRACKING_PAD_SIZE(size);	212	NV_MEM_TRACKING_PAD_SIZE(size);
213		213
		214	/*
		215	* XXX This needs to be !NV_MAY_SLEEP() rather than in_interrupt(); that
		216	* requires quite a bit of locking to be rearranged, however, which is why
		217	* I'll leave it alone for now.
		218	*/
214	if (in_interrupt()) {	219	if (in_interrupt()) {
215	if (size <= KMALLOC_LIMIT) {	220	if (size <= KMALLOC_LIMIT) {
216	/*	221	/*
Lines 296-302 Link Here
296	address = (void ) va;	301	address = (void ) va;
297		302
298	for (i = 0; i < count; i++) {	303	for (i = 0; i < count; i++) {
299	mem_map_reserve(GET_MAP_NR(__pa((va))));	304	SetPageReserved(virt_to_page(va));
300	va += PAGE_SIZE;	305	va += PAGE_SIZE;
301	}	306	}
302		307
Lines 320-326 Link Here
320	unsigned long va = (unsigned long) address;	325	unsigned long va = (unsigned long) address;
321		326
322	for (i = 0; i < count; i++) {	327	for (i = 0; i < count; i++) {
323	mem_map_unreserve(GET_MAP_NR(__pa((va))));	328	ClearPageReserved(virt_to_page(va));
324	va += PAGE_SIZE;	329	va += PAGE_SIZE;
325	}	330	}
326		331
Lines 426-432 Link Here
426	if (in_irq() && MilliSeconds > NV_MAX_ISR_MDELAY)	431	if (in_irq() && MilliSeconds > NV_MAX_ISR_MDELAY)
427	return RM_ERROR;	432	return RM_ERROR;
428		433
429	if (in_interrupt())	434	if (!NV_MAY_SLEEP())
430	{	435	{
431	mdelay(MilliSeconds);	436	mdelay(MilliSeconds);
432	return RM_OK;	437	return RM_OK;
Lines 524-531 Link Here
524	// The current debug display level (default to maximum debug level)	529	// The current debug display level (default to maximum debug level)
525	int cur_debuglevel = 0xaaaaaaaa;	530	int cur_debuglevel = 0xaaaaaaaa;
526		531
527	MODULE_PARM(silence_nvidia_output, "1i");
528	static int silence_nvidia_output = 0;	532	static int silence_nvidia_output = 0;
		533	NV_MODULE_PARAMETER(silence_nvidia_output);
529		534
530		535
531	//	536	//
Lines 708-721 Link Here
708		713
709	ULONG os_cli(ULONG flags)	714	ULONG os_cli(ULONG flags)
710	{	715	{
711	save_flags(flags);	716	NV_SAVE_FLAGS(flags);
712	cli();	717	NV_CLI();
713	return flags;	718	return flags;
714	}	719	}
715		720
716	ULONG os_sti(ULONG flags)	721	ULONG os_sti(ULONG flags)
717	{	722	{
718	restore_flags(flags);	723	NV_RESTORE_FLAGS(flags);
719	return flags;	724	return flags;
720	}	725	}
721		726
Lines 866-881 Link Here
866	U032 size_bytes	871	U032 size_bytes
867	)	872	)
868	{	873	{
869	#if defined (KERNEL_2_2)	874	NV_IOUNMAP(addr, size_bytes);
870	if (MAP_NR(addr) < max_mapnr) {
871	// if we didn't want the memory cached, this isn't necessary
872	// but we shouldn't be in a timing critical piece of code.
873	asm volatile("wbinvd":::"memory");
874	} else
875	#endif
876	{
877	NV_IOUNMAP(addr, size_bytes);
878	}
879	}	875	}
880		876
881	VOID* os_map_user_space(	877	VOID* os_map_user_space(
Lines 979-985 Link Here
979		975
980	U032 os_get_cpu_count()	976	U032 os_get_cpu_count()
981	{	977	{
982	return smp_num_cpus;	978	return NV_SMP_NUM_CPUS;
983	}	979	}
984		980
985	#if defined(DEBUG) && !defined(NVCPU_IA64)	981	#if defined(DEBUG) && !defined(NVCPU_IA64)




 *   This could be changed to work on a per-device basis.
 */

/*
 * The 2nd argument to MODULE_PARM is used to verify parameters passed
 * to the module at load time. It should be a string in the following 
 * format:
 *
 *   	[min[-max]]{b,h,i,l,s}
 *
 * The MIN and MAX specifiers delimit the length of the array. If MAX
 * is omitted, it defaults to MIN; if both are omitted, the default is
 * 1. The final character is a type specifier.
 *
 *  b   byte
 *  h   short
 *  i   int
 *  l   long
 *  s   string
 */

/* 
 * Option: VideoMemoryTypeOverride
 * 

 */

static int NVreg_VideoMemoryTypeOverride = 1;
NV_MODULE_PARAMETER(NVreg_VideoMemoryTypeOverride);

/*
 * Option: EnableVia4x

 */

static int NVreg_EnableVia4x = 0;
NV_MODULE_PARAMETER(NVreg_EnableVia4x);

/*
 * Option: EnableALiAGP

 */

static int NVreg_EnableALiAGP = 0;
NV_MODULE_PARAMETER(NVreg_EnableALiAGP);

/* 
 * Option: ReqAGPRate

 */

static int NVreg_ReqAGPRate = 7;
NV_MODULE_PARAMETER(NVreg_ReqAGPRate);

/* 
 * Option: UpdateKernelAGP

 */

static int NVreg_UpdateKernelAGP = 1;
NV_MODULE_PARAMETER(NVreg_UpdateKernelAGP);

/* 
 * Option: EnableAGPSBA

static int NVreg_EnableAGPSBA = 0;
#endif

NV_MODULE_PARAMETER(NVreg_EnableAGPSBA);

/*
 * Option: EnableAGPFW

 */

static int NVreg_EnableAGPFW = 0;
NV_MODULE_PARAMETER(NVreg_EnableAGPFW);

/*
 * Option: SoftEDIDs

 */

static int NVreg_SoftEDIDs = 1;
NV_MODULE_PARAMETER(NVreg_SoftEDIDs);

/* 
 * Option: Mobile

 */

static int NVreg_Mobile = ~0;
NV_MODULE_PARAMETER(NVreg_Mobile);


static int NVreg_ResmanDebugLevel = ~0;
NV_MODULE_PARAMETER(NVreg_ResmanDebugLevel);

static int NVreg_FlatPanelMode = 0;
NV_MODULE_PARAMETER(NVreg_FlatPanelMode);

/*
 * You can enable any of the registry options disabled by default by

Return to bug 36286

Lines 104-108 Link Here

(-)NVIDIA_kernel-1.0-5328/conftest.sh (+74 lines)
104	exit 0	104	exit 0
105	fi	105	fi
106	;;	106	;;
		107
		108	cc_sanity_check)
		109	shift
		110	#
		111	# Verify that the same compiler is used for the kernel and kernel
		112	# module.
		113	#
		114	if test -n "$IGNORE_CC_MISMATCH" -o -n "$KERNDIR"; then
		115	#
		116	# The user chose to disable the gcc sanity test or is building
		117	# the module for a kernel not currently running, which renders
		118	# our test meaningless.
		119	#
		120	exit 0
		121	fi
		122
		123	VERSION="^Linux version.* (.) (\(gcc.\)).*"
		124	KERNEL=$(cat /proc/version \| sed "s/$VERSION/\1/")
		125	MODULE=$($* -v 2>&1 \| tail -n 1)
		126
		127	if test "$KERNEL" != "$MODULE"; then
		128	#
		129	# The kernel seems to have been built with a different version
		130	# of the C compiler, which may be a problem.
		131	#
		132	exit 1
		133	else
		134	exit 0
		135	fi
		136	;;
		137
		138	kernel_patch_level)
		139	shift
		140	#
		141	# Determine the kernel's major patch level; this is only done if we
		142	# aren't told by KBUILD.
		143	#
		144	echo $(cat "$1"/Makefile \| grep "PATCHLEVEL =" \| cut -d " " -f 3)
		145	exit 0
		146	;;
		147
		148	suser_sanity_check)
		149	shift
		150	#
		151	# Determine the caller's user id to determine if we have sufficient
		152	# privileges for the requested operation.
		153	#
		154	if test $(id -ur) != 0; then
		155	exit 1
		156	else
		157	exit 0
		158	fi
		159	;;
		160
		161	rmmod_sanity_check)
		162	shift
		163	#
		164	# Make sure that any currently loaded NVIDIA kernel module can be
		165	# unloaded.
		166	#
		167	if /sbin/lsmod \| grep -q "$1"; then
		168	/sbin/rmmod "$1" >& /dev/null
		169	fi
		170
171	if /sbin/lsmod \| grep -q "$1"; then
172	#
173	# The NVIDIA kernel module is still loaded, most likely because
174	# it is busy.
175	#
176	exit 1
177	else
178	exit 0
179	fi
180	;;
107	esac	181	esac
108		182

Lines 1-141 Link Here

(-)NVIDIA_kernel-1.0-5328/Makefile (-141 lines)
1	# This Makefile is automatically generated; do not edit
2	# Generated on 'builder3.nvidia.com' on Wed Dec 17 13:54:52 PST 2003
3
4	LINUX_MODULE=nv-linux.o
5	DEFINES=-D__KERNEL__ -DMODULE -D_LOOSE_KERNEL_NAMES -DNTRM -D_GNU_SOURCE -D_LOOSE_KERNEL_NAMES -D__KERNEL__ -DMODULE -DNV_MAJOR_VERSION=1 -DNV_MINOR_VERSION=0 -DNV_PATCHLEVEL=5328 -DNV_UNIX -DNV_LINUX -DNV_INT64_OK -DNVCPU_X86
6	INCLUDES=-I.
7
8	OBJECTS=nv.o os-agp.o os-interface.o os-registry.o
9	HEADERS=os-agp.h os-interface.h nv-linux.h nv-misc.h nv-memdbg.h nv.h rmretval.h nvtypes.h $(VERSION_HDR)
10
11	CFLAGS=-Wall -Wimplicit -Wreturn-type -Wswitch -Wformat -Wchar-subscripts -Wparentheses -Wpointer-arith -Wno-multichar -Werror -O -MD $(DEFINES) $(INCLUDES) -Wno-cast-qual -Wno-error
12
13	RESMAN_KERNEL_MODULE=nv-kernel.o
14
15	KERNDIR=/lib/modules/$(shell uname -r)
16
17	# check for newer paths. if found, use them, otherwise use old paths
18	# these wouldn't work with the gnu make included with rh6.2
19	# KERNINC=$(if -d $(KERNDIR)/build, $(KERNDIR)/build/include, /usr/src/linux/include)
20	# INSTALLDIR=$(if -d $(KERNDIR)/kernel, $(KERNDIR)/kernel/drivers/video, $(KERNDIR)/video)
21
22	# this is slightly more brain-dead, but works..
23	ifeq ($(shell if test -d $(KERNDIR)/build; then echo yes; fi),yes)
24	KERNINC=$(KERNDIR)/build/include
25	else
26	KERNINC=/usr/src/linux/include
27	endif
28
29	ifeq ($(shell if test -d $(KERNDIR)/kernel; then echo yes; fi),yes)
30	INSTALLDIR=$(KERNDIR)/kernel/drivers/video
31	else
32	INSTALLDIR=$(KERNDIR)/video
33	endif
34
35	ifeq ($(shell echo $(NVDEBUG)),1)
36	ifeq ($(shell test -z $(RMDEBUG) && echo yes),yes)
37	RMDEBUG=1
38	endif
39	endif
40
41	ifeq ($(shell echo $(RMDEBUG)),1)
42	CFLAGS += -DDEBUG -g -fno-common
43	endif
44
45	# this is just plain wrong, get rid of it
46	BROKENDIR=$(KERNDIR)/kernel/video
47
48	INSTALL=$(shell which install)
49
50	# allow specification of alternate include file tree on command line and extra defines
51	ifdef SYSINCLUDE
52	INCLUDES += -I$(SYSINCLUDE)
53	else
54	INCLUDES += -I$(KERNINC)
55	endif
56
57	ifeq ($(shell sh conftest.sh remap_page_range $(INCLUDES)), 5)
58	DEFINES += -DREMAP_PAGE_RANGE_5
59	endif
60
61	ifeq ($(shell sh conftest.sh remap_page_range $(INCLUDES)), 4)
62	DEFINES += -DREMAP_PAGE_RANGE_4
63	endif
64
65	DEFINES+=$(EXTRA_DEFINES)
66
67	# allow build parameters to be passed in through the environment
68	ifdef BUILD_PARAMS
69	DEFINES+=-D$(BUILD_PARAMS)
70	endif
71
72	VERSION_HDR=nv_compiler.h
73
74	all: install
75
76	install: package-install
77
78	package-install: nvidia.o rmmod-check
79	@if [ `id -ur` != 0 ]; then \
80	echo Please run \"make install\" as root.; \
81	else \
82	if [ -d $(BROKENDIR) ]; then \
83	rm -f $(BROKENDIR)/NVdriver; \
84	rmdir --ignore-fail-on-non-empty $(BROKENDIR); \
85	fi && \
86	mkdir -p $(INSTALLDIR) && \
87	rm -f $(INSTALLDIR)/NVdriver && \
88	$(INSTALL) -m 0664 -o root -g root nvidia.o $(INSTALLDIR)/nvidia.o$(O) && \
89	PATH="$(PATH):/bin:/sbin" depmod -a && \
90	PATH="$(PATH):/bin:/sbin" modprobe nvidia && \
91	sh makedevices.sh && \
92	echo "nvidia.o installed successfully."; \
93	fi
94
95	RMMOD_ERROR=\
96	echo ""; \
97	echo "Unable to remove existing NVIDIA kernel module."; \
98	echo "Please be sure you have exited X before attempting"; \
99	echo "to install the NVIDIA kernel module."; \
100	echo ""; \
101	echo -en "\033[1;31m"; \
102	echo -e "* Failed rmmod sanity check. Bailing out! *"; \
103	echo -en "\033[0m"; \
104	exit 1;
105
106	rmmod-check:
107	@if PATH="$(PATH):/bin:/sbin" lsmod \| grep -w nvidia > /dev/null; then \
108	if ! PATH="($PATH):/bin:/sbin" rmmod nvidia > /dev/null; then $(RMMOD_ERROR) fi \
109	fi; \
110	if PATH="$(PATH):/bin:/sbin" lsmod \| grep -w NVdriver > /dev/null; then \
111	if ! PATH="$(PATH):/bin:/sbin" rmmod NVdriver > /dev/null; then $(RMMOD_ERROR) fi \
112	fi
113
114	gcc-check:
115	@if ! sh conftest.sh cc_sanity_check full_output $(CC); then exit 1; fi
116
117	nvidia.o: gcc-check $(LINUX_MODULE) $(RESMAN_KERNEL_MODULE)
118	ld -r -o $@ $(LINUX_MODULE) $(RESMAN_KERNEL_MODULE)
119
120	$(VERSION_HDR):
121	echo \#define NV_COMPILER \"`$(CC) -v 2>&1 \| tail -n 1`\" > $@
122
123	$(LINUX_MODULE): $(OBJECTS)
124	ld -r -o $@ $(OBJECTS)
125
126	%.o: %.c $(HEADERS)
127	$(CC) -c $(CFLAGS) $<
128
129	# debug tool to preprocess the file and leave .i to make it easier to untangle #defines
130	%.i: %.c
131	$(CC) $(CFLAGS) -E $< > $@
132
133	%.s: %.c
134	$(CC) $(CFLAGS) -S $< > $@
135
136
137	clean:
138	$(RM) $(OBJECTS) $(LINUX_MODULE) $(VERSION_HDR) *.d NVdriver nvidia.o
139
140
141	-include $(OBJECTS:%.o=%.d)

Line 0 Link Here

(-)NVIDIA_kernel-1.0-5328/Makefile.kbuild (+245 lines)
		1	#
		2	# KBUILD Makefile for the NVIDIA Linux kernel module.
		3	#
		4	# The motivation for replacing the original Makefile is the hope that this
		5	# version will simplify the build and installation process. In the past,
		6	# many architectural and cosmetic changes to the Linux kernel have made it
		7	# difficult to maintain compatibility or required duplication of logic.
		8	#
		9	# Linux 2.5 introduces numerous such changes, many of which impact modules.
		10	# Relying on KBUILD, some aspects of the build system otherwise difficult
		11	# to support (for example, module versioning) are abstracted away and dealt
		12	# with elsewhere, making life significantly easier here.
		13	#
		14	# The new approach currently has its own share of problems, some of which
		15	# are architectural difficulties with KBUILD, others minor annoyances. For
		16	# this reason, an improved version of the NVIDIA Makefile is available to
		17	# those experiencing difficulties.
		18	#
		19	# Please report any problems you may be experiencing with this experimental
		20	# Makefile to either one (or, preferably, both) of us:
		21	#
		22	# Alistair J Strachan (alistair@devzero.co.uk) (first pass, enhancements)
		23	# Christian Zander (zander@mail.minion.de) (enhancements)
		24	#
		25
		26	all: install
		27	install: package-install
		28
		29	#
		30	# The NVIDIA kernel module base name and static file names. KBUILD will go
		31	# ahead and append ".o" or ".ko" to form the final module name.
		32	#
		33
		34	MODULE_NAME := nvidia
		35	VERSION_HEADER := nv_compiler.h
		36
		37	#
		38	# List of object files to link into NVIDIA kernel module; make sure KBUILD
		39	# understands that we want a module.
		40	#
		41
		42	RESMAN_CORE_OBJS := nv-kernel.o
		43	RESMAN_GLUE_OBJS := nv.o os-agp.o os-interface.o os-registry.o
		44
		45	$(MODULE_NAME)-objs := $(RESMAN_CORE_OBJS) $(RESMAN_GLUE_OBJS)
		46
		47	#
		48	# A bug in KBUILD 2.4 means that leaving obj-m set in top-level context
		49	# will cause Rules.make to call pathdown.sh, which is wrong. So, we only
		50	# set this conditional of a kernel-level instance.
		51	#
		52
		53	ifdef TOPDIR
		54	obj-m += $(MODULE_NAME).o
		55	endif
		56
		57	#
		58	# Include local source directory in $(CC)'s include path and set disable any
		59	# warning types that are of little interest to us.
		60	#
		61
		62	EXTRA_CFLAGS += -I$(src)
		63	EXTRA_CFLAGS += -Wno-cast-qual -Wno-strict-prototypes
		64
65	#
66	# Determine location of the Linux kernel source tree. Allow users to override
67	# the default (i.e. automatically determined) kernel source location with the
68	# KERNDIR directive; this new directive replaces NVIDIA's SYSINCLUDE.
69	#
70
71	ifdef KERNDIR
72	KERNEL_SOURCES := $(KERNDIR)
73	KERNEL_HEADERS := -I$(KERNEL_SOURCES)/include
74	MODULE_ROOT := /lib/modules/$(shell uname -r)/kernel/drivers # XXX
75	else
76	KERNEL_SOURCES := /lib/modules/$(shell uname -r)/build
77	KERNEL_HEADERS := -I$(KERNEL_SOURCES)/include
78	MODULE_ROOT := /lib/modules/$(shell uname -r)/kernel/drivers
79	endif
80
81	#
82	# We rely on these two definitions below; if they aren't set, we set them to
83	# reasonable defaults (Linux 2.4's KBUILD, and top-level passes will not set
84	# these).
85	#
86
87	src ?= .
88	obj ?= .
89
90	#
91	# Sets any internal variables left unset by KBUILD (e.g. this happens during
92	# a top-level run).
93	#
94
95	TOPDIR ?= $(KERNEL_SOURCES)
96	PATCHLEVEL ?= $(shell sh $(src)/conftest.sh kernel_patch_level $(TOPDIR))
97
98	#
99	# Linux 2.4 uses the .o module extension. Linux 2.5, however, uses the .ko
100	# module extension. Handle these gracefully.
101	#
102
103	ifeq ($(PATCHLEVEL), 4)
104	MODULE_OBJECT := $(MODULE_NAME).o
105	else
106	MODULE_OBJECT := $(MODULE_NAME).ko
107	endif
108
109	#
110	# NVIDIA specific CFLAGS and #define's. The remap_page_range check has become
111	# necessary with the introduction of the five argument version to Linux 2.4
112	# distribution kernels; this conflicting change cannot be detected at compile
113	# time.
114	#
115
116	EXTRA_CFLAGS += -D__KERNEL__ -DMODULE -D_LOOSE_KERNEL_NAMES -DNTRM -D_GNU_SOURCE -D_LOOSE_KERNEL_NAMES -D__KERNEL__ -DMODULE -DNV_MAJOR_VERSION=1 -DNV_MINOR_VERSION=0 -DNV_PATCHLEVEL=5328 -DNV_UNIX -DNV_LINUX -DNV_INT64_OK -DNVCPU_X86
117
118	ifeq ($(shell echo $(NVDEBUG)),1)
119	ifeq ($(shell test -z $(RMDEBUG) && echo yes),yes)
120	RMDEBUG=1
121	endif
122	endif
123
124	ifeq ($(shell echo $(RMDEBUG)),1)
125	EXTRA_CFLAGS += -DDEBUG -g -fno-common
126	endif
127
128	ifeq ($(shell sh $(src)/conftest.sh remap_page_range $(KERNEL_HEADERS)), 5)
129	EXTRA_CFLAGS += -DREMAP_PAGE_RANGE_5
130	endif
131
132	ifeq ($(shell sh $(src)/conftest.sh remap_page_range $(KERNEL_HEADERS)), 4)
133	EXTRA_CFLAGS += -DREMAP_PAGE_RANGE_4
134	endif
135
136	#
137	# NVIDIA binary object file includes .common section.
138	#
139
140	EXTRA_LDFLAGS := -d
141
142	#
143	# Miscellaneous NVIDIA kernel module build support targets. They are needed
144	# to satisfy KBUILD requirements and to support NVIDIA specifics.
145	#
146
147	$(obj)/nv-kernel.o:
148	cp $(src)/$(RESMAN_CORE_OBJS) $(obj)/$(RESMAN_CORE_OBJS)
149
150	$(obj)/$(VERSION_HEADER):
151	echo \#define NV_COMPILER \"`$(CC) -v 2>&1 \| tail -n 1`\" > $@
152
153	$(obj)/nv.o: $(obj)/$(VERSION_HEADER)
154
155	#
156	# More quirks for Linux 2.4 KBUILD, which doesn't link automatically.
157	#
158
159	ifeq ($(PATCHLEVEL), 4)
160	$(obj)/$(MODULE_NAME).o: $($(MODULE_NAME)-objs)
161	$(LD) $(EXTRA_LDFLAGS) -r -o $@ $($(MODULE_NAME)-objs)
162	endif
163
164	#
165	# KBUILD build parameters.
166	#
167
168	KBUILD_PARAMS := -C $(KERNEL_SOURCES) SUBDIRS=$(PWD)
169
170	#
171	# NVIDIA sanity checks.
172	#
173
174	suser-sanity-check:
175	@if ! sh conftest.sh suser_sanity_check; then \
176	echo; \
177	echo "You have insufficient privileges for this operation. Please "; \
178	echo "run \"make install\" as root! "; \
179	echo; \
180	exit 1; \
181	fi
182
183	rmmod-sanity-check:
184	@if ! sh conftest.sh rmmod_sanity_check $(MODULE_NAME); then \
185	echo; \
186	echo "Unable to unload the currently loaded NVIDIA kernel module! "; \
187	echo "Please be certain that you have exited X before attempting "; \
188	echo "to install this version. "; \
189	echo; \
190	exit 1; \
191	fi
192
193	cc-sanity-check:
194	@if ! sh conftest.sh cc_sanity_check full_output $(CC); then \
195	exit 1; \
196	fi
197
198	#
199	# Build the NVIDIA kernel module using Linux KBUILD. This target is used by
200	# the "package-install" target below.
201	#
202
203	module: cc-sanity-check
204	@make $(KBUILD_PARAMS) modules; \
205	if ! [ -f $(MODULE_OBJECT) ]; then \
206	echo "$(MODULE_OBJECT) failed to build!"; \
207	exit 1; \
208	fi
209
210	#
211	# Build the NVIDIA kernel module with KBUILD. Verify that the user posesses
212	# sufficient privileges. Rebuild the module dependency file.
213	#
214
215	module-install: suser-sanity-check module
216	@mkdir -p $(MODULE_ROOT)/video; \
217	install -m 0664 -o root -g root $(MODULE_OBJECT) $(MODULE_ROOT)/video; \
218	/sbin/depmod -ae;
219
220	#
221	# This target builds, then installs, then creates device nodes and inserts
222	# the module, if successful.
223	#
224
225	package-install: module-install rmmod-sanity-check
226	@sh makedevices.sh; \
227	/sbin/modprobe $(MODULE_NAME) && \
228	echo "$(MODULE_OBJECT) installed successfully.";
229
230	#
231	# Support hack, KBUILD isn't prepared to clean up after external modules.
232	#
233
234	clean:
235	@rm -f $(RESMAN_GLUE_OBJS) .*.{cmd,flags}
236	@rm -f $(MODULE_NAME).{o,ko,mod.{o,c}} built-in.o $(VERSION_HEADER) *~
237
238	#
239	# Linux 2.4 KBUILD requires the inclusion of Rules.make; Linux 2.5's KBUILD
240	# includes dependencies automatically.
241	#
242
243	ifeq ($(PATCHLEVEL), 4)
244	include $(KERNEL_SOURCES)/Rules.make
245	endif

Line 0 Link Here

(-)NVIDIA_kernel-1.0-5328/Makefile.nvidia (+139 lines)
		1	# This Makefile is automatically generated; do not edit
		2	# Generated on 'builder3.nvidia.com' on Thu Jun 19 04:05:35 PDT 2003
		3
		4	LINUX_MODULE=nv-linux.o
		5	DEFINES=-D__KERNEL__ -DMODULE -D_LOOSE_KERNEL_NAMES -DKBUILD_MODNAME="nvidia" -DNTRM -D_GNU_SOURCE -D_LOOSE_KERNEL_NAMES -D__KERNEL__ -DMODULE -DNV_MAJOR_VERSION=1 -DNV_MINOR_VERSION=0 -DNV_PATCHLEVEL=5328 -DNV_UNIX -DNV_LINUX -DNV_INT64_OK -DNVCPU_X86
		6	INCLUDES=-I.
		7
		8	OBJECTS=nv.o os-agp.o os-interface.o os-registry.o
		9	HEADERS=os-agp.h os-interface.h nv-linux.h nv-misc.h nv-memdbg.h nv.h rmretval.h nvtypes.h $(VERSION_HDR)
		10
		11	CFLAGS=-Wall -Wimplicit -Wreturn-type -Wswitch -Wformat -Wchar-subscripts -Wparentheses -Wcast-qual -Wno-multichar -O -MD $(DEFINES) $(INCLUDES) -Wno-cast-qual
		12
		13	RESMAN_KERNEL_MODULE=nv-kernel.o
		14
		15	KERNDIR=/lib/modules/$(shell uname -r)
		16
		17	# check for newer paths. if found, use them, otherwise use old paths
		18	# these wouldn't work with the gnu make included with rh6.2
		19	# KERNINC=$(if -d $(KERNDIR)/build, $(KERNDIR)/build/include, /usr/src/linux/include)
		20	# INSTALLDIR=$(if -d $(KERNDIR)/kernel, $(KERNDIR)/kernel/drivers/video, $(KERNDIR)/video)
		21
		22	# this is slightly more brain-dead, but works..
		23	ifeq ($(shell if test -d $(KERNDIR)/build; then echo yes; fi),yes)
		24	KERNINC=$(KERNDIR)/build/include
		25	else
		26	KERNINC=/usr/src/linux/include
		27	endif
		28
		29	ifeq ($(shell if test -d $(KERNDIR)/kernel; then echo yes; fi),yes)
		30	INSTALLDIR=$(KERNDIR)/kernel/drivers/video
		31	else
		32	INSTALLDIR=$(KERNDIR)/video
		33	endif
		34
		35	ifeq ($(shell echo $(NVDEBUG)),1)
		36	ifeq ($(shell test -z $(RMDEBUG) && echo yes),yes)
		37	RMDEBUG=1
		38	endif
		39	endif
		40
		41	ifeq ($(shell echo $(RMDEBUG)),1)
		42	CFLAGS += -DDEBUG -g -fno-common
		43	endif
		44
		45	# this is just plain wrong, get rid of it
		46	BROKENDIR=$(KERNDIR)/kernel/video
		47
		48	INSTALL=$(shell which install)
		49
		50	# allow specification of alternate include file tree on command line and extra defines
		51	ifdef SYSINCLUDE
		52	INCLUDES += -I$(SYSINCLUDE)
		53	INCLUDES += -I$(SYSINCLUDE)/asm/mach-default
		54	else
		55	INCLUDES += -I$(KERNINC)
		56	INCLUDES += -I$(KERNINC)/asm/mach-default
		57	endif
		58
		59	ifeq ($(shell sh conftest.sh remap_page_range $(INCLUDES)), 5)
		60	DEFINES += -DREMAP_PAGE_RANGE_5
		61	endif
		62
		63	ifeq ($(shell sh conftest.sh remap_page_range $(INCLUDES)), 4)
		64	DEFINES += -DREMAP_PAGE_RANGE_4
65	endif
66
67	DEFINES+=$(EXTRA_DEFINES)
68
69	# allow build parameters to be passed in through the environment
70	ifdef BUILD_PARAMS
71	DEFINES+=-D$(BUILD_PARAMS)
72	endif
73
74	VERSION_HDR=nv_compiler.h
75
76	all: install
77
78	install: package-install
79
80	suser-sanity-check:
81	@if ! sh conftest.sh suser_sanity_check; then \
82	echo; \
83	echo "You have insufficient privileges for this operation. Please "; \
84	echo "run \"make install\" as root! "; \
85	echo; \
86	exit 1; \
87	fi
88
89	rmmod-sanity-check:
90	@if ! sh conftest.sh rmmod_sanity_check nvidia; then \
91	echo; \
92	echo "Unable to unload the currently loaded NVIDIA kernel module! "; \
93	echo "Please be certain that you have exited X before attempting "; \
94	echo "to install this version. "; \
95	echo; \
96	exit 1; \
97	fi
98
99	cc-sanity-check:
100	@if ! sh conftest.sh cc_sanity_check full_output $(CC); then exit 1; fi
101
102	package-install: suser-sanity-check nvidia.o rmmod-sanity-check
103	if [ -d $(BROKENDIR) ]; then \
104	rm -f $(BROKENDIR)/NVdriver; \
105	rmdir --ignore-fail-on-non-empty $(BROKENDIR); \
106	fi && \
107	mkdir -p $(INSTALLDIR) && \
108	rm -f $(INSTALLDIR)/NVdriver && \
109	$(INSTALL) -m 0664 -o root -g root nvidia.o $(INSTALLDIR)/nvidia.o$(O) && \
110	/sbin/depmod -a && \
111	/sbin/modprobe nvidia && \
112	sh makedevices.sh && \
113	echo "nvidia.o installed successfully."; \
114
115	nvidia.o: cc-sanity-check $(LINUX_MODULE) $(RESMAN_KERNEL_MODULE)
116	ld -d -r -o $@ $(LINUX_MODULE) $(RESMAN_KERNEL_MODULE)
117
118	$(VERSION_HDR):
119	echo \#define NV_COMPILER \"`$(CC) -v 2>&1 \| tail -n 1`\" > $@
120
121	$(LINUX_MODULE): $(OBJECTS)
122	ld -r -o $@ $(OBJECTS)
123
124	%.o: %.c $(HEADERS)
125	$(CC) -c $(CFLAGS) $<
126
127	# debug tool to preprocess the file and leave .i to make it easier to untangle #defines
128	%.i: %.c
129	$(CC) $(CFLAGS) -E $< > $@
130
131	%.s: %.c
132	$(CC) $(CFLAGS) -S $< > $@
133
134
135	clean:
136	$(RM) $(OBJECTS) $(LINUX_MODULE) $(VERSION_HDR) *.d NVdriver nvidia.o
137
138
139	-include $(OBJECTS:%.o=%.d)

Lines 8-54 Link Here

(-)NVIDIA_kernel-1.0-5328/makedevices.sh (-38 / +40 lines)
8	# create a temporary file	8	# create a temporary file
9	tmp=`(mktemp -q /tmp/nvidia.XXXXXX) 2> /dev/null` \|\| tmp="/tmp/nvidia.$$"	9	tmp=`(mktemp -q /tmp/nvidia.XXXXXX) 2> /dev/null` \|\| tmp="/tmp/nvidia.$$"
10		10
11	paths=" /etc/modutils/aliases \	11	modconfs=" /etc/modutils/aliases \
12	/etc/modules.conf \	12	/etc/modules.conf \
13	/etc/conf.modules "	13	/etc/modprobe.d/aliases \
14		14	/etc/modprobe.conf \
15	modconf=""	15	/etc/conf.modules "
16	for path in $paths; do	16
17	if [ -f "$path" ]; then	17	#
18	modconf=$path	18	# Pass the -p option to cp to preserve the permissions of $modconf and
19	break	19	# /etc/rc.d/rc.modules across the update. Update all relevant files
		20	# including those eventually regenerated to avoid the need for awkward
		21	# logic here.
		22	#
		23	for modconf in $modconfs; do
		24	if [ -f "$modconf" ]; then
		25	cp -p $modconf $tmp
		26	sed '/^alias.*\(NVdriver\\|nvidia\)/d' < $modconf > $tmp
		27
		28	# make sure the last character in the file is a newline
		29	[ `tail -n 1 $tmp \| wc -l` = 0 ] && echo "" >> $tmp
		30
		31	if [ -c /dev/.devfsd ]; then
		32	echo "alias /dev/nvidia* nvidia" >> $tmp
		33	else
		34	if [ `uname -r \| cut -d '.' -f 2` = 6 ]; then
		35	echo "alias char-major-195* nvidia" >> $tmp
		36	else
		37	echo "alias char-major-195 nvidia" >> $tmp
		38	fi
		39	fi
		40	mv -f $tmp $modconf
		41	test -x /sbin/update-modules && /sbin/update-modules
20	fi	42	fi
21	done	43	done
22		44
23	if [ ! -z $modconf ]; then	45	if [ -f /etc/rc.d/rc.modules ]; then
24	# Initialize the permissions on $tmp so that we don't change the	46	cp -p /etc/rc.d/rc.modules $tmp
25	# permissions of $modconf when we mv it into place	47	sed '/.\(NVdriver\\|nvidia\)./d' < /etc/rc.d/rc.modules > $tmp
26	cp -p $modconf $tmp	48
27	sed '/^alias.*\(NVdriver\\|nvidia\)/d' < $modconf > $tmp	49	# make sure the last character in the file is a newline
28		50	[ `tail -n 1 $tmp \| wc -l` = 0 ] && echo "" >> $tmp
29	# make sure the last character in the file is a newline	51
30	[ `tail -n 1 $tmp \| wc -l` = 0 ] && echo "" >> $tmp	52	echo -e "\n/sbin/modprobe nvidia" >> $tmp
31		53	mv -f $tmp /etc/rc.d/rc.modules
32	if [ -c /dev/.devfsd ]; then
33	echo "alias /dev/nvidia* nvidia" >> $tmp
34	else
35	echo "alias char-major-195 nvidia" >> $tmp
36	fi
37	mv -f $tmp $modconf
38	test -x /sbin/update-modules && /sbin/update-modules
39	else
40	if [ -f /etc/rc.d/rc.modules ]; then
41	# Initialize the permissions on $tmp so that we don't change the
42	# permissions of /etc/rc.d/rc.modules when we mv it into place
43	cp -p /etc/rc.d/rc.modules $tmp
44	sed '/.\(NVdriver\\|nvidia\)./d' < /etc/rc.d/rc.modules > $tmp
45
46	# make sure the last character in the file is a newline
47	[ `tail -n 1 $tmp \| wc -l` = 0 ] && echo "" >> $tmp
48
49	echo "/sbin/modprobe nvidia" >> $tmp
50	mv -f $tmp /etc/rc.d/rc.modules
51	fi
52	fi	54	fi
53		55
54	if [ ! -c /dev/.devfsd ]; then	56	if [ ! -c /dev/.devfsd ]; then

Lines 21-54 Link Here

(-)NVIDIA_kernel-1.0-5328/nv-linux.h (-87 / +173 lines)
21	# define MODVERSIONS	21	# define MODVERSIONS
22	#endif	22	#endif
23		23
24	#if defined (MODVERSIONS)
25	#include <linux/modversions.h>
26	#endif
27
28	#include <linux/kernel.h>	24	#include <linux/kernel.h>
29	#include <linux/module.h>	25	#include <linux/module.h>
30		26
31	#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 2, 12)	27	#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 0)
32	# error This driver does not support 2.2.11 or earlier kernels!	28	# error This driver does not support 2.2.x kernels!
33	#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 3, 0)
34	# define KERNEL_2_2
35	# warning NVIDIA is considering dropping support for linux-2.2
36	# warning kernels. While end users are free to maintain their
37	# warning own patches, or stick with current drivers, our new
38	# warning drivers will not work "out of the box." If you are
39	# warning concerned about lack of support for 2.2 kernels,
40	# warning please let us know at linux-bugs@nvidia.com; we would
41	# warning like to know how many users would be seriously
42	# warning impacted by this decision.
43	#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 0)	29	#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 0)
44	# error This driver does not support 2.3.x development kernels!	30	# error This driver does not support 2.3.x kernels!
45	#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)	31	#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
46	# define KERNEL_2_4	32	# define KERNEL_2_4
47	#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)	33	#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
48	# error This driver does not support 2.5.x development kernels!	34	# error This driver does not support 2.5.x kernels!
49	# define KERNEL_2_5	35	#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 7, 0)
		36	# define KERNEL_2_6
50	#else	37	#else
51	# error This driver does not support 2.6.x or newer kernels!	38	# error This driver does not support development kernels!
52	#endif	39	#endif
53		40
54	#if defined (__ia64)	41	#if defined (__ia64)
Lines 61-72 Link Here
61	#define __SMP__	48	#define __SMP__
62	#endif	49	#endif
63		50
		51	#if defined (MODVERSIONS) && !defined (KERNEL_2_6)
		52	#include <linux/modversions.h>
		53	#endif
		54
64	#include <linux/types.h> /* pic_t, size_t, __u32, etc */	55	#include <linux/types.h> /* pic_t, size_t, __u32, etc */
65	#include <linux/errno.h> /* error codes */	56	#include <linux/errno.h> /* error codes */
66	#include <linux/list.h> /* circular linked list */	57	#include <linux/list.h> /* circular linked list */
67	#include <linux/stddef.h> /* NULL, offsetof */	58	#include <linux/stddef.h> /* NULL, offsetof */
68	#include <linux/wait.h> /* wait queues */	59	#include <linux/wait.h> /* wait queues */
69	#include <linux/tqueue.h> /* struct tq_struct */
70		60
71	#include <linux/slab.h> /* kmalloc, kfree, etc */	61	#include <linux/slab.h> /* kmalloc, kfree, etc */
72	#include <linux/vmalloc.h> /* vmalloc, vfree, etc */	62	#include <linux/vmalloc.h> /* vmalloc, vfree, etc */
Lines 74-82 Link Here
74	#include <linux/poll.h> /* poll_wait */	64	#include <linux/poll.h> /* poll_wait */
75	#include <linux/delay.h> /* mdelay, udelay */	65	#include <linux/delay.h> /* mdelay, udelay */
76		66
		67	#ifdef KERNEL_2_6
		68	#include <linux/sched.h> /* suser(), capable() replacement */
		69	#include <linux/moduleparam.h> /* module_param() */
		70	#include <linux/smp_lock.h> /* kernel_locked */
		71	#include <asm/kmap_types.h> /* page table entry lookup */
		72	#endif
		73
77	#include <linux/pci.h> /* pci_find_class, etc */	74	#include <linux/pci.h> /* pci_find_class, etc */
78	#include <linux/wrapper.h> /* mem_map_reserve */	75	#include <linux/interrupt.h> /* tasklets, interrupt helpers */
79	#include <linux/interrupt.h> /* mark_bh, init_bh, remove_bh */
80	#include <linux/timer.h>	76	#include <linux/timer.h>
81		77
82	#include <asm/system.h> /* cli, sli, save_flags */	78	#include <asm/system.h> /* cli, sli, save_flags */
Lines 85-98 Link Here
85	#include <asm/page.h> /* PAGE_OFFSET */	81	#include <asm/page.h> /* PAGE_OFFSET */
86	#include <asm/pgtable.h> /* pte bit definitions */	82	#include <asm/pgtable.h> /* pte bit definitions */
87		83
88	#if !defined (KERNEL_2_2)
89	#include <linux/spinlock.h>	84	#include <linux/spinlock.h>
90	#include <asm/semaphore.h>	85	#include <asm/semaphore.h>
91	#include <linux/highmem.h>	86	#include <linux/highmem.h>
92	#else
93	#include <asm/spinlock.h>
94	#include <asm/semaphore.h>
95	#endif
96		87
97	#ifdef CONFIG_PROC_FS	88	#ifdef CONFIG_PROC_FS
98	#include <linux/proc_fs.h>	89	#include <linux/proc_fs.h>
Lines 377-454 Link Here
377		368
378	#endif /* !defined NVWATCH */	369	#endif /* !defined NVWATCH */
379		370
		371	#define GET_MODULE_SYMBOL(mod,sym) (const void *) inter_module_get(sym)
		372	#define PUT_MODULE_SYMBOL(sym) (inter_module_put((char *) sym))
380		373
381	#if !defined (KERNEL_2_2)	374	#ifdef KERNEL_2_6
382	# define LINUX_VMA_OFFS(vma) (((vma)->vm_pgoff) << PAGE_SHIFT)	375	# define NV_IS_SUSER() capable(CAP_SYS_ADMIN)
383	# define GET_MODULE_SYMBOL(mod,sym) (const void *) inter_module_get(sym)	376	# define NV_PCI_DEVICE_NAME(x) ((x)->pretty_name)
384	# define PUT_MODULE_SYMBOL(sym) inter_module_put((char *) sym)	377	# define NV_CLI() local_irq_disable()
385	# define GET_MAP_NR(phys_page) virt_to_page(__va(phys_page))	378	# define NV_SAVE_FLAGS(x) local_save_flags(x)
386	# define MEM_MAP_READ_COUNT(map_nr) (atomic_read(&(map_nr)->count))	379	# define NV_RESTORE_FLAGS(x) local_irq_restore(x)
387	# define MEM_MAP_INC_COUNT(map_nr) (atomic_inc(&(map_nr)->count))	380	# define NV_MAY_SLEEP() (!in_interrupt() && !in_atomic())
388	# define MEM_MAP_DEC_COUNT(map_nr) (atomic_dec(&(map_nr)->count))	381	# define NV_SMP_NUM_CPUS num_online_cpus()
389	# define EVENT_QUEUE(ptr) ((struct __wait_queue_head *)(ptr))	382	# define NV_MODULE_PARAMETER(x) module_param(x, int, 0)
390	# define VMA_PRIVATE(vma) ((vma)->vm_private_data)	383	#else
391	# define INIT_EVENT_QUEUE(ptr) \	384	# define NV_IS_SUSER() suser()
392	if (ptr == NULL) { \	385	# define NV_PCI_DEVICE_NAME(x) ((x)->name)
393	NV_KMALLOC((ptr), sizeof(struct __wait_queue_head)); \	386	# define NV_CLI() cli()
394	if (ptr) { \	387	# define NV_SAVE_FLAGS(x) save_flags(x)
395	memset((ptr), 0, sizeof(struct __wait_queue_head)); \	388	# define NV_RESTORE_FLAGS(x) restore_flags(x)
396	init_waitqueue_head((struct __wait_queue_head *)(ptr)); \	389	# define NV_MAY_SLEEP() (!in_interrupt())
397	} \	390	# define NV_SMP_NUM_CPUS smp_num_cpus
398	}	391	# define NV_MODULE_PARAMETER(x) MODULE_PARM(x, "i")
399	# define FREE_EVENT_QUEUE(ptr) NV_KFREE((ptr), sizeof(struct __wait_queue_head)); (ptr) = NULL;	392	#endif
400	#else	393
401	# define in_irq() (local_irq_count[smp_processor_id()])	394	#define NV_DEVICE_NUMBER(x) minor((x)->i_rdev)
402	# define LINUX_VMA_OFFS(vma) ((vma)->vm_offset)	395	#define NV_VMA_OFFSET(x) (((x)->vm_pgoff) << PAGE_SHIFT)
403	# define GET_MODULE_SYMBOL(mod, sym) (void*) get_module_symbol((mod), (sym))	396	#define NV_VMA_PRIVATE(x) ((x)->vm_private_data)
404	# define PUT_MODULE_SYMBOL(sym)	397	#define NV_IS_CONTROL_DEVICE(x) (minor((x)->i_rdev) == 255)
405	# define GET_MAP_NR(phys_page) MAP_NR(__va(phys_page))	398
406	# define MEM_MAP_READ_COUNT(map_nr) (atomic_read(&mem_map[map_nr].count))	399	#ifndef minor
407	# define MEM_MAP_INC_COUNT(map_nr) (atomic_inc(&mem_map[map_nr].count))	400	/*
408	# define MEM_MAP_DEC_COUNT(map_nr) (atomic_dec(&mem_map[map_nr].count))	401	* XXX Is this correct for all possible target kernels? We need this to
409	# define EVENT_QUEUE(ptr) ((struct wait_queue **) &(ptr))	402	* support older 2.4 and some 2.6 kernels.
410	# define VMA_PRIVATE(vma) ((void*)((vma)->vm_pte))	403	*/
411	# define INIT_EVENT_QUEUE(ptr) if (ptr) { ((ptr) = NULL); }	404	# define minor(x) MINOR(x)
412	# define FREE_EVENT_QUEUE(ptr)	405	#endif
		406
		407	#ifndef KERNEL_2_6
		408	typedef void irqreturn_t;
		409	# define IRQ_NONE
		410	# define IRQ_RETVAL(x)
		411	# define IRQ_HANDLED
		412	#else
		413	#ifdef AGPGART
		414	typedef struct agp_kern_info agp_kern_info;
		415	typedef struct agp_memory agp_memory;
		416	#endif
		417	typedef void* devfs_handle_t;
		418	#endif
		419
		420	#ifdef KERNEL_2_6
		421	#define NV_DEVFS_REGISTER(_name, _minor) \
		422	({ \
		423	devfs_handle_t __handle = NULL; \
		424	devfs_mk_cdev(MKDEV(NV_MAJOR_DEVICE_NUMBER, _minor), \
		425	S_IFCHR \| S_IRUGO \| S_IWUGO, _name); \
		426	__handle; \
		427	})
		428
		429	#define NV_DEVFS_REMOVE_DEVICE(i) devfs_remove("nvidia%d", i)
		430	#define NV_DEVFS_REMOVE_CONTROL() devfs_remove("nvidiactl")
		431	#else
		432	#define NV_DEVFS_REGISTER(_name, _minor) \
		433	({ \
		434	devfs_handle_t __handle = \
		435	devfs_register(NULL, _name, DEVFS_FL_DEFAULT, \
		436	NV_MAJOR_DEVICE_NUMBER, _minor, \
		437	S_IFCHR \| S_IRUGO \| S_IWUGO, &nv_fops, NULL); \
		438	__handle; \
		439	})
		440
		441	#define NV_DEVFS_REMOVE_DEVICE(i) devfs_unregister(nv_devfs_handles[i+1])
		442	#define NV_DEVFS_REMOVE_CONTROL() devfs_unregister(nv_devfs_handles[0])
413	#endif	443	#endif
414		444
		445	/*
		446	* Linux 2.5 introduced the five argument version of remap_page_range, all
		447	* relevant releases to date use it. This version was backported to 2.4 by
		448	* RedHat without means to identify the change, hence this hack.
		449	*/
		450	#ifdef KERNEL_2_6
		451	#define NV_REMAP_PAGE_RANGE(a, b...) remap_page_range(vma, a, ## b)
		452	#else
415	#if defined(REMAP_PAGE_RANGE_5)	453	#if defined(REMAP_PAGE_RANGE_5)
416	#define NV_REMAP_PAGE_RANGE(a, b...) remap_page_range(vma, a, ## b)	454	#define NV_REMAP_PAGE_RANGE(a, b...) remap_page_range(vma, a, ## b)
417	#elif defined(REMAP_PAGE_RANGE_4)	455	#elif defined(REMAP_PAGE_RANGE_4)
418	#define NV_REMAP_PAGE_RANGE(a, b...) remap_page_range(a, ## b)	456	#define NV_REMAP_PAGE_RANGE(a, b...) remap_page_range(a, ## b)
419	#else	457	#else
420	#error "Couldn't determine number of arguments expected by remap_page_range!"	458	#warning "conftest.sh failed, assuming old Linux 2.4 remap_page_range(4)!"
		459
		460	#define NV_REMAP_PAGE_RANGE(a, b...) remap_page_range(a, ## b)
421	#endif	461	#endif
		462	#endif /* KERNEL_2_6 */
422		463
423	#if defined(pte_offset_atomic)	464	#if defined(pmd_offset_map)
424	#define NV_PTE_OFFSET(addres, pg_mid_dir, pte) \	465	#define NV_PMD_OFFSET(address, pgd, pmd) \
		466	{ \
		467	pmd = pmd_offset_map(pgd, address); \
		468	}
		469	#define NV_PMD_UNMAP(pmd) \
425	{ \	470	{ \
426	pte_t *pte__ = pte_offset_atomic(pg_mid_dir, address); \	471	pmd_unmap(pmd); \
427	pte = *pte__; \
428	pte_kunmap(pte__); \
429	}	472	}
430	#elif defined(pte_offset)
431	#define NV_PTE_OFFSET(addres, pg_mid_dir, pte) \
432	pte = *pte_offset(pg_mid_dir, address)
433	#else	473	#else
434	#define NV_PTE_OFFSET(addres, pg_mid_dir, pte) \	474	#define NV_PMD_OFFSET(address, pgd, pmd) \
435	{ \	475	{ \
436	pte_t *pte__ = pte_offset_map(pg_mid_dir, address); \	476	pmd = pmd_offset(pgd, address); \
437	pte = *pte__; \
438	pte_unmap(pte__); \
439	}	477	}
		478	#define NV_PMD_UNMAP(pmd)
440	#endif	479	#endif
441		480
442	#define NV_PAGE_ALIGN(addr) ( ((addr) + PAGE_SIZE - 1) / PAGE_SIZE)	481	#define NV_PMD_PRESENT(pmd) \
443	#define NV_MASK_OFFSET(addr) ( (addr) & (PAGE_SIZE - 1) )	482	({ \
		483	if (pmd) { \
		484	if (pmd_none(*pmd)) { \
		485	NV_PMD_UNMAP(pmd); pmd = NULL; \
		486	} \
		487	} pmd != NULL; \
		488	})
444		489
445	#ifndef MAXMEM /* temporary define for 2.2 kernels */	490	#if defined (pte_offset_atomic)
446	#define MAXMEM (-PAGE_OFFSET - (64 * 1024 * 1024))	491	#define NV_PTE_OFFSET(address, pmd, pte) \
		492	{ \
		493	pte = pte_offset_atomic(pmd, address); \
		494	NV_PMD_UNMAP(pmd); \
		495	}
		496	#define NV_PTE_UNMAP(pte) \
		497	{ \
		498	pte_kunmap(pte); \
		499	}
		500	#elif defined (pte_offset)
		501	#define NV_PTE_OFFSET(address, pmd, pte) \
		502	{ \
		503	pte = pte_offset(pmd, address); \
		504	NV_PMD_UNMAP(pmd); \
		505	}
		506	#define NV_PTE_UNMAP(pte)
		507	#else
		508	#define NV_PTE_OFFSET(address, pmd, pte) \
		509	{ \
		510	pte = pte_offset_map(pmd, address); \
		511	NV_PMD_UNMAP(pmd); \
		512	}
		513	#define NV_PTE_UNMAP(pte) \
		514	{ \
		515	pte_unmap(pte); \
		516	}
447	#endif	517	#endif
448		518
449	#ifndef NV01_ROOT	519	#define NV_PTE_PRESENT(pte) \
450	#define NV01_ROOT 0x00000000	520	({ \
451	#endif	521	if (pte) { \
		522	if (!pte_present(*pte)) { \
		523	NV_PTE_UNMAP(pte); pte = NULL; \
		524	} \
		525	} pte != NULL; \
		526	})
		527
		528	#define NV_PTE_VALUE(pte) \
		529	({ \
		530	unsigned long __pte_value = pte_val(*pte); \
		531	NV_PTE_UNMAP(pte); \
		532	__pte_value; \
		533	})
		534
		535	#define NV_PAGE_ALIGN(addr) ( ((addr) + PAGE_SIZE - 1) / PAGE_SIZE)
		536	#define NV_MASK_OFFSET(addr) ( (addr) & (PAGE_SIZE - 1) )
452		537
453	#if defined(NVCPU_IA64)	538	#if defined(NVCPU_IA64)
454	#define NV_GFP_HW (GFP_KERNEL \| __GFP_DMA)	539	#define NV_GFP_HW (GFP_KERNEL \| __GFP_DMA)
Lines 475-481 Link Here
475	static inline int NV_IRQL_IS_RAISED()	560	static inline int NV_IRQL_IS_RAISED()
476	{	561	{
477	unsigned long int eflags;	562	unsigned long int eflags;
478	__save_flags(eflags);	563	NV_SAVE_FLAGS(eflags);
479	return !(eflags & NV_CPU_INTERRUPT_FLAGS_BIT);	564	return !(eflags & NV_CPU_INTERRUPT_FLAGS_BIT);
480	}	565	}
481		566
Lines 557-565 Link Here
557	struct pci_dev *dev;	642	struct pci_dev *dev;
558	nv_alloc_t *alloc_queue;	643	nv_alloc_t *alloc_queue;
559		644
560	// bottom half interrupt handler info; per device	645	/* keep track of any pending bottom halfes */
561	/* keep track of any pending bottom-halves */	646	struct tasklet_struct tasklet;
562	struct tq_struct *bh;	647
		648	/* active bottom half counter */
563	atomic_t bh_count;	649	atomic_t bh_count;
564		650
565	/* get a timer callback every second */	651	/* get a timer callback every second */
Lines 597-603 Link Here
597	U032 num_events;	683	U032 num_events;
598	U032 put, get;	684	U032 put, get;
599	spinlock_t fp_lock;	685	spinlock_t fp_lock;
600	void *wqueue; // wait_queue for polling	686	wait_queue_head_t waitqueue;
601	nv_event_t *event_fifo; // fifo for storing events	687	nv_event_t *event_fifo; // fifo for storing events
602	} nv_file_private_t;	688	} nv_file_private_t;
603		689

Lines 45-88 Link Here

(-)NVIDIA_kernel-1.0-5328/os-agp.c (-114 / +43 lines)
45	int ready;	45	int ready;
46	} agp_gart;	46	} agp_gart;
47		47
48	typedef struct {
49	int (*backend_acquire)(void);
50	void (*backend_release)(void);
51	void (copy_info)(agp_kern_info );
52	agp_memory * (*allocate_memory)(size_t, unsigned int);
53	void (free_memory)(agp_memory );
54	int (bind_memory)(agp_memory , off_t);
55	int (unbind_memory)(agp_memory );
56	void (*enable)(unsigned int);
57	} agp_operations_struct;
58
59	agp_operations_struct agp_ops;
60	agp_kern_info agpinfo;	48	agp_kern_info agpinfo;
61	agp_gart gart;	49	agp_gart gart;
62	#if !defined (KERNEL_2_2)
63	const drm_agp_t *drm_agp_p;	50	const drm_agp_t *drm_agp_p;
64	#endif
65
66	#if defined (KERNEL_2_2)
67	#define GET_AGPGART_SYMBOL(sym, sym_string) \
68	sym = (void*) GET_MODULE_SYMBOL(0, sym_string); \
69	if (sym == NULL) \
70	{ \
71	nv_printf(NV_DBG_ERRORS, \
72	"NVRM: AGPGART: unable to retrieve symbol %s\n", \
73	sym_string); \
74	return 1; \
75	}
76
77	#define AGP_BACKEND_ACQUIRE_SYM __MODULE_STRING(agp_backend_acquire)
78	#define AGP_BACKEND_RELEASE_SYM __MODULE_STRING(agp_backend_release)
79	#define AGP_COPY_INFO_SYM __MODULE_STRING(agp_copy_info)
80	#define AGP_ALLOCATE_MEMORY_SYM __MODULE_STRING(agp_allocate_memory)
81	#define AGP_FREE_MEMORY_SYM __MODULE_STRING(agp_free_memory)
82	#define AGP_BIND_MEMORY_SYM __MODULE_STRING(agp_bind_memory)
83	#define AGP_UNBIND_MEMORY_SYM __MODULE_STRING(agp_unbind_memory)
84	#define AGP_ENABLE_SYM __MODULE_STRING(agp_enable)
85	#endif
86		51
87	#if defined(CONFIG_MTRR)	52	#if defined(CONFIG_MTRR)
88	#define MTRR_DEL(gart) if ((gart).mtrr > 0) mtrr_del((gart).mtrr, 0, 0);	53	#define MTRR_DEL(gart) if ((gart).mtrr > 0) mtrr_del((gart).mtrr, 0, 0);
Lines 110-157 Link Here
110		75
111	memset( (void *) &gart, 0, sizeof(agp_gart));	76	memset( (void *) &gart, 0, sizeof(agp_gart));
112		77
113	#if !defined (KERNEL_2_2)	78	/*
		79	* XXX The inter_module_* mechanism has been deprecated and replaced with
		80	* a different mechanism in Linux 2.5; it will go away eventually.
		81	* Also, the Linux 2.5 AGP GART driver is modularized, agpgart.o does not
		82	* include backend drivers.
		83	*/
114	if (!(drm_agp_p = inter_module_get_request("drm_agp", "agpgart")))	84	if (!(drm_agp_p = inter_module_get_request("drm_agp", "agpgart")))
115	{	85	{
116	nv_printf(NV_DBG_ERRORS,	86	nv_printf(NV_DBG_ERRORS,
117	"NVRM: AGPGART: unable to retrieve symbol table\n");	87	"NVRM: AGPGART: unable to retrieve symbol table\n");
118	return 1;	88	return 1;
119	}	89	}
120
121	agp_ops.backend_acquire = drm_agp_p->acquire;
122	agp_ops.backend_release = drm_agp_p->release;
123	agp_ops.allocate_memory = drm_agp_p->allocate_memory;
124	agp_ops.free_memory = drm_agp_p->free_memory;
125	agp_ops.bind_memory = drm_agp_p->bind_memory;
126	agp_ops.unbind_memory = drm_agp_p->unbind_memory;
127	agp_ops.enable = drm_agp_p->enable;
128
129	// looks like some newer kernels (for example mandrake 9.0's 2.4.19-16mdk)
130	// have updated copy_info to return an integer value, and of course didn't
131	// bother bumping the agpgart revision up. The return value is pretty
132	// harmless (backend_acquire would have already failed and caused us to
133	// bail), so cast the function pointer to avoid compiler warnings.
134	// we may need to revisit this in the future.
135	agp_ops.copy_info = (void ()(agp_kern_info )) drm_agp_p->copy_info;
136
137	#else
138	#if defined(CONFIG_KMOD)
139	if ( request_module("agpgart") )
140	{
141	nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: not loading agpgart.o\n");
142	return 1;
143	}
144	#endif
145
146	GET_AGPGART_SYMBOL(agp_ops.backend_acquire, AGP_BACKEND_ACQUIRE_SYM);
147	GET_AGPGART_SYMBOL(agp_ops.backend_release, AGP_BACKEND_RELEASE_SYM);
148	GET_AGPGART_SYMBOL(agp_ops.copy_info, AGP_COPY_INFO_SYM);
149	GET_AGPGART_SYMBOL(agp_ops.allocate_memory, AGP_ALLOCATE_MEMORY_SYM);
150	GET_AGPGART_SYMBOL(agp_ops.free_memory, AGP_FREE_MEMORY_SYM);
151	GET_AGPGART_SYMBOL(agp_ops.bind_memory, AGP_BIND_MEMORY_SYM);
152	GET_AGPGART_SYMBOL(agp_ops.unbind_memory, AGP_UNBIND_MEMORY_SYM);
153	GET_AGPGART_SYMBOL(agp_ops.enable, AGP_ENABLE_SYM);
154	#endif
155		90
156	/* NOTE: from here down, return an error code of '-1'	91	/* NOTE: from here down, return an error code of '-1'
157	* that indicates that agpgart is loaded, but we failed to use it	92	* that indicates that agpgart is loaded, but we failed to use it
Lines 159-165 Link Here
159	* the memory controller.	94	* the memory controller.
160	*/	95	*/
161		96
162	if ( (*(agp_ops.backend_acquire))() )	97	if (drm_agp_p->acquire())
163	{	98	{
164	nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: backend in use\n");	99	nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: backend in use\n");
165	return -1;	100	return -1;
Lines 177-183 Link Here
177	agp_fw = 1;	112	agp_fw = 1;
178	agp_fw &= 0x00000001;	113	agp_fw &= 0x00000001;
179		114
180	(*(agp_ops.copy_info))(&agpinfo);	115	#if defined(KERNEL_2_4)
		116	/*
		117	* The original Linux 2.4 AGP GART driver interface declared copy_info to
		118	* return nothing. This changed in Linux 2.5, which reports unsupported
		119	* chipsets via this function. If this Linux 2.4 kernels behaves the same
		120	* way, we have no way to know.
		121	*/
		122	drm_agp_p->copy_info(&agpinfo);
		123	#else
		124	if (drm_agp_p->copy_info(&agpinfo)) {
		125	drm_agp_p->release();
		126	inter_module_put("drm_agp");
		127	return -1;
		128	}
		129	#endif
181		130
182	#ifdef CONFIG_MTRR	131	#ifdef CONFIG_MTRR
183	if ((gart.mtrr = mtrr_add(agpinfo.aper_base,	132	if ((gart.mtrr = mtrr_add(agpinfo.aper_base,
Lines 191-197 Link Here
191	*/	140	*/
192	nv_printf(NV_DBG_ERRORS,	141	nv_printf(NV_DBG_ERRORS,
193	"NVRM: AGPGART: unable to set MTRR write-combining\n");	142	"NVRM: AGPGART: unable to set MTRR write-combining\n");
194	(*(agp_ops.backend_release))();	143	drm_agp_p->release();
		144	inter_module_put("drm_agp");
195	return -1;	145	return -1;
196	}	146	}
197	#endif	147	#endif
Lines 207-213 Link Here
207	{	157	{
208	nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: unable to remap aperture\n");	158	nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: unable to remap aperture\n");
209	MTRR_DEL(gart);	159	MTRR_DEL(gart);
210	(*(agp_ops.backend_release))();	160	drm_agp_p->release();
		161	inter_module_put("drm_agp");
211	return -1;	162	return -1;
212	}	163	}
213		164
Lines 218-224 Link Here
218	nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: unable to allocate bitmap\n");	169	nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: unable to allocate bitmap\n");
219	NV_IOUNMAP(gart.aperture, RM_PAGE_SIZE);	170	NV_IOUNMAP(gart.aperture, RM_PAGE_SIZE);
220	MTRR_DEL(gart);	171	MTRR_DEL(gart);
221	(*(agp_ops.backend_release))();	172	drm_agp_p->release();
		173	inter_module_put("drm_agp");
222	return -1;	174	return -1;
223	}	175	}
224		176
Lines 229-267 Link Here
229	os_free_mem(bitmap);	181	os_free_mem(bitmap);
230	NV_IOUNMAP(gart.aperture, RM_PAGE_SIZE);	182	NV_IOUNMAP(gart.aperture, RM_PAGE_SIZE);
231	MTRR_DEL(gart);	183	MTRR_DEL(gart);
232	(*(agp_ops.backend_release))();	184	drm_agp_p->release();
		185	inter_module_put("drm_agp");
233	return -1;	186	return -1;
234	}	187	}
235		188
236	nv_printf(NV_DBG_SETUP,
237	"NVRM: AGPGART: aperture: %ldM @ 0x%08lx\n",
238	(unsigned long)agpinfo.aper_size,
239	(unsigned long)agpinfo.aper_base);
240
241	nv_printf(NV_DBG_SETUP,
242	"NVRM: AGPGART: aperture mapped from 0x%08lx to 0x%08lx\n",
243	agpinfo.aper_base,
244	(unsigned long) gart.aperture);
245
246	if (!agp_sba) agpinfo.mode &= ~0x00000200;	189	if (!agp_sba) agpinfo.mode &= ~0x00000200;
247	if (!agp_fw) agpinfo.mode &= ~0x00000010;	190	if (!agp_fw) agpinfo.mode &= ~0x00000010;
248		191
249	if (!(agp_rate & 0x00000004)) agpinfo.mode &= ~0x00000004;	192	if (!(agp_rate & 0x00000004)) agpinfo.mode &= ~0x00000004;
250	if (!(agp_rate & 0x00000002)) agpinfo.mode &= ~0x00000002;	193	if (!(agp_rate & 0x00000002)) agpinfo.mode &= ~0x00000002;
251		194
252	(*(agp_ops.enable))(agpinfo.mode);	195	drm_agp_p->enable(agpinfo.mode);
253		196
254	if (agpinfo.mode & 0x00000200)
255	nv_printf(NV_DBG_SETUP, "NVRM: AGPGART: backend supports sba\n");
256	if (agpinfo.mode & 0x00000010)
257	nv_printf(NV_DBG_SETUP, "NVRM: AGPGART: backend supports fw\n");
258	if (agpinfo.mode & 0x00000004)
259	nv_printf(NV_DBG_SETUP, "NVRM: AGPGART: mode 4x\n");
260	else if (agpinfo.mode & 0x00000002)
261	nv_printf(NV_DBG_SETUP, "NVRM: AGPGART: mode 2x\n");
262	else if (agpinfo.mode & 0x00000001)
263	nv_printf(NV_DBG_SETUP, "NVRM: AGPGART: mode 1x\n");
264
265	ap_phys_base = (void) agpinfo.aper_base;	197	ap_phys_base = (void) agpinfo.aper_base;
266	ap_mapped_base = (void) gart.aperture;	198	ap_mapped_base = (void) gart.aperture;
267	apsize = (agpinfo.aper_size 0x100000) - 1;	199	apsize = (agpinfo.aper_size 0x100000) - 1;
Lines 295-305 Link Here
295	NV_IOUNMAP(gart.aperture, RM_PAGE_SIZE);	227	NV_IOUNMAP(gart.aperture, RM_PAGE_SIZE);
296	}	228	}
297		229
298	(*(agp_ops.backend_release))();	230	drm_agp_p->release();
299		231
300	#if !defined (KERNEL_2_2)	232	/*
		233	* XXX Same as above; the inter_module_* mechanism will go away at some
		234	* point, it has been deprecated in Linux 2.5.
		235	*/
301	inter_module_put("drm_agp");	236	inter_module_put("drm_agp");
302	#endif
303		237
304	if (rm_clear_agp_bitmap(nv, &bitmap))	238	if (rm_clear_agp_bitmap(nv, &bitmap))
305	{	239	{
Lines 346-352 Link Here
346	return RM_ERROR;	280	return RM_ERROR;
347	}	281	}
348		282
349	ptr = (*agp_ops.allocate_memory)(PageCount, AGP_NORMAL_MEMORY);	283	ptr = drm_agp_p->allocate_memory(PageCount, AGP_NORMAL_MEMORY);
350	if (ptr == NULL)	284	if (ptr == NULL)
351	{	285	{
352	pAddress = (void) 0;	286	pAddress = (void) 0;
Lines 354-360 Link Here
354	return RM_ERR_NO_FREE_MEM;	288	return RM_ERR_NO_FREE_MEM;
355	}	289	}
356		290
357	err = ((agp_ops.bind_memory))(ptr, Offset);	291	err = drm_agp_p->bind_memory(ptr, *Offset);
358	if (err)	292	if (err)
359	{	293	{
360	// this happens a lot when the aperture itself fills up..	294	// this happens a lot when the aperture itself fills up..
Lines 371-377 Link Here
371	if (status != RM_OK)	305	if (status != RM_OK)
372	{	306	{
373	nv_printf(NV_DBG_ERRORS, "NVRM: memory allocation failed\n");	307	nv_printf(NV_DBG_ERRORS, "NVRM: memory allocation failed\n");
374	(*(agp_ops.unbind_memory))(ptr);	308	drm_agp_p->unbind_memory(ptr);
375	goto fail;	309	goto fail;
376	}	310	}
377		311
Lines 386-392 Link Here
386	return RM_OK;	320	return RM_OK;
387		321
388	fail:	322	fail:
389	(*(agp_ops.free_memory))(ptr);	323	drm_agp_p->free_memory(ptr);
390	pAddress = (void) 0;	324	pAddress = (void) 0;
391		325
392	return RM_ERROR;	326	return RM_ERROR;
Lines 426-432 Link Here
426	{	360	{
427	nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: unable to remap %lu pages\n",	361	nv_printf(NV_DBG_ERRORS, "NVRM: AGPGART: unable to remap %lu pages\n",
428	(unsigned long)agp_data->num_pages);	362	(unsigned long)agp_data->num_pages);
429	(*(agp_ops.unbind_memory))(agp_data->ptr);	363	drm_agp_p->unbind_memory(agp_data->ptr);
430	goto fail;	364	goto fail;
431	}	365	}
432		366
Lines 445-452 Link Here
445	}	379	}
446	#endif	380	#endif
447		381
448	#if !defined(KERNEL_2_2)
449
450	RM_STATUS	382	RM_STATUS
451	KernMapAGPNopage(	383	KernMapAGPNopage(
452	VOID *address,	384	VOID *address,
Lines 501-509 Link Here
501	#endif	433	#endif
502	}	434	}
503		435
504	#endif /* !defined(KERNEL_2_2) */
505
506
507	RM_STATUS KernFreeAGPPages(	436	RM_STATUS KernFreeAGPPages(
508	nv_state_t *nv,	437	nv_state_t *nv,
509	VOID **pAddress,	438	VOID **pAddress,
Lines 529-536 Link Here
529	{	458	{
530	size_t pages = ptr->page_count;	459	size_t pages = ptr->page_count;
531		460
532	(*(agp_ops.unbind_memory))(ptr);	461	drm_agp_p->unbind_memory(ptr);
533	(*(agp_ops.free_memory))(ptr);	462	drm_agp_p->free_memory(ptr);
534		463
535	nv_printf(NV_DBG_INFO, "NVRM: AGPGART: freed %ld pages\n",	464	nv_printf(NV_DBG_INFO, "NVRM: AGPGART: freed %ld pages\n",
536	(unsigned long)pages);	465	(unsigned long)pages);

Lines 48-71 Link Here

(-)NVIDIA_kernel-1.0-5328/os-registry.c (-29 / +11 lines)
48	* This could be changed to work on a per-device basis.	48	* This could be changed to work on a per-device basis.
49	*/	49	*/
50		50
51	/*
52	* The 2nd argument to MODULE_PARM is used to verify parameters passed
53	* to the module at load time. It should be a string in the following
54	* format:
55	*
56	* [min[-max]]{b,h,i,l,s}
57	*
58	* The MIN and MAX specifiers delimit the length of the array. If MAX
59	* is omitted, it defaults to MIN; if both are omitted, the default is
60	* 1. The final character is a type specifier.
61	*
62	* b byte
63	* h short
64	* i int
65	* l long
66	* s string
67	*/
68
69	/*	51	/*
70	* Option: VideoMemoryTypeOverride	52	* Option: VideoMemoryTypeOverride
71	*	53	*
Lines 92-98 Link Here
92	*/	74	*/
93		75
94	static int NVreg_VideoMemoryTypeOverride = 1;	76	static int NVreg_VideoMemoryTypeOverride = 1;
95	MODULE_PARM(NVreg_VideoMemoryTypeOverride, "i");	77	NV_MODULE_PARAMETER(NVreg_VideoMemoryTypeOverride);
96		78
97	/*	79	/*
98	* Option: EnableVia4x	80	* Option: EnableVia4x
Lines 111-117 Link Here
111	*/	93	*/
112		94
113	static int NVreg_EnableVia4x = 0;	95	static int NVreg_EnableVia4x = 0;
114	MODULE_PARM(NVreg_EnableVia4x, "i");	96	NV_MODULE_PARAMETER(NVreg_EnableVia4x);
115		97
116	/*	98	/*
117	* Option: EnableALiAGP	99	* Option: EnableALiAGP
Lines 134-140 Link Here
134	*/	116	*/
135		117
136	static int NVreg_EnableALiAGP = 0;	118	static int NVreg_EnableALiAGP = 0;
137	MODULE_PARM(NVreg_EnableALiAGP, "i");	119	NV_MODULE_PARAMETER(NVreg_EnableALiAGP);
138		120
139	/*	121	/*
140	* Option: ReqAGPRate	122	* Option: ReqAGPRate
Lines 164-170 Link Here
164	*/	146	*/
165		147
166	static int NVreg_ReqAGPRate = 7;	148	static int NVreg_ReqAGPRate = 7;
167	MODULE_PARM(NVreg_ReqAGPRate, "i");	149	NV_MODULE_PARAMETER(NVreg_ReqAGPRate);
168		150
169	/*	151	/*
170	* Option: UpdateKernelAGP	152	* Option: UpdateKernelAGP
Lines 193-199 Link Here
193	*/	175	*/
194		176
195	static int NVreg_UpdateKernelAGP = 1;	177	static int NVreg_UpdateKernelAGP = 1;
196	MODULE_PARM(NVreg_UpdateKernelAGP, "i");	178	NV_MODULE_PARAMETER(NVreg_UpdateKernelAGP);
197		179
198	/*	180	/*
199	* Option: EnableAGPSBA	181	* Option: EnableAGPSBA
Lines 226-232 Link Here
226	static int NVreg_EnableAGPSBA = 0;	208	static int NVreg_EnableAGPSBA = 0;
227	#endif	209	#endif
228		210
229	MODULE_PARM(NVreg_EnableAGPSBA, "i");	211	NV_MODULE_PARAMETER(NVreg_EnableAGPSBA);
230		212
231	/*	213	/*
232	* Option: EnableAGPFW	214	* Option: EnableAGPFW
Lines 250-256 Link Here
250	*/	232	*/
251		233
252	static int NVreg_EnableAGPFW = 0;	234	static int NVreg_EnableAGPFW = 0;
253	MODULE_PARM(NVreg_EnableAGPFW, "i");	235	NV_MODULE_PARAMETER(NVreg_EnableAGPFW);
254		236
255	/*	237	/*
256	* Option: SoftEDIDs	238	* Option: SoftEDIDs
Lines 269-275 Link Here
269	*/	251	*/
270		252
271	static int NVreg_SoftEDIDs = 1;	253	static int NVreg_SoftEDIDs = 1;
272	MODULE_PARM(NVreg_SoftEDIDs, "i");	254	NV_MODULE_PARAMETER(NVreg_SoftEDIDs);
273		255
274	/*	256	/*
275	* Option: Mobile	257	* Option: Mobile
Lines 293-306 Link Here
293	*/	275	*/
294		276
295	static int NVreg_Mobile = ~0;	277	static int NVreg_Mobile = ~0;
296	MODULE_PARM(NVreg_Mobile, "i");	278	NV_MODULE_PARAMETER(NVreg_Mobile);
297		279
298		280
299	static int NVreg_ResmanDebugLevel = ~0;	281	static int NVreg_ResmanDebugLevel = ~0;
300	MODULE_PARM(NVreg_ResmanDebugLevel, "i");	282	NV_MODULE_PARAMETER(NVreg_ResmanDebugLevel);
301		283
302	static int NVreg_FlatPanelMode = 0;	284	static int NVreg_FlatPanelMode = 0;
303	MODULE_PARM(NVreg_FlatPanelMode, "i");	285	NV_MODULE_PARAMETER(NVreg_FlatPanelMode);
304		286
305	/*	287	/*
306	* You can enable any of the registry options disabled by default by	288	* You can enable any of the registry options disabled by default by