X-Git-Url: http://git.tremily.us/?a=blobdiff_plain;f=m4%2Fas-linux.m4;h=93107ea92627858d5d986ed08aa9f04e57fc9f5d;hb=f3c325aed08b4bca544fb7080216948c5ec87eaf;hp=854260629a86e699f1b3103e2f721d1a78d8da50;hpb=089a4b19d9c4c7f8b7c2ce1cc8d4210c4399c143;p=comedi.git diff --git a/m4/as-linux.m4 b/m4/as-linux.m4 index 85426062..93107ea9 100644 --- a/m4/as-linux.m4 +++ b/m4/as-linux.m4 @@ -1,17 +1,32 @@ -dnl as-linux.m4 0.0.1 +dnl as-linux.m4 0.2.0 + dnl autostars m4 macro for detecting a Linux source tree (or dnl equivalent) for compiling modules. -dnl + dnl David Schleef dnl Frank Mori Hess -dnl thomas@apestaart.org -dnl +dnl Thomas Vander Stichele + +dnl $Id$ + dnl AS_LINUX() dnl -dnl this macro adds the options --with-linuxdir and --with-linux-config. +dnl this macro adds the options +dnl --with-linuxdir to specify a kernel build tree location +dnl --with-linuxsrcdir to specify a kernel source tree location +dnl --with-linuxconfig to specify a kernel .config file +dnl --with-kernel-release to specify an alternative uname -r +dnl --with-machine to specify an alternative uname -m +dnl --with-rpm-target to specify to match the given rpm --target option +dnl --with-extraversion to specify an EXTRAVERSION override +dnl --with-modulesdir to specify the base install location of modules +dnl --with-modulesdeveldir to specify the base install location of build stuff + dnl this macro defines: dnl LINUX_DIR -dnl The directory where the Linux source resides. +dnl The directory where the Linux build tree resides. +dnl LINUX_SRC_DIR +dnl The directory where the Linux source tree resides. dnl CONFIG_FILE dnl The Linux config file dnl LINUX_ARCH @@ -36,30 +51,84 @@ dnl LINUX_LD dnl Path to linker (possibly with options) used by Linux. dnl LINUX_AS dnl Assembler used by Linux. +dnl LINUX_MODULE_STYLE +dnl Style of module building (2.4.0, 2.6.0, 2.6.6) dnl LINUX_MODULE_EXT dnl Module extension (.o or .ko) +dnl LINUX_MODPOST +dnl path to modpost script +dnl MODULESDIR +dnl base install path for kernel modules +dnl MODULESDEVELDIR +dnl base install path for kernel module development files dnl -dnl dnl End of search list. +dnl main entry point +dnl checks the version, and figures out all flags to use to make modules. +AC_DEFUN([AS_LINUX], +[ + dnl check if user supplied a uname -r, and if not use the running one + AS_LINUX_KERNEL_RELEASE() + dnl check if user supplied a uname -m, and if not use the running one + AS_LINUX_MACHINE() + dnl check if the user supplied an rpm target arch + dnl override the LINUX_MACHINE value if he did + AS_LINUX_RPM_TARGET() + + dnl find the kernel build tree for the given uname -r + AS_LINUX_DIR() + dnl override kernel release uname -r value with info from build tree + AS_LINUX_OVERRIDE_KERNEL_RELEASE($LINUX_DIR) + dnl find the kernel source tree from the build tree or --with-linuxsrcdir + AS_LINUX_SRC_DIR($LINUX_DIR) + dnl check if user supplied an EXTRAVERSION, and if not get from uname -r + AS_LINUX_EXTRAVERSION($LINUX_KERNEL_RELEASE) + dnl check if user supplied a config file; if not, guess a good one + AS_LINUX_CONFIG($LINUX_DIR, $LINUX_KERNEL_RELEASE, $LINUX_MACHINE) + dnl check if we're building on pre-FC2 Red Hat/Fedora, + dnl and add some flags if we are + AS_CHECK_REDHAT_PRE_FC2() + dnl check for where to install modules + AS_LINUX_MODULESDIR($LINUX_KERNEL_RELEASE) + dnl check for where to install module development files + AS_LINUX_MODULESDEVELDIR($LINUX_DIR) + dnl check for the MAJOR/MINOR version of Linux + AS_LINUX_VERSION_MAJOR_MINOR($LINUX_DIR) + + dnl now call the correct macro to get compiler flags + dnl the versioned AS_LINUX macros just use the global variables + dnl this could be cleaned up later on if we feel like it + case $LINUX_VERSION_MAJOR.$LINUX_VERSION_MINOR in + 2.6 | 3.[[0-9]]*) + AS_LINUX_2_6() + ;; + 2.[[01234]]) + AS_LINUX_2_4() + ;; + *) + AC_MSG_ERROR([Unknown Linux major.minor $LINUX_VERSION_MAJOR.$LINUX_VERSION_MINOR]) + ;; + esac +]) -dnl check if we can find a source dir for the Linux kernel -dnl defines LINUX_DIR to the absolute location of a usable kernel source tree +dnl check if we can find a build dir for the Linux kernel +dnl defines LINUX_DIR to the absolute location of a usable kernel build tree AC_DEFUN([AS_LINUX_DIR], [ AC_ARG_WITH([linuxdir], [AC_HELP_STRING([--with-linuxdir=DIR], - [specify path to Linux source directory])], + [specify path to Linux build directory])], [LINUX_DIR="${withval}"], [LINUX_DIR=default]) if test "${LINUX_DIR}" != "default" ; then - AS_TRY_LINUX_DIR([${LINUX_DIR}], , AC_MSG_ERROR([Linux dir not found]) ) + AS_TRY_LINUX_DIR([${LINUX_DIR}], , AC_MSG_ERROR([Linux build dir not found]) ) fi if test "${LINUX_DIR}" = "default" ; then - dir="/lib/modules/`uname -r`/build"; + dir="/lib/modules/$LINUX_KERNEL_RELEASE/build"; AS_TRY_LINUX_DIR([${dir}], [LINUX_DIR=${dir}], ) fi if test "${LINUX_DIR}" = "default" ; then @@ -72,15 +141,71 @@ AC_DEFUN([AS_LINUX_DIR], fi if test "${LINUX_DIR}" = "default" ; then - AC_MSG_ERROR([Linux source directory not found]) + AC_MSG_ERROR([Linux build directory not found]) fi AC_SUBST(LINUX_DIR) ]) -dnl check if the given candidate path for a linux source tree is usable +dnl check if the given candidate path for a linux build tree is usable AC_DEFUN([AS_TRY_LINUX_DIR], - [AC_MSG_CHECKING(for Linux in $1) + [AC_MSG_CHECKING(for Linux build in $1) + + if test -f "$1/Makefile" ; then + result=yes + $2 + else + result="not found" + $3 + fi + + AC_MSG_RESULT($result) +]) + +dnl get the kernel source directory +dnl $1 is the kernel build directory +dnl defines LINUX_SRC_DIR to the absolute location of kernel source tree +AC_DEFUN([AS_LINUX_SRC_DIR], +[ + AC_ARG_WITH([linuxsrcdir], + [AC_HELP_STRING([--with-linuxsrcdir=DIR], + [specify path to Linux source directory])], + [LINUX_SRC_DIR="${withval}"], + [LINUX_SRC_DIR=default]) + + if test "${LINUX_SRC_DIR}" != "default" ; then + AS_TRY_LINUX_SRC_DIR([${LINUX_SRC_DIR}], , AC_MSG_ERROR([Linux source dir not found]) ) + fi + + if test "${LINUX_SRC_DIR}" = "default" ; then + AC_MSG_CHECKING(for separate Linux source and build directory) + dir=`sed -n -e 's/^KERNELSRC *:= *\(.*\)/\1/p' "$1/Makefile"` + if test -z "$dir"; then + # 2.6.25 + dir=`sed -n -e 's/^MAKEARGS *:= *-C *\([[^[:space:]]]*\).*/\1/p' "$1/Makefile"` + fi + if test -z "$dir"; then + AC_MSG_RESULT([no]) + LINUX_SRC_DIR="$1" + else + AC_MSG_RESULT([yes]) + case "$dir" in + .*) dir="$1/$dir" ;; + esac + AS_TRY_LINUX_SRC_DIR([${dir}], [LINUX_SRC_DIR=${dir}], ) + fi + fi + + if test "${LINUX_SRC_DIR}" = "default" ; then + AC_MSG_ERROR([Linux source directory not found]) + fi + + AC_SUBST(LINUX_SRC_DIR) +]) + +dnl check if the given candidate path for a linux source tree is usable +AC_DEFUN([AS_TRY_LINUX_SRC_DIR], + [AC_MSG_CHECKING(for Linux source in $1) if test -f "$1/Makefile" ; then result=yes @@ -93,76 +218,223 @@ AC_DEFUN([AS_TRY_LINUX_DIR], AC_MSG_RESULT($result) ]) +dnl allow for specifying a kernel release (uname -r) to build for +dnl use uname -r of running one if not specified +dnl store result in LINUX_KERNEL_RELEASE +AC_DEFUN([AS_LINUX_KERNEL_RELEASE], +[ + AC_ARG_WITH([kernel-release], + [AC_HELP_STRING([--with-kernel-release=RELEASE], + [specify the "uname -r"-value to build for])], + [LINUX_KERNEL_RELEASE="${withval}"], + [LINUX_KERNEL_RELEASE=`uname -r`]) + if test "x$LINUX_KERNEL_RELEASE" = "xyes"; + then + LINUX_KERNEL_RELEASE=`uname -r` + fi + AC_MSG_NOTICE([Using $LINUX_KERNEL_RELEASE as the uname -r value]) +]) + +dnl replaces LINUX_KERNEL_RELEASE once the Linux build directory is known +dnl first argument is the Linux build directory +AC_DEFUN([AS_LINUX_OVERRIDE_KERNEL_RELEASE], +[ + INCDIR="$1/include" + UTSINC="${INCDIR}/linux/utsrelease.h" + if ! test -f "${UTSINC}"; then + UTSINC="${INCDIR}/linux/version.h" + fi + if test -f "${UTSINC}"; then + RELEASE=`echo UTS_RELEASE | cat "${UTSINC}" - | + /lib/cpp -I "${INCDIR}" | tail -n 1 | + sed 's/^"\(.*\)"$/\1/'` + if test "${RELEASE}" != "UTS_RELEASE" -a "${RELEASE}" != "" \ + -a "${RELEASE}" != "${LINUX_KERNEL_RELEASE}"; then + AC_MSG_NOTICE([Overriding uname -r value with ${RELEASE}]) + LINUX_KERNEL_RELEASE="${RELEASE}" + fi + + fi +]) + +dnl allow for specifying a machine (uname -m) to build for +dnl use uname -m, of running one if not specified +dnl store result in LINUX_MACHINE +AC_DEFUN([AS_LINUX_MACHINE], +[ + AC_ARG_WITH([machine], + [AC_HELP_STRING([--with-machine=MACHINE], + [specify the "uname -m"-value to build for])], + [LINUX_MACHINE="${withval}"], + [LINUX_MACHINE=`uname -m`]) + if test "x$LINUX_MACHINE" = "xyes"; + then + LINUX_MACHINE=`uname -m` + fi + AC_MSG_NOTICE([Using $LINUX_MACHINE as the uname -m value]) +]) +dnl allow for specifying an rpm target arch +dnl if none specified, try to guess one from running rpm querying for +dnl the kernel with the uname -r +dnl this is so configure without arguments works out of the box +dnl FIXME: investigate if uname -p is a correct guess for this, and if +dnl we should have a flag for specifying it instead + +dnl this macro possibly overrides LINUX_MACHINE + +dnl first argument is the kernel release building for +AC_DEFUN([AS_LINUX_RPM_TARGET], +[ + RELEASE=$LINUX_KERNEL_RELEASE + AC_ARG_WITH([rpm-target], + [AC_HELP_STRING([--with-rpm-target=TARGET], + [specify the target arch to build for])], + [LINUX_RPM_TARGET="${withval}"], + [LINUX_RPM_TARGET=]) + if test "x$LINUX_RPM_TARGET" = "x" + then + dnl if we have rpm, try to guess the target of the kernel + dnl we want to build for using rpm + AC_PATH_PROG([RPM], [rpm], [no]) + if test "x$RPM" != "xno" ; then + if $RPM -q kernel-$RELEASE > /dev/null + then + LINUX_RPM_TARGET=`$RPM -q --queryformat %{arch} kernel-$RELEASE` + else + AC_MSG_NOTICE([Cannot guess target arch, consider setting it using --with-rpm-target]) + fi + fi + fi + + dnl now override LINUX_MACHINE if LINUX_RPM_TARGET is set + if test "x$LINUX_RPM_TARGET" != "x" + then + dnl override LINUX_MACHINE based on this + dnl FIXME: add other possible Red Hat/Fedora/rpm targets here + LINUX_MACHINE= + case "$LINUX_RPM_TARGET" in + i?86) LINUX_MACHINE=i386;; + athlon) LINUX_MACHINE=i386;; + x86_64) LINUX_MACHINE=x86_64;; + esac + if test "x$LINUX_MACHINE" = "x" + then + AC_MSG_ERROR(Could not guess uname -m value from target $LINUX_RPM_TARGET) + fi + fi +]) + + +dnl allow for specifying an override for EXTRAVERSION +dnl if none specified, make it from the passed-in KERNEL_RELEASE (uname -r) +dnl resulting value is stored in LINUX_EXTRAVERSION +dnl first argument is the uname -r string to use as a fallback +AC_DEFUN([AS_LINUX_EXTRAVERSION], +[ + KERNEL_RELEASE=[$1] + dnl extract the default by getting everything after first - + LINUX_EXTRAVERSION="-`echo $KERNEL_RELEASE | cut -d- -f 2-`" + AC_ARG_WITH([extraversion], + [AC_HELP_STRING([--with-extraversion=FILE], + [specify override for kernel EXTRAVERSION])], + [LINUX_EXTRAVERSION="${withval}"],) +]) + + dnl check if we can find a config file for the Linux kernel -dnl defines CONFIG_FILE to the absolute location of a usable kernel source tree -dnl uses LINUX_DIR to find either .config or decent configs in configs/ -AC_DEFUN([AS_CONFIG_FILE], +dnl defines LINUX_CONFIG to the absolute location of a usable +dnl kernel source config file + +dnl for rpm distros, it can try and guess the correct config file by +dnl checking the global LINUX_RPM_TARGET variable set somewhere else +dnl (FIXME: move this to an argument instead ?) + +dnl first argument is LINUX_DIR to check for possible configs +dnl second argument is kernel-release (uname -r) +dnl third argument is machine (uname -m) + +AC_DEFUN([AS_LINUX_CONFIG], [ - AC_ARG_WITH([linux-config], - [AC_HELP_STRING([--with-linux-config=FILE], + LINUX_DIR=[$1] + KERNEL_RELEASE=[$2] + MACHINE=[$3] + AC_ARG_WITH([linuxconfig], + [AC_HELP_STRING([--with-linuxconfig=FILE], [specify path to Linux configuration file])], - [CONFIG_FILE="${withval}"], - [CONFIG_FILE=default]) + [LINUX_CONFIG="${withval}"], + [LINUX_CONFIG=default]) - if test "${CONFIG_FILE}" != "default" ; then - AS_TRY_CONFIG_FILE([${CONFIG_FILE}], , AC_MSG_ERROR([Linux config not found]) ) + dnl if a file got specified, try it as a linux config file + if test "${LINUX_CONFIG}" != "default" ; then + AS_TRY_LINUX_CONFIG($LINUX_CONFIG, $MACHINE, + ,, AC_MSG_ERROR([Linux config not found]) ) fi - dnl if default specified, first check for the regular .config file + dnl if no file specified, first check for the regular .config file dnl in LINUX_DIR created by manual configuration - if test "${CONFIG_FILE}" = "default" ; then + if test "${LINUX_CONFIG}" = "default" ; then file="$LINUX_DIR/.config"; - AS_TRY_CONFIG_FILE([${file}], [CONFIG_FILE=${file}], ) + AS_TRY_LINUX_CONFIG($file, $MACHINE, + [LINUX_CONFIG=${file}], ) fi dnl second, try to guess what config file to use for the current kernel - if test "${CONFIG_FILE}" = "default" ; then + dnl FIXME: the possible arch is from rpmbuild --target, and is + dnl different from the value of ARCH (Makefile) or MACHINE (uname -m) + dnl so we should have a redhat flag to specify the target to find + dnl the correct config file + if test "${LINUX_CONFIG}" = "default" && test "x$LINUX_RPM_TARGET" != "x"; then dnl Red Hat stores configuration files for their built kernels dnl named kernel-(version)-(arch)(extra).config dnl where arch is athlon, i386, i586, i686, x86_64 dnl and (extra) is empty or -smp, -BOOT, -bigmem dnl haven't seen combinations of extra yet as of FC1 - version=`uname -r | cut -d- -f1` - machine=`uname -m` + KVERSION=`echo $KERNEL_RELEASE | cut -d- -f1` extra= - uname -r | grep smp && extra="-smp" - uname -r | grep bigmem && extra="-bigmem" - uname -r | grep BOOT && extra="-BOOT" - file="$LINUX_DIR/configs/kernel-$version-$machine$extra.config" - AS_TRY_CONFIG_FILE([${file}], [CONFIG_FILE=${file}], ) + echo $KERNEL_RELEASE | grep smp && EXTRA="-smp" + echo $KERNEL_RELEASE | grep bigmem && EXTRA="-bigmem" + echo $KERNEL_RELEASE | grep BOOT && EXTRA="-BOOT" + file="$LINUX_DIR/configs/kernel-$KVERSION-$LINUX_RPM_TARGET$EXTRA.config" + AS_TRY_LINUX_CONFIG($file, $MACHINE, + [LINUX_CONFIG=${file}], ) fi - if test "${CONFIG_FILE}" = "default" ; then + if test "${LINUX_CONFIG}" = "default" ; then AC_MSG_ERROR([ The kernel source tree at ${LINUX_DIR} is not configured, and no configuration files in config/ matching your kernel were found. -Fix before continuing or specify a config file using --with-linux-config.]) +Fix before continuing or specify a config file using --with-configfile.]) fi - AC_SUBST(CONFIG_FILE) + AC_SUBST(LINUX_CONFIG) ]) dnl check if the given candidate config file is usable -AC_DEFUN([AS_TRY_CONFIG_FILE], - [AC_MSG_CHECKING(for configuration in $1) +dnl FIXME: it would be nice if it could check if it matches the +dnl given machine (uname -m) +AC_DEFUN([AS_TRY_LINUX_CONFIG], +[ + CFG=[$1] + MACHINE=[$2] + AC_MSG_CHECKING($CFG) - if test -f "$1" ; then + if test -f "$CFG" ; then result=yes - $2 + ifelse([$3], , :, [$3]) else result="not found" - $3 + ifelse([$4], , :, [$4]) fi - AC_MSG_RESULT($result) ]) dnl check if RED_HAT_LINUX_KERNEL is defined -dnl RH/Fedora defines this in linux/rhconfig.h, included from linux/version.h +dnl pre-FC2 RH/Fedora defines this in linux/rhconfig.h +dnl included from linux/version.h dnl if this is present, a few extra defines need to be present to make sure dnl symbol versioning is correct dnl uses LINUX_DIR to find rhconfig.h -AC_DEFUN([AS_CHECK_REDHAT], +AC_DEFUN([AS_CHECK_REDHAT_PRE_FC2], [ - AC_MSG_CHECKING(Red Hat/Fedora kernel) + AC_MSG_CHECKING(Pre-FC2 Red Hat/Fedora kernel) HAVE_REDHAT_KERNEL=false ac_save_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -I${LINUX_DIR}/include/linux" @@ -184,8 +456,8 @@ int code = RED_HAT_LINUX_KERNEL; BIGMEM='0' HUGEMEM='0' - dnl get variables from the currently running kernel as default - KERNEL_TYPE=`uname -r | sed 's_^.*\(smp\|enterprise\|bigmem\|hugemem\)$_-\1_;t;s_.*__;'` + dnl get variables from the currently running kernel as default + KERNEL_TYPE=`uname -r | sed 's_^.*\(smp\|enterprise\|bigmem\|hugemem\)$_\1_;t;s_.*__;'` KERNEL_RELEASE=`uname -r | sed 's|smp\|enterprise\|bigmem\|hugemem||g'` KERNEL_ARCH=`uname -m` @@ -198,18 +470,18 @@ int code = RED_HAT_LINUX_KERNEL; AS_CHECK_LINUX_CONFIG_OPTION(CONFIG_MK7, KERNEL_ARCH=athlon) dnl check the config file and override KERNEL_TYPE - AS_CHECK_LINUX_CONFIG_OPTION(CONFIG_SMP, KERNEL_TYPE=-smp) + AS_CHECK_LINUX_CONFIG_OPTION(CONFIG_SMP, KERNEL_TYPE=smp) dnl bigmem is also smp, so this check is done after smp to override - AS_CHECK_LINUX_CONFIG_OPTION(CONFIG_HIGHMEM64G, KERNEL_TYPE=-bigmem) + AS_CHECK_LINUX_CONFIG_OPTION(CONFIG_HIGHMEM64G, KERNEL_TYPE=bigmem) dnl FIXME: need to check hugemem and enterprise config files, which dnl aren't provided in Fedora Core 1 ! case "$KERNEL_TYPE" in - -smp) SMP='1';; - -enterprise) ENTERPRISE='1';; - -bigmem) BIGMEM='1';; - -hugemem) HUGEMEM='1';; + smp) SMP='1';; + enterprise) ENTERPRISE='1';; + bigmem) BIGMEM='1';; + hugemem) HUGEMEM='1';; *) UP='1';; esac REDHAT_CFLAGS="-D__MODULE_KERNEL_$KERNEL_ARCH=1" @@ -218,68 +490,48 @@ int code = RED_HAT_LINUX_KERNEL; REDHAT_CFLAGS="$REDHAT_CFLAGS -D__BOOT_KERNEL_SMP=$SMP" REDHAT_CFLAGS="$REDHAT_CFLAGS -D__BOOT_KERNEL_BIGMEM=$BIGMEM" REDHAT_CFLAGS="$REDHAT_CFLAGS -D__BOOT_KERNEL_HUGEMEM=$HUGEMEM" -]) -dnl main entry point -dnl checks the version, and figures out all flags to use to make modules. -AC_DEFUN([AS_LINUX], -[ - AS_LINUX_DIR() - AS_CONFIG_FILE() - AS_CHECK_REDHAT() + LINUX_REDHAT_CFLAGS="$REDHAT_CFLAGS" - AC_MSG_CHECKING([Linux major/minor version]) + AC_SUBST(LINUX_KERNEL_TYPE, "$KERNEL_TYPE") +]) - if [[ ! -f "${LINUX_DIR}/include/linux/version.h" ]];then - AC_MSG_ERROR([The header file include/linux/version.h does not exist. -For 2.6 kernels, it can be generated by running 'make prepare' in -the kernel source directory.]) +dnl add an argument to specify/override the module install path +dnl if nothing specified, it will be /lib/modules/(kernelrel) +AC_DEFUN([AS_LINUX_MODULESDIR], +[ + KERNEL_RELEASE=[$1] + AC_ARG_WITH([modulesdir], + [AC_HELP_STRING([--with-modulesdir=DIR], + [specify path to kernel-specific modules install directory])], + [MODULESDIR="${withval}"], + [MODULESDIR=default]) + + if test "${MODULESDIR}" = "default" ; then + MODULESDIR="/lib/modules/${KERNEL_RELEASE}" fi - dnl the next set of tests is for figuring out version major/minor - dnl we make sure we have the right version.h by faking out CFLAGS - ac_save_CFLAGS="$CFLAGS" - CFLAGS="$CFLAGS -I${LINUX_DIR}/include/linux" - dnl make sure we find version.h and it contains LINUX_VERSION_CODE - AC_COMPILE_IFELSE(AC_LANG_PROGRAM([ -#include "version.h" -int code = LINUX_VERSION_CODE; -]), - :, AC_MSG_ERROR([${LINUX_DIR}/include/linux/version.h does not contain LINUX_VERSION_CODE])) - - - dnl figure out the linux kernel version major and minor - dnl using the LINUX_VERSION_CODE defined in include/linux/version.h - AC_RUN_IFELSE(AC_LANG_PROGRAM([ -#include "version.h" -#define KERNEL_VERSION_MAJOR(code) ((code) >> 16) -],[ - return KERNEL_VERSION_MAJOR(LINUX_VERSION_CODE); -]), - LINUX_VERSION_MAJOR=0, - LINUX_VERSION_MAJOR=$?) - AC_RUN_IFELSE(AC_LANG_PROGRAM([ -#include "version.h" -#define KERNEL_VERSION_MINOR(code) (((code) >> 8) & 0xff) -],[ - return KERNEL_VERSION_MINOR(LINUX_VERSION_CODE); -]), - LINUX_VERSION_MINOR=0, - LINUX_VERSION_MINOR=$?) - AC_MSG_RESULT($LINUX_VERSION_MAJOR.$LINUX_VERSION_MINOR) - dnl restore CFLAGS - CFLAGS="$ac_save_CFLAGS" + dnl make it available to Makefiles so it can be used in ...dir + AC_SUBST(modulesdir, $MODULESDIR) + AC_MSG_NOTICE([Putting kernel modules under ${MODULESDIR}]) +]) - case $LINUX_VERSION_MAJOR.$LINUX_VERSION_MINOR in - 2.6) - AS_LINUX_2_6() - ;; - 2.[[01234]]) - AS_LINUX_2_4() - ;; - *) - AC_MSG_ERROR([Unknown Linux major.minor $LINUX_VERSION_MAJOR.$LINUX_VERSION_MINOR]) - ;; - esac +dnl add an argument to specify/override the module devel install path +dnl if nothing specified, it will be the passed in LINUXDIR) +AC_DEFUN([AS_LINUX_MODULESDEVELDIR], +[ + LINUXDIR=[$1] + AC_ARG_WITH([modulesdeveldir], + [AC_HELP_STRING([--with-modulesdeveldir=DIR], + [specify path to kernel-specific module development install directory])], + [MODULESDEVELDIR="${withval}"], + [MODULESDEVELDIR=default]) + + if test "${MODULESDEVELDIR}" = "default" ; then + MODULESDEVELDIR="${LINUXDIR}" + fi + dnl make it available to Makefiles so it can be used in ...dir + AC_SUBST(modulesdeveldir, $MODULESDEVELDIR) + AC_MSG_NOTICE([Putting kernel module development files under ${MODULESDEVELDIR}]) ]) AC_DEFUN([AS_LINUX_2_6], @@ -310,24 +562,27 @@ obj-m += fake.o .PHONY: flags flags: echo LINUX_ARCH=\"\$(ARCH)\" >>\$(obj)/flags - echo LINUX_AFLAGS=\"\$(AFLAGS)\" | sed 's_Iinclude_I"\$(LINUXDIR)/include"_g'>>\$(obj)/flags + echo LINUX_AFLAGS=\"\$(AFLAGS)\" | sed 's,include,"\$(LINUXDIR)/include",g'>>\$(obj)/flags echo LINUX_LDFLAGS=\"\" >>\$(obj)/flags echo LINUX_ARFLAGS=\"\$(ARFLAGS)\" >>\$(obj)/flags echo LINUX_CROSS_COMPILE=\"\$(CROSS_COMPILE)\" >>\$(obj)/flags echo LINUX_KERNELRELEASE=\"\$(KERNELRELEASE)\" >>\$(obj)/flags - echo LINUX_CFLAGS=\"\$(CFLAGS)\" | sed 's_Iinclude_I"\$(LINUXDIR)/include"_g'>>\$(obj)/flags + echo LINUX_CFLAGS=\"\$(CFLAGS) \$(CPPFLAGS)\" \ + | sed -e 's,-Iinclude,-I\$(LINUXDIR)/include,g' -e 's,-include include,-include \$(LINUXDIR)/include,g' >>\$(obj)/flags echo LINUX_CFLAGS_MODULE=\"\$(CFLAGS_MODULE)\" >>\$(obj)/flags echo LINUX_CC=\"\$(CC)\" >>\$(obj)/flags echo LINUX_LD=\"\$(LD) \$(LDFLAGS) \$(LDFLAGS_MODULE)\" >>\$(obj)/flags echo LINUX_AS=\"\$(AS)\" >>\$(obj)/flags + echo LINUX_MODLIB=\"\$(MODLIB)\" >>\$(obj)/flags EOF - echo ${MAKE-make} -C ${LINUX_DIR} V=1 SUBDIRS=${tmpdir} LINUXDIR=${LINUX_DIR} MODVERDIR=${tmpdir} modules >&5 2>&5 - ${MAKE-make} -C ${LINUX_DIR} V=1 SUBDIRS=${tmpdir} LINUXDIR=${LINUX_DIR} MODVERDIR=${tmpdir} modules >&5 2>&5 + echo ${MAKE-make} -C ${LINUX_DIR} V=1 SUBDIRS=${tmpdir} LINUXDIR=${LINUX_DIR} modules >&5 2>&5 + ${MAKE-make} -C ${LINUX_DIR} V=1 SUBDIRS=${tmpdir} LINUXDIR=${LINUX_DIR} modules >&5 2>&5 . ${tmpdir}/flags rm -rf ${tmpdir} LINUX_MODULE_EXT=".ko" + LINUX_MODULE_STYLE="2.6.6" LINUX_CFLAGS="$LINUX_CFLAGS $LINUX_CFLAGS_MODULE" @@ -342,8 +597,13 @@ EOF AC_SUBST(LINUX_LD) AC_SUBST(LINUX_AS) AC_SUBST(LINUX_MODULE_EXT) + AC_SUBST(LINUX_MODULE_STYLE) + AC_SUBST(LINUX_MODPOST) + AC_SUBST(LINUX_MODLIB) - AC_MSG_RESULT([ok]) + AC_MSG_RESULT([$LINUX_CFLAGS]) + + AC_PATH_PROG([LINUX_MODPOST], ["modpost"], ["no"], ["$LINUX_DIR/scripts:$LINUX_DIR/scripts/mod"]) ]) @@ -355,9 +615,9 @@ AC_DEFUN([AS_LINUX_2_4], dnl we use the correct config file by substituting the MAKEFILES dnl Makefile variable, which originally points to .config - if [[ ! -f "${LINUX_DIR}/.hdepend" ]];then - AC_MSG_ERROR([ -You need to run 'make dep' on the kernel source before continuing.]) + if [[ ! -e "${LINUX_DIR}/.hdepend" ]];then + AC_MSG_WARN([ +No .hdepend file found, you may need to run 'make dep' on the kernel source before continuing.]) fi { @@ -390,10 +650,15 @@ modules: @echo LINUX_AS=\"\$(AS)\" EOF make -C ${LINUX_DIR} SUBDIRS=${tmpdir} modules | grep ^LINUX_ >${tmpdir}/ack + if (($?)); then + echo make modules with LINUX_DIR=$(LINUX_DIR) failed. + exit 1 + fi . ${tmpdir}/ack rm -rf ${tmpdir} LINUX_MODULE_EXT=".o" + LINUX_MODULE_STYLE="2.4.0" LINUX_CFLAGS="$LINUX_CFLAGS $LINUX_MODFLAGS" @@ -413,6 +678,7 @@ EOF AC_SUBST(LINUX_LD) AC_SUBST(LINUX_AS) AC_SUBST(LINUX_MODULE_EXT) + AC_SUBST(LINUX_MODULE_STYLE) AC_MSG_RESULT([ok]) @@ -426,10 +692,10 @@ AC_DEFUN([AS_CHECK_LINUX_CONFIG_OPTION], [ AC_MSG_CHECKING([Linux config option $1]) - if grep '^$1=y$' ${CONFIG_FILE} >/dev/null 2>/dev/null; then + if grep '^$1=y$' ${LINUX_CONFIG} >/dev/null 2>/dev/null; then result=yes $2 - else if grep '^$1=m$' ${CONFIG_FILE} >/dev/null 2>/dev/null; then + else if grep '^$1=m$' ${LINUX_CONFIG} >/dev/null 2>/dev/null; then result=module $3 else @@ -461,3 +727,247 @@ AC_DEFUN([AS_LINUX_CONFIG_OPTION_MODULE], AM_CONDITIONAL([$1],[test "${$1}" = yes -o "${$1}" = module]) ]) +dnl check for the major/minor version of the Linux source by checking +dnl the Makefile +dnl first argument is the linux directory +dnl sets LINUX_VERSION_MAJOR and LINUX_VERSION_MINOR +AC_DEFUN([AS_LINUX_VERSION_MAJOR_MINOR], +[ + LINUX_DIR=[$1] + AC_MSG_CHECKING([Linux major/minor version]) + + if [[ ! -f "${LINUX_DIR}/Makefile" ]];then + AC_MSG_ERROR([The Linux kernel Makefile does not exist.]) + fi + dnl the next set of tests is for figuring out version major/minor + dnl use VERSION and PATCHLEVEL in the kernel Makefile + LINUX_VERSION_MAJOR=`sed -n 's/^VERSION = \([[0-9]]*\)/\1/p' "${LINUX_DIR}/Makefile"` + LINUX_VERSION_MINOR=`sed -n 's/^PATCHLEVEL = \([[0-9]]*\)/\1/p' "${LINUX_DIR}/Makefile"` + if [[ -z "$LINUX_VERSION_MAJOR" -o -z "$LINUX_VERSION_MINOR" ]]; then + AC_MSG_ERROR([No major/minor version information found in Linux kernel Makefile.]) + fi + AC_MSG_RESULT($LINUX_VERSION_MAJOR.$LINUX_VERSION_MINOR) +]) + +# COMEDI_CHECK_LINUX_KBUILD([LINUX_SOURCE_PATH], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------------- +# +# Check if kernel source tree is recent enough to support "Kbuild" files. +AC_DEFUN([COMEDI_CHECK_LINUX_KBUILD], +[ + AC_MSG_CHECKING([for Kbuild support in $1]) + dnl If $1/scripts/Makefile.build refers to $()/Kbuild + dnl then we support Kbuild (2.6.10 onwards). + if grep -q '/Kbuild' "$1/scripts/Makefile.build" 2>/dev/null; then + AC_MSG_RESULT([yes]) + $2 + else + AC_MSG_RESULT([no]) + $3 + fi +]) + +# COMEDI_CHECK_PCMCIA_PROBE([LINUX_SOURCE_PATH], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------------- +# +# Check if kernel pcmcia support is new enough to have a probe member in the pcmcia_driver +# struct. +AC_DEFUN([COMEDI_CHECK_PCMCIA_DRIVER_PROBE], +[ + AC_REQUIRE([AC_PROG_EGREP]) + AC_MSG_CHECKING([$1 for probe in pcmcia_driver struct]) + cat "$1/include/pcmcia/ds.h" | tr \\n ' ' | [$EGREP "struct[[:space:]]+pcmcia_driver[[:space:]]*[{][^}]*probe"] > /dev/null + if (($?)); then + AC_MSG_RESULT([no]) + $3 + else + AC_MSG_RESULT([yes]) + $2 + fi +]) + +# COMEDI_CHECK_PCMCIA_DRIVER_NAME([LINUX_SOURCE_PATH], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------------- +# +# Check if kernel pcmcia support is new enough to have a name member in the pcmcia_driver +# struct. +AC_DEFUN([COMEDI_CHECK_PCMCIA_DRIVER_NAME], +[ + AC_REQUIRE([AC_PROG_EGREP]) + AC_MSG_CHECKING([$1 for name in pcmcia_driver struct]) + cat "$1/include/pcmcia/ds.h" | tr \\n ' ' | [$EGREP "struct[[:space:]]+pcmcia_driver[[:space:]]*[{][^}]*name"] > /dev/null + if (($?)); then + AC_MSG_RESULT([no]) + $3 + else + AC_MSG_RESULT([yes]) + $2 + fi +]) + +# COMEDI_CHECK_PCMCIA_LOOP_TUPLE([LINUX_SOURCE_PATH], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------------- +# +# Check if kernel pcmcia support is new enough to have the pcmcia_loop_tuple +# function. +AC_DEFUN([COMEDI_CHECK_PCMCIA_LOOP_TUPLE], +[ + AC_MSG_CHECKING([$1 for pcmcia_loop_tuple function]) + if [grep -q 'int[[:space:]]\+pcmcia_loop_tuple[[:space:]]*(' "$1/include/pcmcia/ds.h"] 2>/dev/null ; then + AC_MSG_RESULT([yes]) + $2 + else + AC_MSG_RESULT([no]) + $3 + fi +]) + +# COMEDI_CHECK_DS_DEV_NODE_T([LINUX_SOURCE_PATH], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------------- +# +# Check if kernel pcmcia support is old enough to have the dev_node_t type +# in pcmcia/ds.h. +AC_DEFUN([COMEDI_CHECK_DS_DEV_NODE_T], +[ + AC_MSG_CHECKING([$1 for dev_node_t in pcmcia/ds.h (removed in 2.6.35)]) + if [grep -q dev_node_t "$1/include/pcmcia/ds.h"] 2>/dev/null ; then + AC_MSG_RESULT([yes]) + $2 + else + AC_MSG_RESULT([no]) + $3 + fi +]) + +# COMEDI_CHECK_CS_IRQ_REQ_T([LINUX_SOURCE_PATH], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------------- +# +# Check if kernel pcmcia support is old enough to have the irq_req_t type +# in pcmcia/cs.h. +AC_DEFUN([COMEDI_CHECK_CS_IRQ_REQ_T], +[ + AC_MSG_CHECKING([$1 for irq_req_t in pcmcia/cs.h (removed in 2.6.35)]) + if [grep -q irq_req_t "$1/include/pcmcia/cs.h"] 2>/dev/null ; then + AC_MSG_RESULT([yes]) + $2 + else + AC_MSG_RESULT([no]) + $3 + fi +]) + +# COMEDI_CHECK_CS_IO_REQ_T([LINUX_SOURCE_PATH], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------------- +# +# Check if kernel pcmcia support is old enough to have the io_req_t type +# in pcmcia/cs.h. +AC_DEFUN([COMEDI_CHECK_CS_IO_REQ_T], +[ + AC_MSG_CHECKING([$1 for io_req_t in pcmcia/cs.h (removed in 2.6.36)]) + if [grep -q io_req_t "$1/include/pcmcia/cs.h"] 2>/dev/null ; then + AC_MSG_RESULT([yes]) + $2 + else + AC_MSG_RESULT([no]) + $3 + fi +]) + +# COMEDI_CHECK_CS_MEMREQ_T([LINUX_SOURCE_PATH], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------------- +# +# Check if kernel pcmcia support is old enough to have the memreq_t type +# in pcmcia/cs.h. +AC_DEFUN([COMEDI_CHECK_CS_MEMREQ_T], +[ + AC_MSG_CHECKING([$1 for memreq_t in pcmcia/cs.h (removed in 2.6.36)]) + if [grep -q memreq_t "$1/include/pcmcia/cs.h"] 2>/dev/null ; then + AC_MSG_RESULT([yes]) + $2 + else + AC_MSG_RESULT([no]) + $3 + fi +]) + +# COMEDI_CHECK_HAVE_CS_TYPES_H([LINUX_SOURCE_PATH], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------------- +# +# Check if kernel has file. +AC_DEFUN([COMEDI_CHECK_HAVE_CS_TYPES_H], +[ + AC_MSG_CHECKING([$1 for include/pcmcia/cs_types.h (removed in 2.6.36)]) + if test -f "$1/include/pcmcia/cs_types.h"; then + AC_MSG_RESULT([yes]) + $2 + else + AC_MSG_RESULT([no]) + $3 + fi +]) + +# COMEDI_CHECK_HAVE_CS_H([LINUX_SOURCE_PATH], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------------- +# +# Check if kernel has file. +AC_DEFUN([COMEDI_CHECK_HAVE_CS_H], +[ + AC_MSG_CHECKING([$1 for include/pcmcia/cs.h (removed in 2.6.37)]) + if test -f "$1/include/pcmcia/cs.h"; then + AC_MSG_RESULT([yes]) + $2 + else + AC_MSG_RESULT([no]) + $3 + fi +]) + +# COMEDI_CHECK_HAVE_MUTEX_H([LINUX_SOURCE_PATH], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------------- +# +# Check if kernel has file. +AC_DEFUN([COMEDI_CHECK_HAVE_MUTEX_H], +[ + AC_MSG_CHECKING([$1 for include/linux/mutex.h]) + if test -f "$1/include/linux/mutex.h"; then + AC_MSG_RESULT([yes]) + $2 + else + AC_MSG_RESULT([no]) + $3 + fi +]) + +# COMEDI_CHECK_HAVE_LINUX_SEMAPHORE_H([LINUX_SOURCE_PATH], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------------- +# +# Check if kernel has file. +AC_DEFUN([COMEDI_CHECK_HAVE_LINUX_SEMAPHORE_H], +[ + AC_MSG_CHECKING([$1 for include/linux/semaphore.h]) + if test -f "$1/include/linux/semaphore.h"; then + AC_MSG_RESULT([yes]) + $2 + else + AC_MSG_RESULT([no]) + $3 + fi +]) + +# COMEDI_CHECK_HAVE_GENERIC_BOOL_TYPE([LINUX_SOURCE_PATH], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# +# ------------------------------------------------------------- +# Check if kernel is new enough to have generic 'bool' type in +# and 'false' and 'true' enum constants in . This was added +# in vanilla 2.6.19, but backported to RHEL5 2.6.18. +AC_DEFUN([COMEDI_CHECK_HAVE_GENERIC_BOOL_TYPE], +[ + AC_MSG_CHECKING([$1 for 'bool' in include/linux/types.h]) + if grep -q 'bool;' "$1/include/linux/types.h" 2>/dev/null; then + AC_MSG_RESULT([yes]) + $2 + else + AC_MSG_RESULT([no]) + $3 + fi +])