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.41 2005/07/05 13:34:45 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}
                [[ ! -f ${NEWDIR}/moduledb ]] && \
                        mv ${OLDDIR}/moduledb ${NEWDIR}/moduledb
                rm -f ${OLDDIR}/*
                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.42	# $Header: /var/cvsroot/gentoo-x86/eclass/linux-mod.eclass,v 1.41 2005/07/05 13:34:45 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	johnm	1.42	[[ ! -f ${NEWDIR}/moduledb ]] && \
198			mv ${OLDDIR}/moduledb ${NEWDIR}/moduledb
199			rm -f ${OLDDIR}/*
200	johnm	1.41	rmdir ${OLDDIR}
201			fi
202			}
203
204	johnm	1.37	update_moduledb() {
205	johnm	1.40	local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
206	johnm	1.41	move_old_moduledb
207	johnm	1.40
208			if [[ ! -f ${MODULEDB_DIR}/moduledb ]]; then
209			[[ ! -d ${MODULEDB_DIR} ]] && mkdir -p ${MODULEDB_DIR}
210			touch ${MODULEDB_DIR}/moduledb
211	johnm	1.37	fi
212	johnm	1.40	if [[ -z $(grep ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb) ]]; then
213	johnm	1.37	einfo "Adding module to moduledb."
214	johnm	1.40	echo "a:1:${CATEGORY}/${PN}-${PVR}" >> ${MODULEDB_DIR}/moduledb
215	johnm	1.37	fi
216			}
217
218			remove_moduledb() {
219	johnm	1.40	local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
220	johnm	1.41	move_old_moduledb
221	johnm	1.40
222			if [[ -n $(grep ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb) ]]; then
223	johnm	1.37	einfo "Removing ${CATEGORY}/${PN}-${PVR} from moduledb."
224	johnm	1.40	sed -ie "/.${CATEGORY}\/${P}./d" ${MODULEDB_DIR}/moduledb
225	johnm	1.37	fi
226			}
227
228	johnm	1.1	set_kvobj() {
229			if kernel_is 2 6
230			then
231			KV_OBJ="ko"
232			else
233			KV_OBJ="o"
234			fi
235	johnm	1.26	# Do we really need to know this?
236			# Lets silence it.
237			# einfo "Using KV_OBJ=${KV_OBJ}"
238	johnm	1.1	}
239
240	johnm	1.11	generate_modulesd() {
241			# This function will generate the neccessary modules.d file from the
242			# information contained in the modules exported parms
243	johnm	1.26
244			local currm_path currm t myIFS myVAR
245			local module_docs module_enabled module_aliases \
246			module_additions module_examples module_modinfo module_opts
247
248			for currm_path in ${@}
249	johnm	1.11	do
250	johnm	1.26	currm=${currm_path//*\/}
251			currm=$(echo ${currm} \| tr '[:lower:]' '[:upper:]')
252
253			module_docs="$(eval echo \${MODULESD_${currm}_DOCS})"
254			module_enabled="$(eval echo \${MODULESD_${currm}_ENABLED})"
255	johnm	1.30	module_aliases="$(eval echo \${#MODULESD_${currm/-/_}_ALIASES[*]})"
256			module_additions="$(eval echo \${#MODULESD_${currm/-/_}_ADDITIONS[*]})"
257			module_examples="$(eval echo \${#MODULESD_${currm/-/_}_EXAMPLES[*]})"
258	johnm	1.26
259	johnm	1.27	[[ ${module_aliases} -eq 0 ]] && unset module_aliases
260			[[ ${module_additions} -eq 0 ]] && unset module_additions
261			[[ ${module_examples} -eq 0 ]] && unset module_examples
262	johnm	1.26
263			# If we specify we dont want it, then lets exit, otherwise we assume
264			# that if its set, we do want it.
265			[[ ${module_enabled} == no ]] && return 0
266
267			# unset any unwanted variables.
268			for t in ${!module_*}
269	johnm	1.11	do
270	johnm	1.26	[[ -z ${!t} ]] && unset ${t}
271	johnm	1.11	done
272
273	johnm	1.26	[[ -z ${!module_*} ]] && return 0
274
275			# OK so now if we have got this far, then we know we want to continue
276			# and generate the modules.d file.
277			module_modinfo="$(modinfo -p ${currm_path}.${KV_OBJ})"
278			module_config="${T}/modulesd-${currm}"
279
280	johnm	1.11	ebegin "Preparing file for modules.d"
281	johnm	1.26	#-----------------------------------------------------------------------
282			echo "# modules.d configuration file for ${currm}" >> ${module_config}
283			#-----------------------------------------------------------------------
284			[[ -n ${module_docs} ]] && \
285			echo "# For more information please read:" >> ${module_config}
286			for t in ${module_docs}
287	johnm	1.11	do
288	johnm	1.26	echo "# ${t//*\/}" >> ${module_config}
289	johnm	1.11	done
290	johnm	1.26	echo >> ${module_config}
291	johnm	1.11
292	johnm	1.26	#-----------------------------------------------------------------------
293	johnm	1.27	if [[ ${module_aliases} -gt 0 ]]
294	johnm	1.11	then
295			echo "# Internal Aliases - Do not edit" >> ${module_config}
296			echo "# ------------------------------" >> ${module_config}
297	johnm	1.12
298	johnm	1.26	for((t=0; t<${module_aliases}; t++))
299	johnm	1.11	do
300	johnm	1.26	echo "alias $(eval echo \${MODULESD_${currm}_ALIASES[$t]})" \
301			>> ${module_config}
302	johnm	1.12	done
303	johnm	1.26	echo '' >> ${module_config}
304	johnm	1.11	fi
305
306	johnm	1.26	#-----------------------------------------------------------------------
307			if [[ -n ${module_modinfo} ]]
308	johnm	1.11	then
309			echo >> ${module_config}
310			echo "# Configurable module parameters" >> ${module_config}
311			echo "# ------------------------------" >> ${module_config}
312	johnm	1.26	myIFS="${IFS}"
313	johnm	1.11	IFS="$(echo -en "\n\b")"
314	johnm	1.26
315			for t in ${module_modinfo}
316	johnm	1.11	do
317	johnm	1.26	myVAR="$(echo ${t#:} \| grep -e " [0-9][ =]" \| sed "s:.\([01][= ]\).*:\1:")"
318			if [[ -n ${myVAR} ]]
319	johnm	1.11	then
320	johnm	1.26	module_opts="${module_opts} ${t%%:*}:${myVAR}"
321	johnm	1.11	fi
322	johnm	1.26	echo -e "# ${t%%:}:\t${t#:}" >> ${module_config}
323			done
324			IFS="${myIFS}"
325			echo '' >> ${module_config}
326			fi
327
328			#-----------------------------------------------------------------------
329			if [[ $(eval echo \${MODULESD_${currm}_ALIASES[0]}) == guess ]]
330			then
331			# So lets do some guesswork eh?
332			if [[ -n ${module_opts} ]]
333			then
334			echo "# For Example..." >> ${module_config}
335			echo "# --------------" >> ${module_config}
336			for t in ${module_opts}
337			do
338			echo "# options ${currm} ${t//:}=${t//:}" >> ${module_config}
339			done
340			echo '' >> ${module_config}
341			fi
342	johnm	1.27	elif [[ ${module_examples} -gt 0 ]]
343	johnm	1.26	then
344			echo "# For Example..." >> ${module_config}
345			echo "# --------------" >> ${module_config}
346			for((t=0; t<${module_examples}; t++))
347			do
348			echo "options $(eval echo \${MODULESD_${currm}_EXAMPLES[$t]})" \
349			>> ${module_config}
350	johnm	1.11	done
351	johnm	1.26	echo '' >> ${module_config}
352	johnm	1.11	fi
353	johnm	1.26
354			#-----------------------------------------------------------------------
355	johnm	1.27	if [[ ${module_additions} -gt 0 ]]
356	johnm	1.11	then
357	johnm	1.26	for((t=0; t<${module_additions}; t++))
358	johnm	1.11	do
359	johnm	1.26	echo "$(eval echo \${MODULESD_${currm}_ADDITIONS[$t]})" \
360			>> ${module_config}
361	johnm	1.11	done
362	johnm	1.26	echo '' >> ${module_config}
363	johnm	1.11	fi
364
365	johnm	1.26	#-----------------------------------------------------------------------
366
367	johnm	1.12	# then we install it
368	johnm	1.11	insinto /etc/modules.d
369	johnm	1.27	newins ${module_config} ${currm_path//*\/}
370
371	johnm	1.12	# and install any documentation we might have.
372	johnm	1.26	[[ -n ${module_docs} ]] && dodoc ${module_docs}
373	johnm	1.11	done
374			eend 0
375	johnm	1.26	return 0
376	johnm	1.11	}
377
378	johnm	1.1	display_postinst() {
379			# if we haven't determined the version yet, we need too.
380			get_version;
381
382	johnm	1.10	local modulename moduledir sourcedir moduletemp file i
383	johnm	1.1
384			file=${ROOT}/etc/modules.autoload.d/kernel-${KV_MAJOR}.${KV_MINOR}
385			file=${file/\/\///}
386
387	johnm	1.20	for i in ${MODULE_IGNORE}
388			do
389			MODULE_NAMES=${MODULE_NAMES//${i}(*}
390			done
391
392	johnm	1.22	if [[ -n ${MODULE_NAMES} ]]
393			then
394			einfo "If you would like to load this module automatically upon boot"
395			einfo "please type the following as root:"
396			for i in ${MODULE_NAMES}
397	johnm	1.20	do
398	johnm	1.23	unset libdir srcdir objdir
399	johnm	1.22	for n in $(find_module_params ${i})
400			do
401			eval ${n/:}=${n/:/}
402			done
403			einfo " # echo \"${modulename}\" >> ${file}"
404	johnm	1.20	done
405	johnm	1.22	einfo
406			fi
407	johnm	1.1	}
408
409	johnm	1.18	find_module_params() {
410			local matched_offset=0 matched_opts=0 test="${@}" temp_var result
411			local i=0 y=0 z=0
412
413			for((i=0; i<=${#test}; i++))
414			do
415			case ${test:${i}:1} in
416			\() matched_offset[0]=${i};;
417			\:) matched_opts=$((${matched_opts} + 1));
418			matched_offset[${matched_opts}]="${i}";;
419			\)) matched_opts=$((${matched_opts} + 1));
420			matched_offset[${matched_opts}]="${i}";;
421			esac
422			done
423
424			for((i=0; i<=${matched_opts}; i++))
425			do
426			# i = offset were working on
427			# y = last offset
428			# z = current offset - last offset
429			# temp_var = temporary name
430			case ${i} in
431			0) tempvar=${test:0:${matched_offset[0]}};;
432			*) y=$((${matched_offset[$((${i} - 1))]} + 1))
433			z=$((${matched_offset[${i}]} - ${matched_offset[$((${i} - 1))]}));
434			z=$((${z} - 1))
435			tempvar=${test:${y}:${z}};;
436			esac
437
438			case ${i} in
439			0) result="${result} modulename:${tempvar}";;
440			1) result="${result} libdir:${tempvar}";;
441			2) result="${result} srcdir:${tempvar}";;
442			3) result="${result} objdir:${tempvar}";;
443			esac
444			done
445
446			echo ${result}
447			}
448
449	johnm	1.1	# default ebuild functions
450			# --------------------------------
451
452			linux-mod_pkg_setup() {
453	johnm	1.6	linux-info_pkg_setup;
454			check_kernel_built;
455	johnm	1.1	check_modules_supported;
456			set_kvobj;
457			}
458
459			linux-mod_src_compile() {
460	johnm	1.26	local modulename libdir srcdir objdir i n myARCH="${ARCH}"
461	johnm	1.21	unset ARCH
462	johnm	1.26
463	johnm	1.16	BUILD_TARGETS=${BUILD_TARGETS:-clean module}
464	johnm	1.20
465			for i in ${MODULE_IGNORE}
466			do
467			MODULE_NAMES=${MODULE_NAMES//${i}(*}
468			done
469	johnm	1.1
470	johnm	1.9	for i in ${MODULE_NAMES}
471	johnm	1.1	do
472	johnm	1.23	unset libdir srcdir objdir
473	johnm	1.18	for n in $(find_module_params ${i})
474			do
475			eval ${n/:}=${n/:/}
476			done
477			libdir=${libdir:-misc}
478			srcdir=${srcdir:-${S}}
479			objdir=${objdir:-${srcdir}}
480	johnm	1.10
481	johnm	1.18	if [ ! -f "${srcdir}/.built" ];
482	johnm	1.16	then
483	johnm	1.18	cd ${srcdir}
484	johnm	1.16	einfo "Preparing ${modulename} module"
485	johnm	1.22	if [[ -n ${ECONF_PARAMS} ]]
486			then
487			econf ${ECONF_PARAMS} \|\| \
488			die "Unable to run econf ${ECONF_PARAMS}"
489			fi
490
491	johnm	1.21	emake ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS} \
492	johnm	1.18	\|\| die "Unable to make \
493			${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS}."
494			touch ${srcdir}/.built
495	johnm	1.16	cd ${OLDPWD}
496			fi
497	johnm	1.1	done
498	johnm	1.26
499			ARCH="${myARCH}"
500	johnm	1.1	}
501
502			linux-mod_src_install() {
503	johnm	1.18	local modulename libdir srcdir objdir i n
504	johnm	1.20
505			for i in ${MODULE_IGNORE}
506			do
507			MODULE_NAMES=${MODULE_NAMES//${i}(*}
508			done
509	johnm	1.1
510	johnm	1.9	for i in ${MODULE_NAMES}
511	johnm	1.1	do
512	johnm	1.23	unset libdir srcdir objdir
513	johnm	1.18	for n in $(find_module_params ${i})
514			do
515			eval ${n/:}=${n/:/}
516			done
517			libdir=${libdir:-misc}
518			srcdir=${srcdir:-${S}}
519			objdir=${objdir:-${srcdir}}
520	johnm	1.1
521			einfo "Installing ${modulename} module"
522	johnm	1.18	cd ${objdir}
523	johnm	1.26	insinto ${ROOT}lib/modules/${KV_FULL}/${libdir}
524	johnm	1.1	doins ${modulename}.${KV_OBJ}
525	johnm	1.16	cd ${OLDPWD}
526	johnm	1.11
527	johnm	1.26	generate_modulesd ${objdir}/${modulename}
528	johnm	1.1	done
529			}
530
531			linux-mod_pkg_postinst() {
532			update_depmod;
533	johnm	1.3	update_modules;
534	johnm	1.37	update_moduledb;
535	johnm	1.1	display_postinst;
536			}
537	johnm	1.37
538			linux-mod_pkg_postrm() {
539			remove_moduledb;
540			}