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.45 2005/07/06 20:53:20 agriffis 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
EXPORT_FUNCTIONS pkg_setup pkg_postinst src_install src_compile pkg_postrm

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

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