gentoo-x86/eclass/linux-mod.eclass

# Copyright 1999-2004 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/linux-mod.eclass,v 1.40 2005/07/05 11:37:03 johnm Exp $

# Description: This eclass is used to interface with linux-info in such a way
#              to provide the functionality required and initial functions
#                          required to install external modules against a kernel source
#                          tree.
#
# Maintainer: John Mylchreest <johnm@gentoo.org>
# Copyright 2004 Gentoo Linux
#
# Please direct your bugs to the current eclass maintainer :)

# A Couple of env vars are available to effect usage of this eclass
# These are as follows:
# 
# Env Var               Option          Default         Description
# KERNEL_DIR            <string>        /usr/src/linux  The directory containing kernel
#                                                       the target kernel sources.
# ECONF_PARAMS          <string>                        The parameters to pass to econf.
#                                                       If this is not set, then econf
#                                                       isn't run.
# BUILD_PARAMS          <string>                        The parameters to pass to emake.
# BUILD_TARGETS         <string>        clean modules   The build targets to pass to
#                                                       make.
# MODULE_NAMES          <string>                        This is the modules which are
#                                                       to be built automatically using 
#                                                       the default pkg_compile/install. 
#                                                       They are explained properly 
#                                                       below. It will only make  
#                                                       BUILD_TARGETS once in any
#                                                       directory.

# MODULE_NAMES - Detailed Overview
# 
# The structure of each MODULE_NAMES entry is as follows:
# modulename(libdir:srcdir:objdir)
# for example:
# MODULE_NAMES="module_pci(pci:${S}/pci:${S}) module_usb(usb:${S}/usb:${S})"
# 
# what this would do is
#  cd ${S}/pci
#  make ${BUILD_PARAMS} ${BUILD_TARGETS}
#  cd ${S}
#  insinto /lib/modules/${KV_FULL}/pci
#  doins module_pci.${KV_OBJ}
#
#  cd ${S}/usb
#  make ${BUILD_PARAMS} ${BUILD_TARGETS}
#  cd ${S}
#  insinto /lib/modules/${KV_FULL}/usb
#  doins module_usb.${KV_OBJ}
#
# if the srcdir isnt specified, it assumes ${S}
# if the libdir isnt specified, it assumes misc.
# if the objdir isnt specified, it assumes srcdir

# There is also support for automatyed modules.d file generation.
# This can be explicitly enabled by setting any of the following variables.
#
#
# MODULESD_${modulename}_ENABLED                This enables the modules.d file
#                                               generation even if we dont
#                                               specify any additional info.
# MODULESD_${modulename}_EXAMPLES               This is a bash array containing
#                                               a list of examples which should
#                                               be used. If you want us to try and
#                                               take a guess. Set this to "guess"
# MODULESD_${modulename}_ALIASES                This is a bash array containing
#                                               a list of associated aliases.
# MODULESD_${modulename}_ADDITIONS              This is a bash array containing
#                                               A list of additional things to
#                                               add to the bottom of the file.
#                                               This can be absolutely anything.
#                                               Each entry is a new line.
# MODULES_${modulename}_DOCS                    This is a string list which contains
#                                               the full path to any associated
#                                               documents for $modulename


inherit linux-info
ECLASS=linux-mod
INHERITED="$INHERITED $ECLASS"
EXPORT_FUNCTIONS pkg_setup pkg_postinst src_install src_compile pkg_postrm

IUSE="${IUSE}"
SLOT="0"
DESCRIPTION="Based on the $ECLASS eclass"
DEPEND="virtual/linux-sources
                sys-apps/sed
                virtual/modutils
                pcmcia? ( virtual/pcmcia )"

# eclass utilities
# ----------------------------------

unpack_pcmcia_sources() {
        # So while the two eclasses exist side-by-side and also the ebuilds inherit
        # both we need to check for PCMCIA_SOURCE_DIR, and if we find it, then we
        # bail out and assume pcmcia.eclass is working on it.
        [[ -n ${PCMCIA_SOURCE_DIR} ]] && return 1

        if [[ -f "${1}" ]]; then
                PCMCIA_SOURCE_DIR="${WORKDIR}/pcmcia-cs/"
        
                ebegin "Decompressing pcmcia-cs sources"
                mkdir -p ${PCMCIA_SOURCE_DIR}
                tar -xjf ${1} -C ${PCMCIA_SOURCE_DIR}
                eend $?

                if [[ -f ${PCMCIA_SOURCE_DIR}/pcmcia-cs-version ]]; then
                        PCMCIA_VERSION=$(cat ${PCMCIA_SOURCE_DIR}/pcmcia-cs-version)
                        einfo "Found pcmcia-cs-${PCMCIA_VERSION}"
                fi
        fi
}

# Dummy function for compatibility.
pcmcia_configure() { return 0; }

pcmcia_src_unpack() {
        local pcmcia_tbz="${ROOT}/usr/src/pcmcia-cs/pcmcia-cs-build-env.tbz2"

        # if the kernel has pcmcia support built in, then we just ignore all this.
        if linux_chkconfig_present PCMCIA; then
                einfo "Kernel based PCMCIA support has been detected."
        else
                if kernel_is 2 4; then
                        unpack_pcmcia_sources ${pcmcia_tbz};
                else
                        einfo "We have detected that you are running a 2.6 kernel"
                        einfo "but you are not using the built-in PCMCIA support."
                        einfo "We will assume you know what you are doing, but please"
                        einfo "consider using the built in PCMCIA support instead."
                        sleep 10

                        unpack_pcmcia_sources ${pcmcia_tbz};
                fi
        fi
}

use_m() {
        # if we haven't determined the version yet, we need too.
        get_version;
        
        # if the kernel version is greater than 2.6.6 then we should use
        # M= instead of SUBDIRS=
        [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
                return 0 || return 1
}

convert_to_m() {
        if use_m
        then
                [ ! -f "${1}" ] && \
                        die "convert_to_m() requires a filename as an argument"
                ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
                sed -i 's:SUBDIRS=:M=:g' ${1}
                eend $?
        fi
}

update_depmod() {
        # if we haven't determined the version yet, we need too.
        get_version;
        
        ebegin "Updating module dependencies for ${KV_FULL}"
        if [ -r ${KV_OUT_DIR}/System.map ]
        then
                depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL}
                eend $?
        else
                ewarn
                ewarn "${KV_OUT_DIR}/System.map not found."
                ewarn "You must manually update the kernel module dependencies using depmod."
                eend 1
                ewarn
        fi
}

update_modules() {
        if [ -x /sbin/modules-update ] && \
                grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
                ebegin "Updating modules.conf"
                /sbin/modules-update
                eend $?
        fi
}

move_old_moduledb() {
        local OLDDIR=${ROOT}/usr/share/module-rebuild/
        local NEWDIR=${ROOT}/var/lib/module-rebuild/
        
        if [[ -f ${OLDDIR}/moduledb ]]; then
                [[ ! -d ${NEWDIR} ]] && mkdir -p ${NEWDIR}
                mv ${OLDDIR}/moduledb ${NEWDIR}/moduledb
                rmdir ${OLDDIR}
        fi
}

update_moduledb() {
        local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
        move_old_moduledb

        if [[ ! -f ${MODULEDB_DIR}/moduledb ]]; then
                [[ ! -d ${MODULEDB_DIR} ]] && mkdir -p ${MODULEDB_DIR}
                touch ${MODULEDB_DIR}/moduledb
        fi
        if [[ -z $(grep ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb) ]]; then
                einfo "Adding module to moduledb."
                echo "a:1:${CATEGORY}/${PN}-${PVR}" >> ${MODULEDB_DIR}/moduledb
        fi      
}

remove_moduledb() {
        local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
        move_old_moduledb

        if [[ -n $(grep ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb) ]]; then
                einfo "Removing ${CATEGORY}/${PN}-${PVR} from moduledb."
                sed -ie "/.*${CATEGORY}\/${P}.*/d" ${MODULEDB_DIR}/moduledb
        fi
}

set_kvobj() {
        if kernel_is 2 6
        then
                KV_OBJ="ko"
        else
                KV_OBJ="o"
        fi
        # Do we really need to know this?
        # Lets silence it.
        # einfo "Using KV_OBJ=${KV_OBJ}"
}

generate_modulesd() {
        # This function will generate the neccessary modules.d file from the
        # information contained in the modules exported parms

        local   currm_path currm t myIFS myVAR
        local   module_docs module_enabled module_aliases \
                        module_additions module_examples module_modinfo module_opts

        for currm_path in ${@}
        do
                currm=${currm_path//*\/}
                currm=$(echo ${currm} | tr '[:lower:]' '[:upper:]')

                module_docs="$(eval echo \${MODULESD_${currm}_DOCS})"
                module_enabled="$(eval echo \${MODULESD_${currm}_ENABLED})"
                module_aliases="$(eval echo \${#MODULESD_${currm/-/_}_ALIASES[*]})"
                module_additions="$(eval echo \${#MODULESD_${currm/-/_}_ADDITIONS[*]})"
                module_examples="$(eval echo \${#MODULESD_${currm/-/_}_EXAMPLES[*]})"

                [[ ${module_aliases} -eq 0 ]]   && unset module_aliases
                [[ ${module_additions} -eq 0 ]] && unset module_additions
                [[ ${module_examples} -eq 0 ]]  && unset module_examples

                # If we specify we dont want it, then lets exit, otherwise we assume 
                # that if its set, we do want it.
                [[ ${module_enabled} == no ]] && return 0

                # unset any unwanted variables.
                for t in ${!module_*}
                do
                        [[ -z ${!t} ]] && unset ${t}
                done

                [[ -z ${!module_*} ]] && return 0

                # OK so now if we have got this far, then we know we want to continue
                # and generate the modules.d file.
                module_modinfo="$(modinfo -p ${currm_path}.${KV_OBJ})"
                module_config="${T}/modulesd-${currm}"

                ebegin "Preparing file for modules.d"
                #-----------------------------------------------------------------------
                echo "# modules.d configuration file for ${currm}" >> ${module_config}
                #-----------------------------------------------------------------------
                [[ -n ${module_docs} ]] && \
                        echo "# For more information please read:" >> ${module_config}
                for t in ${module_docs}
                do
                        echo "#    ${t//*\/}" >> ${module_config}
                done
                echo >> ${module_config}

                #-----------------------------------------------------------------------
                if [[ ${module_aliases} -gt 0 ]]
                then
                        echo  "# Internal Aliases - Do not edit" >> ${module_config}
                        echo  "# ------------------------------" >> ${module_config}

                        for((t=0; t<${module_aliases}; t++))
                        do
                                echo "alias $(eval echo \${MODULESD_${currm}_ALIASES[$t]})" \
                                        >> ${module_config}
                        done
                        echo '' >> ${module_config}
                fi

                #-----------------------------------------------------------------------
                if [[ -n ${module_modinfo} ]]
                then
                        echo >> ${module_config}
                        echo  "# Configurable module parameters" >> ${module_config}
                        echo  "# ------------------------------" >> ${module_config}
                        myIFS="${IFS}"
                        IFS="$(echo -en "\n\b")"
                        
                        for t in ${module_modinfo}
                        do
                                myVAR="$(echo ${t#*:} | grep -e " [0-9][ =]" | sed "s:.*\([01][= ]\).*:\1:")"
                                if [[ -n ${myVAR} ]]
                                then
                                        module_opts="${module_opts} ${t%%:*}:${myVAR}"
                                fi
                                echo -e "# ${t%%:*}:\t${t#*:}" >> ${module_config}
                        done                    
                        IFS="${myIFS}"
                        echo '' >> ${module_config}
                fi

                #-----------------------------------------------------------------------
                if [[ $(eval echo \${MODULESD_${currm}_ALIASES[0]}) == guess ]]
                then
                        # So lets do some guesswork eh?
                        if [[ -n ${module_opts} ]]
                        then
                                echo "# For Example..." >> ${module_config}
                                echo "# --------------" >> ${module_config}
                                for t in ${module_opts}
                                do
                                        echo "# options ${currm} ${t//:*}=${t//*:}" >> ${module_config}
                                done
                                echo '' >> ${module_config}
                        fi
                elif [[ ${module_examples} -gt 0 ]]
                then
                        echo "# For Example..." >> ${module_config}
                        echo "# --------------" >> ${module_config}
                        for((t=0; t<${module_examples}; t++))
                        do
                                echo "options $(eval echo \${MODULESD_${currm}_EXAMPLES[$t]})" \
                                        >> ${module_config}
                        done
                        echo '' >> ${module_config}
                fi

                #-----------------------------------------------------------------------
                if [[ ${module_additions} -gt 0 ]]
                then
                        for((t=0; t<${module_additions}; t++))
                        do
                                echo "$(eval echo \${MODULESD_${currm}_ADDITIONS[$t]})" \
                                        >> ${module_config}
                        done
                        echo '' >> ${module_config}
                fi
                
                #-----------------------------------------------------------------------

                # then we install it
                insinto /etc/modules.d
                newins ${module_config} ${currm_path//*\/}

                # and install any documentation we might have.
                [[ -n ${module_docs} ]] && dodoc ${module_docs}
        done
        eend 0
        return 0
}

display_postinst() {
        # if we haven't determined the version yet, we need too.
        get_version;
        
        local modulename moduledir sourcedir moduletemp file i
        
        file=${ROOT}/etc/modules.autoload.d/kernel-${KV_MAJOR}.${KV_MINOR}
        file=${file/\/\///}

        for i in ${MODULE_IGNORE}
        do
                MODULE_NAMES=${MODULE_NAMES//${i}(*}
        done

        if [[ -n ${MODULE_NAMES} ]]
        then
                einfo "If you would like to load this module automatically upon boot"
                einfo "please type the following as root:"
                for i in ${MODULE_NAMES}
                do
                        unset libdir srcdir objdir
                        for n in $(find_module_params ${i})
                        do
                                eval ${n/:*}=${n/*:/}
                        done
                        einfo "    # echo \"${modulename}\" >> ${file}"
                done
                einfo
        fi
}

find_module_params() {
        local matched_offset=0 matched_opts=0 test="${@}" temp_var result
        local i=0 y=0 z=0
        
        for((i=0; i<=${#test}; i++))
        do
                case ${test:${i}:1} in
                        \()             matched_offset[0]=${i};;
                        \:)             matched_opts=$((${matched_opts} + 1));
                                        matched_offset[${matched_opts}]="${i}";;
                        \))             matched_opts=$((${matched_opts} + 1));
                                        matched_offset[${matched_opts}]="${i}";;
                esac
        done
        
        for((i=0; i<=${matched_opts}; i++))
        do
                # i                     = offset were working on
                # y                     = last offset
                # z                     = current offset - last offset
                # temp_var      = temporary name
                case ${i} in
                        0)      tempvar=${test:0:${matched_offset[0]}};;
                        *)      y=$((${matched_offset[$((${i} - 1))]} + 1))
                                z=$((${matched_offset[${i}]} - ${matched_offset[$((${i} - 1))]}));
                                z=$((${z} - 1))
                                tempvar=${test:${y}:${z}};;
                esac
                
                case ${i} in
                        0)      result="${result} modulename:${tempvar}";;
                        1)      result="${result} libdir:${tempvar}";;
                        2)      result="${result} srcdir:${tempvar}";;
                        3)      result="${result} objdir:${tempvar}";;
                esac
        done
        
        echo ${result}
}

# default ebuild functions
# --------------------------------

linux-mod_pkg_setup() {
        linux-info_pkg_setup;
        check_kernel_built;
        check_modules_supported;
        set_kvobj;
}

linux-mod_src_compile() {
        local modulename libdir srcdir objdir i n myARCH="${ARCH}"
        unset ARCH

        BUILD_TARGETS=${BUILD_TARGETS:-clean module}
        
        for i in ${MODULE_IGNORE}
        do
                MODULE_NAMES=${MODULE_NAMES//${i}(*}
        done

        for i in ${MODULE_NAMES}
        do
                unset libdir srcdir objdir
                for n in $(find_module_params ${i})
                do
                        eval ${n/:*}=${n/*:/}
                done
                libdir=${libdir:-misc}
                srcdir=${srcdir:-${S}}
                objdir=${objdir:-${srcdir}}
                
                if [ ! -f "${srcdir}/.built" ];
                then
                        cd ${srcdir}
                        einfo "Preparing ${modulename} module"
                        if [[ -n ${ECONF_PARAMS} ]]
                        then
                                econf ${ECONF_PARAMS} || \
                                die "Unable to run econf ${ECONF_PARAMS}"
                        fi

                        emake ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS} \
                                || die "Unable to make \
                                   ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS}."
                        touch ${srcdir}/.built
                        cd ${OLDPWD}
                fi
        done

        ARCH="${myARCH}"
}

linux-mod_src_install() {
        local modulename libdir srcdir objdir i n
        
        for i in ${MODULE_IGNORE}
        do
                MODULE_NAMES=${MODULE_NAMES//${i}(*}
        done

        for i in ${MODULE_NAMES}
        do
                unset libdir srcdir objdir
                for n in $(find_module_params ${i})
                do
                        eval ${n/:*}=${n/*:/}
                done
                libdir=${libdir:-misc}
                srcdir=${srcdir:-${S}}
                objdir=${objdir:-${srcdir}}

                einfo "Installing ${modulename} module"
                cd ${objdir}
                insinto ${ROOT}lib/modules/${KV_FULL}/${libdir}
                doins ${modulename}.${KV_OBJ}
                cd ${OLDPWD}
                
                generate_modulesd ${objdir}/${modulename}
        done
}

linux-mod_pkg_postinst() {
        update_depmod;
        update_modules;
        update_moduledb;
        display_postinst;
}

linux-mod_pkg_postrm() {
        remove_moduledb;
}
1	johnm	1.1	# Copyright 1999-2004 Gentoo Foundation
2			# Distributed under the terms of the GNU General Public License v2
3	johnm	1.41	# $Header: /var/cvsroot/gentoo-x86/eclass/linux-mod.eclass,v 1.40 2005/07/05 11:37:03 johnm Exp $
4	johnm	1.1
5	johnm	1.10	# Description: This eclass is used to interface with linux-info in such a way
6			# to provide the functionality required and initial functions
7			# required to install external modules against a kernel source
8			# tree.
9			#
10			# Maintainer: John Mylchreest <johnm@gentoo.org>
11			# Copyright 2004 Gentoo Linux
12			#
13			# Please direct your bugs to the current eclass maintainer :)
14
15			# A Couple of env vars are available to effect usage of this eclass
16			# These are as follows:
17			#
18	johnm	1.26	# Env Var Option Default Description
19			# KERNEL_DIR <string> /usr/src/linux The directory containing kernel
20			# the target kernel sources.
21			# ECONF_PARAMS <string> The parameters to pass to econf.
22			# If this is not set, then econf
23			# isn't run.
24			# BUILD_PARAMS <string> The parameters to pass to emake.
25			# BUILD_TARGETS <string> clean modules The build targets to pass to
26			# make.
27			# MODULE_NAMES <string> This is the modules which are
28			# to be built automatically using
29			# the default pkg_compile/install.
30			# They are explained properly
31			# below. It will only make
32			# BUILD_TARGETS once in any
33			# directory.
34	johnm	1.10
35			# MODULE_NAMES - Detailed Overview
36			#
37			# The structure of each MODULE_NAMES entry is as follows:
38	johnm	1.26	# modulename(libdir:srcdir:objdir)
39	johnm	1.10	# for example:
40	johnm	1.26	# MODULE_NAMES="module_pci(pci:${S}/pci:${S}) module_usb(usb:${S}/usb:${S})"
41	johnm	1.10	#
42			# what this would do is
43			# cd ${S}/pci
44			# make ${BUILD_PARAMS} ${BUILD_TARGETS}
45	johnm	1.26	# cd ${S}
46	johnm	1.10	# insinto /lib/modules/${KV_FULL}/pci
47			# doins module_pci.${KV_OBJ}
48			#
49			# cd ${S}/usb
50			# make ${BUILD_PARAMS} ${BUILD_TARGETS}
51	johnm	1.26	# cd ${S}
52	johnm	1.10	# insinto /lib/modules/${KV_FULL}/usb
53			# doins module_usb.${KV_OBJ}
54			#
55	johnm	1.26	# if the srcdir isnt specified, it assumes ${S}
56			# if the libdir isnt specified, it assumes misc.
57			# if the objdir isnt specified, it assumes srcdir
58
59			# There is also support for automatyed modules.d file generation.
60			# This can be explicitly enabled by setting any of the following variables.
61			#
62			#
63			# MODULESD_${modulename}_ENABLED This enables the modules.d file
64			# generation even if we dont
65			# specify any additional info.
66			# MODULESD_${modulename}_EXAMPLES This is a bash array containing
67			# a list of examples which should
68			# be used. If you want us to try and
69			# take a guess. Set this to "guess"
70			# MODULESD_${modulename}_ALIASES This is a bash array containing
71			# a list of associated aliases.
72			# MODULESD_${modulename}_ADDITIONS This is a bash array containing
73			# A list of additional things to
74			# add to the bottom of the file.
75			# This can be absolutely anything.
76			# Each entry is a new line.
77			# MODULES_${modulename}_DOCS This is a string list which contains
78			# the full path to any associated
79			# documents for $modulename
80
81	johnm	1.1
82			inherit linux-info
83			ECLASS=linux-mod
84			INHERITED="$INHERITED $ECLASS"
85	johnm	1.37	EXPORT_FUNCTIONS pkg_setup pkg_postinst src_install src_compile pkg_postrm
86	johnm	1.1
87	brix	1.38	IUSE="${IUSE}"
88	johnm	1.26	SLOT="0"
89	johnm	1.1	DESCRIPTION="Based on the $ECLASS eclass"
90			DEPEND="virtual/linux-sources
91	johnm	1.11	sys-apps/sed
92	johnm	1.33	virtual/modutils
93	brix	1.39	pcmcia? ( virtual/pcmcia )"
94	johnm	1.26
95	johnm	1.1	# eclass utilities
96			# ----------------------------------
97
98	johnm	1.33	unpack_pcmcia_sources() {
99			# So while the two eclasses exist side-by-side and also the ebuilds inherit
100			# both we need to check for PCMCIA_SOURCE_DIR, and if we find it, then we
101			# bail out and assume pcmcia.eclass is working on it.
102			[[ -n ${PCMCIA_SOURCE_DIR} ]] && return 1
103
104			if [[ -f "${1}" ]]; then
105			PCMCIA_SOURCE_DIR="${WORKDIR}/pcmcia-cs/"
106
107			ebegin "Decompressing pcmcia-cs sources"
108			mkdir -p ${PCMCIA_SOURCE_DIR}
109			tar -xjf ${1} -C ${PCMCIA_SOURCE_DIR}
110			eend $?
111
112			if [[ -f ${PCMCIA_SOURCE_DIR}/pcmcia-cs-version ]]; then
113			PCMCIA_VERSION=$(cat ${PCMCIA_SOURCE_DIR}/pcmcia-cs-version)
114			einfo "Found pcmcia-cs-${PCMCIA_VERSION}"
115			fi
116			fi
117			}
118
119			# Dummy function for compatibility.
120			pcmcia_configure() { return 0; }
121
122			pcmcia_src_unpack() {
123			local pcmcia_tbz="${ROOT}/usr/src/pcmcia-cs/pcmcia-cs-build-env.tbz2"
124
125			# if the kernel has pcmcia support built in, then we just ignore all this.
126			if linux_chkconfig_present PCMCIA; then
127			einfo "Kernel based PCMCIA support has been detected."
128			else
129			if kernel_is 2 4; then
130			unpack_pcmcia_sources ${pcmcia_tbz};
131			else
132			einfo "We have detected that you are running a 2.6 kernel"
133			einfo "but you are not using the built-in PCMCIA support."
134			einfo "We will assume you know what you are doing, but please"
135			einfo "consider using the built in PCMCIA support instead."
136			sleep 10
137
138			unpack_pcmcia_sources ${pcmcia_tbz};
139			fi
140			fi
141			}
142
143	johnm	1.1	use_m() {
144			# if we haven't determined the version yet, we need too.
145			get_version;
146
147			# if the kernel version is greater than 2.6.6 then we should use
148	johnm	1.8	# M= instead of SUBDIRS=
149	johnm	1.1	[ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
150			return 0 \|\| return 1
151			}
152
153			convert_to_m() {
154			if use_m
155			then
156	johnm	1.32	[ ! -f "${1}" ] && \
157			die "convert_to_m() requires a filename as an argument"
158	johnm	1.8	ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
159	johnm	1.1	sed -i 's:SUBDIRS=:M=:g' ${1}
160			eend $?
161			fi
162			}
163
164			update_depmod() {
165			# if we haven't determined the version yet, we need too.
166			get_version;
167
168			ebegin "Updating module dependencies for ${KV_FULL}"
169	johnm	1.5	if [ -r ${KV_OUT_DIR}/System.map ]
170	johnm	1.1	then
171	johnm	1.5	depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL}
172	johnm	1.18	eend $?
173	johnm	1.1	else
174			ewarn
175	johnm	1.5	ewarn "${KV_OUT_DIR}/System.map not found."
176	johnm	1.1	ewarn "You must manually update the kernel module dependencies using depmod."
177	johnm	1.18	eend 1
178	johnm	1.1	ewarn
179			fi
180			}
181
182	johnm	1.3	update_modules() {
183	kingtaco	1.31	if [ -x /sbin/modules-update ] && \
184			grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
185	johnm	1.3	ebegin "Updating modules.conf"
186			/sbin/modules-update
187			eend $?
188			fi
189			}
190
191	johnm	1.41	move_old_moduledb() {
192			local OLDDIR=${ROOT}/usr/share/module-rebuild/
193			local NEWDIR=${ROOT}/var/lib/module-rebuild/
194
195			if [[ -f ${OLDDIR}/moduledb ]]; then
196			[[ ! -d ${NEWDIR} ]] && mkdir -p ${NEWDIR}
197			mv ${OLDDIR}/moduledb ${NEWDIR}/moduledb
198			rmdir ${OLDDIR}
199			fi
200			}
201
202	johnm	1.37	update_moduledb() {
203	johnm	1.40	local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
204	johnm	1.41	move_old_moduledb
205	johnm	1.40
206			if [[ ! -f ${MODULEDB_DIR}/moduledb ]]; then
207			[[ ! -d ${MODULEDB_DIR} ]] && mkdir -p ${MODULEDB_DIR}
208			touch ${MODULEDB_DIR}/moduledb
209	johnm	1.37	fi
210	johnm	1.40	if [[ -z $(grep ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb) ]]; then
211	johnm	1.37	einfo "Adding module to moduledb."
212	johnm	1.40	echo "a:1:${CATEGORY}/${PN}-${PVR}" >> ${MODULEDB_DIR}/moduledb
213	johnm	1.37	fi
214			}
215
216			remove_moduledb() {
217	johnm	1.40	local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
218	johnm	1.41	move_old_moduledb
219	johnm	1.40
220			if [[ -n $(grep ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb) ]]; then
221	johnm	1.37	einfo "Removing ${CATEGORY}/${PN}-${PVR} from moduledb."
222	johnm	1.40	sed -ie "/.${CATEGORY}\/${P}./d" ${MODULEDB_DIR}/moduledb
223	johnm	1.37	fi
224			}
225
226	johnm	1.1	set_kvobj() {
227			if kernel_is 2 6
228			then
229			KV_OBJ="ko"
230			else
231			KV_OBJ="o"
232			fi
233	johnm	1.26	# Do we really need to know this?
234			# Lets silence it.
235			# einfo "Using KV_OBJ=${KV_OBJ}"
236	johnm	1.1	}
237
238	johnm	1.11	generate_modulesd() {
239			# This function will generate the neccessary modules.d file from the
240			# information contained in the modules exported parms
241	johnm	1.26
242			local currm_path currm t myIFS myVAR
243			local module_docs module_enabled module_aliases \
244			module_additions module_examples module_modinfo module_opts
245
246			for currm_path in ${@}
247	johnm	1.11	do
248	johnm	1.26	currm=${currm_path//*\/}
249			currm=$(echo ${currm} \| tr '[:lower:]' '[:upper:]')
250
251			module_docs="$(eval echo \${MODULESD_${currm}_DOCS})"
252			module_enabled="$(eval echo \${MODULESD_${currm}_ENABLED})"
253	johnm	1.30	module_aliases="$(eval echo \${#MODULESD_${currm/-/_}_ALIASES[*]})"
254			module_additions="$(eval echo \${#MODULESD_${currm/-/_}_ADDITIONS[*]})"
255			module_examples="$(eval echo \${#MODULESD_${currm/-/_}_EXAMPLES[*]})"
256	johnm	1.26
257	johnm	1.27	[[ ${module_aliases} -eq 0 ]] && unset module_aliases
258			[[ ${module_additions} -eq 0 ]] && unset module_additions
259			[[ ${module_examples} -eq 0 ]] && unset module_examples
260	johnm	1.26
261			# If we specify we dont want it, then lets exit, otherwise we assume
262			# that if its set, we do want it.
263			[[ ${module_enabled} == no ]] && return 0
264
265			# unset any unwanted variables.
266			for t in ${!module_*}
267	johnm	1.11	do
268	johnm	1.26	[[ -z ${!t} ]] && unset ${t}
269	johnm	1.11	done
270
271	johnm	1.26	[[ -z ${!module_*} ]] && return 0
272
273			# OK so now if we have got this far, then we know we want to continue
274			# and generate the modules.d file.
275			module_modinfo="$(modinfo -p ${currm_path}.${KV_OBJ})"
276			module_config="${T}/modulesd-${currm}"
277
278	johnm	1.11	ebegin "Preparing file for modules.d"
279	johnm	1.26	#-----------------------------------------------------------------------
280			echo "# modules.d configuration file for ${currm}" >> ${module_config}
281			#-----------------------------------------------------------------------
282			[[ -n ${module_docs} ]] && \
283			echo "# For more information please read:" >> ${module_config}
284			for t in ${module_docs}
285	johnm	1.11	do
286	johnm	1.26	echo "# ${t//*\/}" >> ${module_config}
287	johnm	1.11	done
288	johnm	1.26	echo >> ${module_config}
289	johnm	1.11
290	johnm	1.26	#-----------------------------------------------------------------------
291	johnm	1.27	if [[ ${module_aliases} -gt 0 ]]
292	johnm	1.11	then
293			echo "# Internal Aliases - Do not edit" >> ${module_config}
294			echo "# ------------------------------" >> ${module_config}
295	johnm	1.12
296	johnm	1.26	for((t=0; t<${module_aliases}; t++))
297	johnm	1.11	do
298	johnm	1.26	echo "alias $(eval echo \${MODULESD_${currm}_ALIASES[$t]})" \
299			>> ${module_config}
300	johnm	1.12	done
301	johnm	1.26	echo '' >> ${module_config}
302	johnm	1.11	fi
303
304	johnm	1.26	#-----------------------------------------------------------------------
305			if [[ -n ${module_modinfo} ]]
306	johnm	1.11	then
307			echo >> ${module_config}
308			echo "# Configurable module parameters" >> ${module_config}
309			echo "# ------------------------------" >> ${module_config}
310	johnm	1.26	myIFS="${IFS}"
311	johnm	1.11	IFS="$(echo -en "\n\b")"
312	johnm	1.26
313			for t in ${module_modinfo}
314	johnm	1.11	do
315	johnm	1.26	myVAR="$(echo ${t#:} \| grep -e " [0-9][ =]" \| sed "s:.\([01][= ]\).*:\1:")"
316			if [[ -n ${myVAR} ]]
317	johnm	1.11	then
318	johnm	1.26	module_opts="${module_opts} ${t%%:*}:${myVAR}"
319	johnm	1.11	fi
320	johnm	1.26	echo -e "# ${t%%:}:\t${t#:}" >> ${module_config}
321			done
322			IFS="${myIFS}"
323			echo '' >> ${module_config}
324			fi
325
326			#-----------------------------------------------------------------------
327			if [[ $(eval echo \${MODULESD_${currm}_ALIASES[0]}) == guess ]]
328			then
329			# So lets do some guesswork eh?
330			if [[ -n ${module_opts} ]]
331			then
332			echo "# For Example..." >> ${module_config}
333			echo "# --------------" >> ${module_config}
334			for t in ${module_opts}
335			do
336			echo "# options ${currm} ${t//:}=${t//:}" >> ${module_config}
337			done
338			echo '' >> ${module_config}
339			fi
340	johnm	1.27	elif [[ ${module_examples} -gt 0 ]]
341	johnm	1.26	then
342			echo "# For Example..." >> ${module_config}
343			echo "# --------------" >> ${module_config}
344			for((t=0; t<${module_examples}; t++))
345			do
346			echo "options $(eval echo \${MODULESD_${currm}_EXAMPLES[$t]})" \
347			>> ${module_config}
348	johnm	1.11	done
349	johnm	1.26	echo '' >> ${module_config}
350	johnm	1.11	fi
351	johnm	1.26
352			#-----------------------------------------------------------------------
353	johnm	1.27	if [[ ${module_additions} -gt 0 ]]
354	johnm	1.11	then
355	johnm	1.26	for((t=0; t<${module_additions}; t++))
356	johnm	1.11	do
357	johnm	1.26	echo "$(eval echo \${MODULESD_${currm}_ADDITIONS[$t]})" \
358			>> ${module_config}
359	johnm	1.11	done
360	johnm	1.26	echo '' >> ${module_config}
361	johnm	1.11	fi
362
363	johnm	1.26	#-----------------------------------------------------------------------
364
365	johnm	1.12	# then we install it
366	johnm	1.11	insinto /etc/modules.d
367	johnm	1.27	newins ${module_config} ${currm_path//*\/}
368
369	johnm	1.12	# and install any documentation we might have.
370	johnm	1.26	[[ -n ${module_docs} ]] && dodoc ${module_docs}
371	johnm	1.11	done
372			eend 0
373	johnm	1.26	return 0
374	johnm	1.11	}
375
376	johnm	1.1	display_postinst() {
377			# if we haven't determined the version yet, we need too.
378			get_version;
379
380	johnm	1.10	local modulename moduledir sourcedir moduletemp file i
381	johnm	1.1
382			file=${ROOT}/etc/modules.autoload.d/kernel-${KV_MAJOR}.${KV_MINOR}
383			file=${file/\/\///}
384
385	johnm	1.20	for i in ${MODULE_IGNORE}
386			do
387			MODULE_NAMES=${MODULE_NAMES//${i}(*}
388			done
389
390	johnm	1.22	if [[ -n ${MODULE_NAMES} ]]
391			then
392			einfo "If you would like to load this module automatically upon boot"
393			einfo "please type the following as root:"
394			for i in ${MODULE_NAMES}
395	johnm	1.20	do
396	johnm	1.23	unset libdir srcdir objdir
397	johnm	1.22	for n in $(find_module_params ${i})
398			do
399			eval ${n/:}=${n/:/}
400			done
401			einfo " # echo \"${modulename}\" >> ${file}"
402	johnm	1.20	done
403	johnm	1.22	einfo
404			fi
405	johnm	1.1	}
406
407	johnm	1.18	find_module_params() {
408			local matched_offset=0 matched_opts=0 test="${@}" temp_var result
409			local i=0 y=0 z=0
410
411			for((i=0; i<=${#test}; i++))
412			do
413			case ${test:${i}:1} in
414			\() matched_offset[0]=${i};;
415			\:) matched_opts=$((${matched_opts} + 1));
416			matched_offset[${matched_opts}]="${i}";;
417			\)) matched_opts=$((${matched_opts} + 1));
418			matched_offset[${matched_opts}]="${i}";;
419			esac
420			done
421
422			for((i=0; i<=${matched_opts}; i++))
423			do
424			# i = offset were working on
425			# y = last offset
426			# z = current offset - last offset
427			# temp_var = temporary name
428			case ${i} in
429			0) tempvar=${test:0:${matched_offset[0]}};;
430			*) y=$((${matched_offset[$((${i} - 1))]} + 1))
431			z=$((${matched_offset[${i}]} - ${matched_offset[$((${i} - 1))]}));
432			z=$((${z} - 1))
433			tempvar=${test:${y}:${z}};;
434			esac
435
436			case ${i} in
437			0) result="${result} modulename:${tempvar}";;
438			1) result="${result} libdir:${tempvar}";;
439			2) result="${result} srcdir:${tempvar}";;
440			3) result="${result} objdir:${tempvar}";;
441			esac
442			done
443
444			echo ${result}
445			}
446
447	johnm	1.1	# default ebuild functions
448			# --------------------------------
449
450			linux-mod_pkg_setup() {
451	johnm	1.6	linux-info_pkg_setup;
452			check_kernel_built;
453	johnm	1.1	check_modules_supported;
454			set_kvobj;
455			}
456
457			linux-mod_src_compile() {
458	johnm	1.26	local modulename libdir srcdir objdir i n myARCH="${ARCH}"
459	johnm	1.21	unset ARCH
460	johnm	1.26
461	johnm	1.16	BUILD_TARGETS=${BUILD_TARGETS:-clean module}
462	johnm	1.20
463			for i in ${MODULE_IGNORE}
464			do
465			MODULE_NAMES=${MODULE_NAMES//${i}(*}
466			done
467	johnm	1.1
468	johnm	1.9	for i in ${MODULE_NAMES}
469	johnm	1.1	do
470	johnm	1.23	unset libdir srcdir objdir
471	johnm	1.18	for n in $(find_module_params ${i})
472			do
473			eval ${n/:}=${n/:/}
474			done
475			libdir=${libdir:-misc}
476			srcdir=${srcdir:-${S}}
477			objdir=${objdir:-${srcdir}}
478	johnm	1.10
479	johnm	1.18	if [ ! -f "${srcdir}/.built" ];
480	johnm	1.16	then
481	johnm	1.18	cd ${srcdir}
482	johnm	1.16	einfo "Preparing ${modulename} module"
483	johnm	1.22	if [[ -n ${ECONF_PARAMS} ]]
484			then
485			econf ${ECONF_PARAMS} \|\| \
486			die "Unable to run econf ${ECONF_PARAMS}"
487			fi
488
489	johnm	1.21	emake ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS} \
490	johnm	1.18	\|\| die "Unable to make \
491			${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS}."
492			touch ${srcdir}/.built
493	johnm	1.16	cd ${OLDPWD}
494			fi
495	johnm	1.1	done
496	johnm	1.26
497			ARCH="${myARCH}"
498	johnm	1.1	}
499
500			linux-mod_src_install() {
501	johnm	1.18	local modulename libdir srcdir objdir i n
502	johnm	1.20
503			for i in ${MODULE_IGNORE}
504			do
505			MODULE_NAMES=${MODULE_NAMES//${i}(*}
506			done
507	johnm	1.1
508	johnm	1.9	for i in ${MODULE_NAMES}
509	johnm	1.1	do
510	johnm	1.23	unset libdir srcdir objdir
511	johnm	1.18	for n in $(find_module_params ${i})
512			do
513			eval ${n/:}=${n/:/}
514			done
515			libdir=${libdir:-misc}
516			srcdir=${srcdir:-${S}}
517			objdir=${objdir:-${srcdir}}
518	johnm	1.1
519			einfo "Installing ${modulename} module"
520	johnm	1.18	cd ${objdir}
521	johnm	1.26	insinto ${ROOT}lib/modules/${KV_FULL}/${libdir}
522	johnm	1.1	doins ${modulename}.${KV_OBJ}
523	johnm	1.16	cd ${OLDPWD}
524	johnm	1.11
525	johnm	1.26	generate_modulesd ${objdir}/${modulename}
526	johnm	1.1	done
527			}
528
529			linux-mod_pkg_postinst() {
530			update_depmod;
531	johnm	1.3	update_modules;
532	johnm	1.37	update_moduledb;
533	johnm	1.1	display_postinst;
534			}
535	johnm	1.37
536			linux-mod_pkg_postrm() {
537			remove_moduledb;
538			}