Updated ioctl32 patch to one provided by upstream.

5 files changed, 1197 insertions, 11 deletions

diff --git a/media-sound/alsa-driver/ChangeLog b/media-sound/alsa-driver/ChangeLog
index 77f5c8bbaf57..71eab3bcfc73 100644
--- a/media-sound/alsa-driver/ChangeLog
+++ b/media-sound/alsa-driver/ChangeLog
@@ -1,6 +1,12 @@
 # ChangeLog for media-sound/alsa-driver
 # Copyright 2002-2004 Gentoo Foundation; Distributed under the GPL v2
-# $Header: /var/cvsroot/gentoo-x86/media-sound/alsa-driver/ChangeLog,v 1.106 2004/11/22 21:45:00 eradicator Exp $
+# $Header: /var/cvsroot/gentoo-x86/media-sound/alsa-driver/ChangeLog,v 1.107 2004/11/24 11:35:00 eradicator Exp $
+
+*alsa-driver-1.0.7-r1 (24 Nov 2004)
+
+  24 Nov 2004; Jeremy Huddleston <eradicator@gentoo.org>
+  +files/alsa-driver-1.0.7-ioctl32.patch-r1, +alsa-driver-1.0.7-r1.ebuild:
+  Updated ioctl32 patch to one provided by upstream.
 
   22 Nov 2004; Jeremy Huddleston <eradicator@gentoo.org>
   alsa-driver-1.0.7.ebuild:
diff --git a/media-sound/alsa-driver/Manifest b/media-sound/alsa-driver/Manifest
index 631bd033c43f..ecfdbaa495f9 100644
--- a/media-sound/alsa-driver/Manifest
+++ b/media-sound/alsa-driver/Manifest
@@ -1,7 +1,5 @@
------BEGIN PGP SIGNED MESSAGE-----
-Hash: SHA1
-
 MD5 db63e6561580892059b9597f978dcc53 alsa-driver-1.0.7.ebuild 4098
+MD5 9c4832d5710b14a99fb9ee3fa84ab1f1 alsa-driver-1.0.7-r1.ebuild 4101
 MD5 d388a1b0706024ddccccc99045b976f9 alsa-driver-0.9.8.ebuild 2341
 MD5 e5de43659b629d1e9f0ee8d3f1864840 alsa-driver-1.0.3.ebuild 3363
 MD5 04b323d60085d3b338bc1ebff419f222 ChangeLog 17970
@@ -14,6 +12,8 @@ MD5 8c120f7730b91118d0a8148d2deb3a43 files/alsa-driver-0.9.8-au-fix.patch 1267
 MD5 1d70561326ef89e94179634d92782610 files/alsa-driver-1.0.4-devfix.patch 2756
 MD5 08af7cfec9cd33819c62880d6219f3a5 files/alsa-driver-1.0.5-devfix.patch 763
 MD5 034733ce45d34c261a5c9bb74679f77a files/alsa-driver-1.0.7-ioctl32.patch 8684
+MD5 f452ac25eee838c3aba484dfd6055596 files/alsa-driver-1.0.7-ioctl32.patch-r1 31053
+MD5 479ee887025f4ce7944adee1e4a6fdf3 files/digest-alsa-driver-1.0.7-r1 71
 MD5 439dab13c036317c9b308b234ecf7290 files/digest-alsa-driver-0.9.8 71
 MD5 e1b13905eac70fe728dcb85fcaac27a9 files/digest-alsa-driver-1.0.6a 72
 MD5 938a2ee36c54416322d1acd47b249c99 files/digest-alsa-driver-1.0.3 71
@@ -23,10 +23,3 @@ MD5 27ccbe36406f145c1d63725a53517233 files/makefile.patch 1122
 MD5 deb0bfd8e2cfe0ba434fb5a820294502 files/digest-alsa-driver-1.0.5a 72
 MD5 a2ee6fa920bbac70835b4a58e5759e8c files/alsa-driver-1.0.5a-cs46xx-passthrough.patch 446
 MD5 8bb31a005a1db2e306c51d017fd44e70 files/alsa-driver-1.0.5a-xbox-ac97.patch 721
------BEGIN PGP SIGNATURE-----
-Version: GnuPG v1.2.6 (GNU/Linux)
-
-iD8DBQFBol3nArHZZzCEUG0RAlrDAJ9NwM6FYrmntiPvsWe8dGWyMy0e1gCeLAJw
-nvYLUdYUJDWNks9ZbfHHmgg=
-=ZiyK
------END PGP SIGNATURE-----
diff --git a/media-sound/alsa-driver/alsa-driver-1.0.7-r1.ebuild b/media-sound/alsa-driver/alsa-driver-1.0.7-r1.ebuild
new file mode 100644
index 000000000000..465439219a40
--- /dev/null
+++ b/media-sound/alsa-driver/alsa-driver-1.0.7-r1.ebuild
@@ -0,0 +1,157 @@
+# Copyright 1999-2004 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/media-sound/alsa-driver/alsa-driver-1.0.7-r1.ebuild,v 1.1 2004/11/24 11:35:00 eradicator Exp $
+
+IUSE="oss doc"
+
+inherit kernel-mod flag-o-matic eutils
+
+MY_P=${P/_rc/rc}
+S=${WORKDIR}/${MY_P}
+
+DESCRIPTION="Advanced Linux Sound Architecture kernel modules"
+HOMEPAGE="http://www.alsa-project.org/"
+SRC_URI="mirror://alsaproject/driver/${P}.tar.bz2"
+
+LICENSE="GPL-2 LGPL-2.1"
+SLOT="${KV}"
+#KEYWORDS="~alpha ~amd64 ~ia64 ~mips ~ppc ~sparc ~x86"
+
+#alsa-driver-1.0.7-r1 only has ioctl32 updates over 1.0.7
+KEYWORDS="~amd64 ~mips ~sparc"
+
+RDEPEND="virtual/modutils
+	 ~media-sound/alsa-headers-${PV}"
+
+DEPEND="${RDEPEND}
+	sys-devel/patch
+	virtual/linux-sources
+	>=sys-devel/autoconf-2.50
+	sys-apps/debianutils"
+
+PROVIDE="virtual/alsa"
+
+# By default, drivers for all supported cards will be compiled.
+# If you want to only compile for specific card(s), set ALSA_CARDS
+# environment to a space-separated list of drivers that you want to build.
+# For example:
+#
+#   env ALSA_CARDS='emu10k1 intel8x0 ens1370' emerge alsa-driver
+#
+[ -z "${ALSA_CARDS}" ] && ALSA_CARDS=all
+
+src_unpack() {
+	unpack ${A}
+
+	cd ${S}
+	epatch ${FILESDIR}/${PN}-1.0.5-devfix.patch
+	epatch ${FILESDIR}/${PN}-1.0.5a-cs46xx-passthrough.patch
+
+	if [ "${PROFILE_ARCH}" == "xbox" ]; then
+		epatch ${FILESDIR}/${PN}-1.0.5a-xbox-ac97.patch
+	fi
+
+	if kernel-mod_is_2_5_kernel || (kernel-mod_is_2_6_kernel && [ ${KV_PATCH} -lt 6 ]); then
+		FULL_KERNEL_PATH="${ROOT}/usr/src/${KV_DIR}"
+
+		if ! [ -d "${FULL_KERNEL_PATH}" ]; then
+			eerror "An error seems to have occurred.  We looked in ${FULL_KERNEL_PATH} for your kernel sources, but we didn't see them."
+			die "ALSA driver configuration failure."
+		fi
+
+		einfo "A 2.5 or 2.6 kernel was detected.  We are copying the kernel source tree from"
+		einfo "${FULL_KERNEL_PATH} to ${T}/linux"
+		einfo "because the alsa-driver build process overwrites files in the 2.6.x kernel tree."
+
+		# Copy everything over to our tmp dir...
+		cp -a ${FULL_KERNEL_PATH} ${T}/linux
+	else
+		# SUBDIRS -> M
+		epatch ${FILESDIR}/${PN}-1.0.6a-kbuild.patch
+	fi
+
+	# Fix ioctl32 support
+	epatch ${FILESDIR}/${P}-ioctl32.patch-r1
+
+	# Fix order of configure operations so the kernel compiler isn't used
+	# for tests.
+	epatch ${FILESDIR}/${PN}-1.0.7-configure.patch
+	export WANT_AUTOCONF=2.5
+	autoconf
+}
+
+src_compile() {
+	# Default ARCH & kernel path to set in compilation and make
+	KER_DIR=${KERNEL_DIR}
+
+	# If we're using a 2.5 or 2.6 kernel, use our copied kernel tree.
+	if [ -d "${T}/linux" ]; then
+		KER_DIR="${T}/linux"
+	fi
+
+	econf `use_with oss` \
+		--with-kernel="${KER_DIR}" \
+		--with-isapnp=yes \
+		--with-sequencer=yes \
+		--with-cards="${ALSA_CARDS}" || die "econf failed"
+
+	# Should fix bug #46901
+	is-flag "-malign-double" && filter-flags "-fomit-frame-pointer"
+
+	unset ARCH
+	# -j1 : see bug #71028
+	emake -j1 || die "Parallel Make Failed"
+
+	if use doc; then
+		cd ${S}/scripts
+		emake || die
+
+		cd ${S}/doc/DocBook
+		emake || die
+	fi
+}
+
+
+src_install() {
+	dodir /usr/include/sound
+	make DESTDIR=${D} install || die
+
+	# Provided by alsa-headers now
+	rm -rf ${D}/usr/include/sound
+
+	# We have our own scripts in alsa-utils
+	test -e ${D}/etc/init.d/alsasound && rm ${D}/etc/init.d/alsasound
+	test -e ${D}/etc/rc.d/init.d/alsasound && rm ${D}/etc/rc.d/init.d/alsasound
+
+	dodoc CARDS-STATUS INSTALL FAQ README WARNING TODO
+
+	if use doc; then
+		docinto doc
+		dodoc doc/*
+		rm ${D}/usr/share/doc/${PF}/doc/Makefile.gz
+
+		docinto DocBook
+		dodoc doc/DocBook/*
+		rm ${D}/usr/share/doc/${PF}/DocBook/Makefile.gz
+
+		docinto Documentation
+		dodoc sound/Documentation/*
+	fi
+}
+
+pkg_postinst() {
+	if [ "${ROOT}" = / ]
+	then
+		[ -x /usr/sbin/update-modules ] && /usr/sbin/update-modules
+	fi
+
+	einfo
+	einfo "The alsasound initscript and modules.d/alsa have now moved to alsa-utils"
+	einfo
+	einfo "Also, remember that all mixer channels will be MUTED by default."
+	einfo "Use the 'alsamixer' program to unmute them."
+	einfo
+	einfo "Version 1.0.3 and above should work with version 2.6 kernels."
+	einfo "If you experience problems, please report bugs to http://bugs.gentoo.org."
+	einfo
+}
diff --git a/media-sound/alsa-driver/files/alsa-driver-1.0.7-ioctl32.patch-r1 b/media-sound/alsa-driver/files/alsa-driver-1.0.7-ioctl32.patch-r1
new file mode 100644
index 000000000000..95e9123a0824
--- /dev/null
+++ b/media-sound/alsa-driver/files/alsa-driver-1.0.7-ioctl32.patch-r1
@@ -0,0 +1,1029 @@
+Index: alsa-kernel/core/ioctl32/hwdep32.c
+===================================================================
+RCS file: /suse/tiwai/cvs/alsa/alsa-kernel/core/ioctl32/hwdep32.c,v
+retrieving revision 1.10
+diff -u -r1.10 hwdep32.c
+--- alsa-kernel/core/ioctl32/hwdep32.c	18 Oct 2004 14:31:33 -0000	1.10
++++ alsa-kernel/core/ioctl32/hwdep32.c	23 Nov 2004 14:22:41 -0000
+@@ -36,24 +36,24 @@
+ 
+ static inline int _snd_ioctl32_hwdep_dsp_image(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
+ {
+-	struct sndrv_hwdep_dsp_image data;
+-	struct sndrv_hwdep_dsp_image32 data32;
+-	mm_segment_t oldseg;
+-	int err;
++	struct sndrv_hwdep_dsp_image __user *data, *dst;
++	struct sndrv_hwdep_dsp_image32 __user *data32, *src;
++	compat_caddr_t ptr;
+ 
+-	if (copy_from_user(&data32, (void __user *)arg, sizeof(data32)))
++	data32 = compat_ptr(arg);
++	data = compat_alloc_user_space(sizeof(*data));
++
++	/* index and name */
++	if (copy_in_user(data, data32, 4 + 64))
++		return -EFAULT;
++	if (__get_user(ptr, &data32->image) ||
++	    __put_user(compat_ptr(ptr), &data->image))
+ 		return -EFAULT;
+-	memset(&data, 0, sizeof(data));
+-	data.index = data32.index;
+-	memcpy(data.name, data32.name, sizeof(data.name));
+-	data.image = compat_ptr(data32.image);
+-	data.length = data32.length;
+-	data.driver_data = data32.driver_data;
+-	oldseg = get_fs();
+-	set_fs(KERNEL_DS);
+-	err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)&data);
+-	set_fs(oldseg);
+-	return err;
++	src = data32;
++	dst = data;
++	COPY_CVT(length);
++	COPY_CVT(driver_data);
++	return file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)data);
+ }
+ 
+ DEFINE_ALSA_IOCTL_ENTRY(hwdep_dsp_image, hwdep_dsp_image, SNDRV_HWDEP_IOCTL_DSP_LOAD);
+Index: alsa-kernel/core/ioctl32/ioctl32.c
+===================================================================
+RCS file: /suse/tiwai/cvs/alsa/alsa-kernel/core/ioctl32/ioctl32.c,v
+retrieving revision 1.27
+diff -u -r1.27 ioctl32.c
+--- alsa-kernel/core/ioctl32/ioctl32.c	18 Oct 2004 14:31:33 -0000	1.27
++++ alsa-kernel/core/ioctl32/ioctl32.c	23 Nov 2004 14:13:47 -0000
+@@ -93,43 +93,28 @@
+ 	unsigned char reserved[50];
+ } /* don't set packed attribute here */;
+ 
+-#define CVT_sndrv_ctl_elem_list()\
+-{\
+-	COPY(offset);\
+-	COPY(space);\
+-	COPY(used);\
+-	COPY(count);\
+-	CPTR(pids);\
+-}
+-
+ static inline int _snd_ioctl32_ctl_elem_list(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
+ {
+-	struct sndrv_ctl_elem_list32 data32;
+-	struct sndrv_ctl_elem_list data;
+-	mm_segment_t oldseg;
++	struct sndrv_ctl_elem_list32 __user *data32;
++	struct sndrv_ctl_elem_list __user *data;
++	compat_caddr_t ptr;
+ 	int err;
+ 
+-	if (copy_from_user(&data32, (void __user *)arg, sizeof(data32)))
++	data32 = compat_ptr(arg);
++	data = compat_alloc_user_space(sizeof(*data));
++
++	/* offset, space, used, count */
++	if (copy_in_user(data, data32, 4 * 4))
+ 		return -EFAULT;
+-	memset(&data, 0, sizeof(data));
+-	data.offset = data32.offset;
+-	data.space = data32.space;
+-	data.used = data32.used;
+-	data.count = data32.count;
+-	data.pids = compat_ptr(data32.pids);
+-	oldseg = get_fs();
+-	set_fs(KERNEL_DS);
+-	err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)&data);
+-	set_fs(oldseg);
++	/* pids */
++	if (__get_user(ptr, &data32->pids) ||
++	    __put_user(compat_ptr(ptr), &data->pids))
++		return -EFAULT;
++	err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)data);
+ 	if (err < 0)
+ 		return err;
+ 	/* copy the result */
+-	data32.offset = data.offset;
+-	data32.space = data.space;
+-	data32.used = data.used;
+-	data32.count = data.count;
+-	//data.pids = data.pids;
+-	if (copy_to_user((void __user *)arg, &data32, sizeof(data32)))
++	if (copy_in_user(data32, data, 4 * 4))
+ 		return -EFAULT;
+ 	return 0;
+ }
+@@ -170,54 +155,57 @@
+ 
+ static inline int _snd_ioctl32_ctl_elem_info(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
+ {
+-	struct sndrv_ctl_elem_info data;
+-	struct sndrv_ctl_elem_info32 data32;
++	struct sndrv_ctl_elem_info __user *data, *src;
++	struct sndrv_ctl_elem_info32 __user *data32, *dst;
++	unsigned int type;
+ 	int err;
+-	mm_segment_t oldseg;
+ 
+-	if (copy_from_user(&data32, (void __user *)arg, sizeof(data32)))
++	data32 = compat_ptr(arg);
++	data = compat_alloc_user_space(sizeof(*data));
++
++	/* copy id */
++	if (copy_in_user(&data->id, &data32->id, sizeof(data->id)))
+ 		return -EFAULT;
+-	memset(&data, 0, sizeof(data));
+-	data.id = data32.id;
+ 	/* we need to copy the item index.
+ 	 * hope this doesn't break anything..
+ 	 */
+-	data.value.enumerated.item = data32.value.enumerated.item;
+-	oldseg = get_fs();
+-	set_fs(KERNEL_DS);
+-	err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)&data);
+-	set_fs(oldseg);
++	if (__copy_in_user(&data->value.enumerated.item,
++			   &data32->value.enumerated.item, 4))
++		return -EFAULT;
++	err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)data);
+ 	if (err < 0)
+ 		return err;
+ 	/* restore info to 32bit */
+-	data32.id = data.id;
+-	data32.type = data.type;
+-	data32.access = data.access;
+-	data32.count = data.count;
+-	data32.owner = data.owner;
+-	switch (data.type) {
++	/* id, type, access, count */
++	if (copy_in_user(data32, data, 4 * 4))
++		return -EFAULT;
++	/* for COPY_CVT macro */
++	src = data;
++	dst = data32;
++	COPY_CVT(owner);
++	__get_user(type, &data->type);
++	switch (type) {
+ 	case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
+ 	case SNDRV_CTL_ELEM_TYPE_INTEGER:
+-		data32.value.integer.min = data.value.integer.min;
+-		data32.value.integer.max = data.value.integer.max;
+-		data32.value.integer.step = data.value.integer.step;
++		COPY_CVT(value.integer.min);
++		COPY_CVT(value.integer.max);
++		COPY_CVT(value.integer.step);
+ 		break;
+ 	case SNDRV_CTL_ELEM_TYPE_INTEGER64:
+-		data32.value.integer64.min = data.value.integer64.min;
+-		data32.value.integer64.max = data.value.integer64.max;
+-		data32.value.integer64.step = data.value.integer64.step;
++		if (__copy_in_user(&data32->value.integer64,
++				   &data->value.integer64,
++				   sizeof(data->value.integer64)))
++			return -EFAULT;
+ 		break;
+ 	case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
+-		data32.value.enumerated.items = data.value.enumerated.items;
+-		data32.value.enumerated.item = data.value.enumerated.item;
+-		memcpy(data32.value.enumerated.name, data.value.enumerated.name,
+-		       sizeof(data.value.enumerated.name));
++		if (__copy_in_user(&data32->value.enumerated,
++				   &data->value.enumerated,
++				   sizeof(data->value.enumerated)))
++			return -EFAULT;
+ 		break;
+ 	default:
+ 		break;
+ 	}
+-	if (copy_to_user((void __user *)arg, &data32, sizeof(data32)))
+-		return -EFAULT;
+ 	return 0;
+ }
+ 
+@@ -277,60 +265,85 @@
+ static inline int _snd_ioctl32_ctl_elem_value(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
+ {
+ 	struct sndrv_ctl_elem_value *data;
+-	struct sndrv_ctl_elem_value32 *data32;
++	struct sndrv_ctl_elem_value32 __user *data32;
++	mm_segment_t oldseg;
+ 	int err, i;
+ 	int type;
+-	mm_segment_t oldseg;
+ 
+ 	/* FIXME: check the sane ioctl.. */
+ 
++	data32 = compat_ptr(arg);
+ 	data = kmalloc(sizeof(*data), GFP_KERNEL);
+-	data32 = kmalloc(sizeof(*data32), GFP_KERNEL);
+-	if (data == NULL || data32 == NULL) {
+-		err = -ENOMEM;
++	if (data == NULL)
++		return -ENOMEM;
++
++	if (copy_from_user(&data->id, &data32->id, 4)) {
++		err = -EFAULT;
+ 		goto __end;
+ 	}
+-
+-	if (copy_from_user(data32, (void __user *)arg, sizeof(*data32))) {
++	if (__get_user(data->indirect, &data32->indirect)) {
+ 		err = -EFAULT;
+ 		goto __end;
+ 	}
+-	memset(data, 0, sizeof(*data));
+-	data->id = data32->id;
+-	data->indirect = data32->indirect;
+-	if (data->indirect) /* FIXME: this is not correct for long arrays */
+-		data->value.integer.value_ptr = compat_ptr(data32->value.integer.value_ptr);
++	/* FIXME: indirect access is not supported */
++	if (data->indirect) {
++		err = -EINVAL;
++		goto __end;
++	}
+ 	type = get_ctl_type(file, &data->id);
+ 	if (type < 0) {
+ 		err = type;
+ 		goto __end;
+ 	}
+-	if (! data->indirect) {
+-		switch (type) {
+-		case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
+-		case SNDRV_CTL_ELEM_TYPE_INTEGER:
+-			for (i = 0; i < 128; i++)
+-				data->value.integer.value[i] = data32->value.integer.value[i];
+-			break;
+-		case SNDRV_CTL_ELEM_TYPE_INTEGER64:
+-			for (i = 0; i < 64; i++)
+-				data->value.integer64.value[i] = data32->value.integer64.value[i];
+-			break;
+-		case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
+-			for (i = 0; i < 128; i++)
+-				data->value.enumerated.item[i] = data32->value.enumerated.item[i];
+-			break;
+-		case SNDRV_CTL_ELEM_TYPE_BYTES:
+-			memcpy(data->value.bytes.data, data32->value.bytes.data,
+-			       sizeof(data->value.bytes.data));
+-			break;
+-		case SNDRV_CTL_ELEM_TYPE_IEC958:
+-			data->value.iec958 = data32->value.iec958;
+-			break;
+-		default:
+-			printk("unknown type %d\n", type);
+-			break;
++
++	switch (type) {
++	case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
++	case SNDRV_CTL_ELEM_TYPE_INTEGER:
++		for (i = 0; i < 128; i++) {
++			int val;
++			if (__get_user(val, &data32->value.integer.value[i])) {
++				err = -EFAULT;
++				goto __end;
++			}
++			data->value.integer.value[i] = val;
+ 		}
++		break;
++	case SNDRV_CTL_ELEM_TYPE_INTEGER64:
++		if (__copy_from_user(data->value.integer64.value,
++				     data32->value.integer64.value,
++				     sizeof(data->value.integer64.value))) {
++			err = -EFAULT;
++			goto __end;
++		}
++		break;
++	case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
++		if (__copy_from_user(data->value.enumerated.item,
++				     data32->value.enumerated.item,
++				     sizeof(data32->value.enumerated.item))) {
++			err = -EFAULT;
++			goto __end;
++		}
++		break;
++	case SNDRV_CTL_ELEM_TYPE_BYTES:
++		if (__copy_from_user(data->value.bytes.data,
++				     data32->value.bytes.data,
++				     sizeof(data32->value.bytes.data))) {
++			err = -EFAULT;
++			goto __end;
++		}
++		break;
++	case SNDRV_CTL_ELEM_TYPE_IEC958:
++		if (__copy_from_user(&data->value.iec958,
++				     &data32->value.iec958,
++				     sizeof(data32->value.iec958))) {
++			err = -EFAULT;
++			goto __end;
++		}
++		break;
++	default:
++		printk(KERN_ERR "snd_ioctl32_ctl_elem_value: unknown type %d\n", type);
++		err = -EINVAL;
++		goto __end;
+ 	}
+ 
+ 	oldseg = get_fs();
+@@ -340,38 +353,53 @@
+ 	if (err < 0)
+ 		goto __end;
+ 	/* restore info to 32bit */
+-	if (! data->indirect) {
+-		switch (type) {
+-		case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
+-		case SNDRV_CTL_ELEM_TYPE_INTEGER:
+-			for (i = 0; i < 128; i++)
+-				data32->value.integer.value[i] = data->value.integer.value[i];
+-			break;
+-		case SNDRV_CTL_ELEM_TYPE_INTEGER64:
+-			for (i = 0; i < 64; i++)
+-				data32->value.integer64.value[i] = data->value.integer64.value[i];
+-			break;
+-		case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
+-			for (i = 0; i < 128; i++)
+-				data32->value.enumerated.item[i] = data->value.enumerated.item[i];
+-			break;
+-		case SNDRV_CTL_ELEM_TYPE_BYTES:
+-			memcpy(data32->value.bytes.data, data->value.bytes.data,
+-			       sizeof(data->value.bytes.data));
+-			break;
+-		case SNDRV_CTL_ELEM_TYPE_IEC958:
+-			data32->value.iec958 = data->value.iec958;
+-			break;
+-		default:
+-			break;
++	switch (type) {
++	case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
++	case SNDRV_CTL_ELEM_TYPE_INTEGER:
++		for (i = 0; i < 128; i++) {
++			int val;
++			val = data->value.integer.value[i];
++			if (__put_user(val, &data32->value.integer.value[i])) {
++				err = -EFAULT;
++				goto __end;
++			}
++		}
++		break;
++	case SNDRV_CTL_ELEM_TYPE_INTEGER64:
++		if (__copy_to_user(data32->value.integer64.value,
++				   data->value.integer64.value,
++				   sizeof(data32->value.integer64.value))) {
++			err = -EFAULT;
++			goto __end;
++		}
++		break;
++	case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
++		if (__copy_to_user(data32->value.enumerated.item,
++				   data->value.enumerated.item,
++				   sizeof(data32->value.enumerated.item))) {
++			err = -EFAULT;
++			goto __end;
+ 		}
++		break;
++	case SNDRV_CTL_ELEM_TYPE_BYTES:
++		if (__copy_to_user(data32->value.bytes.data,
++				   data->value.bytes.data,
++				   sizeof(data32->value.bytes.data))) {
++			err = -EFAULT;
++			goto __end;
++		}
++		break;
++	case SNDRV_CTL_ELEM_TYPE_IEC958:
++		if (__copy_to_user(&data32->value.iec958,
++				   &data->value.iec958,
++				   sizeof(data32->value.iec958))) {
++			err = -EFAULT;
++			goto __end;
++		}
++		break;
+ 	}
+ 	err = 0;
+-	if (copy_to_user((void __user *)arg, data32, sizeof(*data32)))
+-		err = -EFAULT;
+       __end:
+-      	if (data32)
+-      		kfree(data32);
+ 	if (data)
+ 		kfree(data);
+ 	return err;
+Index: alsa-kernel/core/ioctl32/ioctl32.h
+===================================================================
+RCS file: /suse/tiwai/cvs/alsa/alsa-kernel/core/ioctl32/ioctl32.h,v
+retrieving revision 1.14
+diff -u -r1.14 ioctl32.h
+--- alsa-kernel/core/ioctl32/ioctl32.h	18 Oct 2004 14:31:33 -0000	1.14
++++ alsa-kernel/core/ioctl32/ioctl32.h	23 Nov 2004 14:12:15 -0000
+@@ -28,20 +28,37 @@
+ 
+ #include <linux/compat.h>
+ 
+-#define COPY(x)  (dst->x = src->x)
+-#define CPTR(x)	 (dst->x = compat_ptr(src->x))
++#define COPY(x) \
++	do { \
++		if (copy_in_user(&dst->x, &src->x, sizeof(dst->x))) \
++			return -EFAULT; \
++	} while (0)
++
++#define COPY_ARRAY(x) \
++	do { \
++		if (copy_in_user(dst->x, src->x, sizeof(dst->x))) \
++			return -EFAULT; \
++	} while (0)
++
++#define COPY_CVT(x) \
++	do { \
++		__typeof__(src->x) __val_tmp; \
++		if (get_user(__val_tmp, &src->x) || \
++		    put_user(__val_tmp, &dst->x))\
++			return -EFAULT; \
++	} while (0)
+ 
+ #define convert_from_32(type, dstp, srcp)\
+ {\
+-	struct sndrv_##type *dst = dstp;\
+-	struct sndrv_##type##32 *src = srcp;\
++	struct sndrv_##type __user *dst = dstp;\
++	struct sndrv_##type##32 __user *src = srcp;\
+ 	CVT_##sndrv_##type();\
+ }
+ 
+ #define convert_to_32(type, dstp, srcp)\
+ {\
+-	struct sndrv_##type *src = srcp;\
+-	struct sndrv_##type##32 *dst = dstp;\
++	struct sndrv_##type __user *src = srcp;\
++	struct sndrv_##type##32 __user *dst = dstp;\
+ 	CVT_##sndrv_##type();\
+ }
+ 
+@@ -49,65 +66,19 @@
+ #define DEFINE_ALSA_IOCTL(type) \
+ static inline int _snd_ioctl32_##type(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)\
+ {\
+-	struct sndrv_##type##32 data32;\
+-	struct sndrv_##type data;\
+-	mm_segment_t oldseg;\
++	struct sndrv_##type##32 __user *data32;\
++	struct sndrv_##type __user *data;\
+ 	int err;\
+-	if (copy_from_user(&data32, (void __user *)arg, sizeof(data32)))\
+-		return -EFAULT;\
+-	memset(&data, 0, sizeof(data));\
+-	convert_from_32(type, &data, &data32);\
+-	oldseg = get_fs();\
+-	set_fs(KERNEL_DS);\
+-	err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)&data);\
+-	set_fs(oldseg);\
+-	if (err < 0) \
+-		return err;\
+-	if (native_ctl & (_IOC_READ << _IOC_DIRSHIFT)) {\
+-		convert_to_32(type, &data32, &data);\
+-		if (copy_to_user((void __user *)arg, &data32, sizeof(data32)))\
+-			return -EFAULT;\
+-	}\
+-	return 0;\
+-}
+-
+-#define DEFINE_ALSA_IOCTL_BIG(type) \
+-static inline int _snd_ioctl32_##type(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)\
+-{\
+-	struct sndrv_##type##32 *data32;\
+-	struct sndrv_##type *data;\
+-	mm_segment_t oldseg;\
+-	int err;\
+-	data32 = kmalloc(sizeof(*data32), GFP_KERNEL); \
+-	data = kmalloc(sizeof(*data), GFP_KERNEL); \
+-	if (data32 == NULL || data == NULL) { \
+-		err = -ENOMEM; \
+-		goto __end; \
+-	}\
+-	if (copy_from_user(data32, (void __user *)arg, sizeof(*data32))) { \
+-		err = -EFAULT; \
+-		goto __end; \
+-	}\
+-	memset(data, 0, sizeof(*data));\
++	data32 = compat_ptr(arg);\
++	data = compat_alloc_user_space(sizeof(*data));\
+ 	convert_from_32(type, data, data32);\
+-	oldseg = get_fs();\
+-	set_fs(KERNEL_DS);\
+ 	err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)data);\
+-	set_fs(oldseg);\
+ 	if (err < 0) \
+-		goto __end;\
+-	err = 0;\
++		return err;\
+ 	if (native_ctl & (_IOC_READ << _IOC_DIRSHIFT)) {\
+ 		convert_to_32(type, data32, data);\
+-		if (copy_to_user((void __user *)arg, data32, sizeof(*data32)))\
+-			err = -EFAULT;\
+ 	}\
+-      __end:\
+-      	if (data)\
+-      		kfree(data);\
+-      	if (data32)\
+-      		kfree(data32);\
+-	return err;\
++	return 0;\
+ }
+ 
+ #define DEFINE_ALSA_IOCTL_ENTRY(name,type,native_ctl) \
+Index: alsa-kernel/core/ioctl32/pcm32.c
+===================================================================
+RCS file: /suse/tiwai/cvs/alsa/alsa-kernel/core/ioctl32/pcm32.c,v
+retrieving revision 1.25
+diff -u -r1.25 pcm32.c
+--- alsa-kernel/core/ioctl32/pcm32.c	18 Oct 2004 14:36:00 -0000	1.25
++++ alsa-kernel/core/ioctl32/pcm32.c	23 Nov 2004 14:15:56 -0000
+@@ -41,16 +41,13 @@
+ 	u32 val;
+ };
+ 
+-#define CVT_sndrv_pcm_sframes_str() { COPY(val); }
+-#define CVT_sndrv_pcm_uframes_str() { COPY(val); }
++#define CVT_sndrv_pcm_sframes_str() { COPY_CVT(val); }
++#define CVT_sndrv_pcm_uframes_str() { COPY_CVT(val); }
+ 
+ 
+ struct sndrv_interval32 {
+ 	u32 min, max;
+-	unsigned int openmin:1,
+-		     openmax:1,
+-		     integer:1,
+-		     empty:1;
++	u32 flags; /* bit fields */
+ };
+ 
+ struct sndrv_pcm_hw_params32 {
+@@ -73,25 +70,9 @@
+ 
+ #define CVT_sndrv_pcm_hw_params()\
+ {\
+-	unsigned int i;\
+-	COPY(flags);\
+-	for (i = 0; i < numberof(dst->masks); i++)\
+-		COPY(masks[i]);\
+-	for (i = 0; i < numberof(dst->intervals); i++) {\
+-		COPY(intervals[i].min);\
+-		COPY(intervals[i].max);\
+-		COPY(intervals[i].openmin);\
+-		COPY(intervals[i].openmax);\
+-		COPY(intervals[i].integer);\
+-		COPY(intervals[i].empty);\
+-	}\
+-	COPY(rmask);\
+-	COPY(cmask);\
+-	COPY(info);\
+-	COPY(msbits);\
+-	COPY(rate_num);\
+-	COPY(rate_den);\
+-	COPY(fifo_size);\
++	if (copy_in_user(dst, src, sizeof(snd_pcm_hw_params_t) - sizeof(sndrv_pcm_uframes_t) - 64)) \
++		return -EFAULT;\
++	COPY_CVT(fifo_size);\
+ }
+ 
+ struct sndrv_pcm_sw_params32 {
+@@ -113,13 +94,13 @@
+ 	COPY(tstamp_mode);\
+ 	COPY(period_step);\
+ 	COPY(sleep_min);\
+-	COPY(avail_min);\
+-	COPY(xfer_align);\
+-	COPY(start_threshold);\
+-	COPY(stop_threshold);\
+-	COPY(silence_threshold);\
+-	COPY(silence_size);\
+-	COPY(boundary);\
++	COPY_CVT(avail_min);\
++	COPY_CVT(xfer_align);\
++	COPY_CVT(start_threshold);\
++	COPY_CVT(stop_threshold);\
++	COPY_CVT(silence_threshold);\
++	COPY_CVT(silence_size);\
++	COPY_CVT(boundary);\
+ }
+ 
+ struct sndrv_pcm_channel_info32 {
+@@ -132,7 +113,7 @@
+ #define CVT_sndrv_pcm_channel_info()\
+ {\
+ 	COPY(channel);\
+-	COPY(offset);\
++	COPY_CVT(offset);\
+ 	COPY(first);\
+ 	COPY(step);\
+ }
+@@ -154,16 +135,16 @@
+ #define CVT_sndrv_pcm_status()\
+ {\
+ 	COPY(state);\
+-	COPY(trigger_tstamp.tv_sec);\
+-	COPY(trigger_tstamp.tv_nsec);\
+-	COPY(tstamp.tv_sec);\
+-	COPY(tstamp.tv_nsec);\
+-	COPY(appl_ptr);\
+-	COPY(hw_ptr);\
+-	COPY(delay);\
+-	COPY(avail);\
+-	COPY(avail_max);\
+-	COPY(overrange);\
++	COPY_CVT(trigger_tstamp.tv_sec);\
++	COPY_CVT(trigger_tstamp.tv_nsec);\
++	COPY_CVT(tstamp.tv_sec);\
++	COPY_CVT(tstamp.tv_nsec);\
++	COPY_CVT(appl_ptr);\
++	COPY_CVT(hw_ptr);\
++	COPY_CVT(delay);\
++	COPY_CVT(avail);\
++	COPY_CVT(avail_max);\
++	COPY_CVT(overrange);\
+ 	COPY(suspended_state);\
+ }
+ 
+@@ -194,41 +175,19 @@
+ 
+ static inline int _snd_ioctl32_pcm_hw_params(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
+ {
+-	struct sndrv_pcm_hw_params32 *data32;
+-	struct sndrv_pcm_hw_params *data;
+-	mm_segment_t oldseg;
++	struct sndrv_pcm_hw_params32 __user *data32;
++	struct sndrv_pcm_hw_params __user *data;
+ 	int err;
+ 
+-	data32 = kmalloc(sizeof(*data32), GFP_KERNEL);
+-	data = kmalloc(sizeof(*data), GFP_KERNEL);
+-	if (data32 == NULL || data == NULL) {
+-		err = -ENOMEM;
+-		goto __end;
+-	}
+-	if (copy_from_user(data32, (void __user *)arg, sizeof(*data32))) {
+-		err = -EFAULT;
+-		goto __end;
+-	}
+-	memset(data, 0, sizeof(*data));
++	data32 = compat_ptr(arg);
++	data = compat_alloc_user_space(sizeof(*data));
+ 	convert_from_32(pcm_hw_params, data, data32);
+-	oldseg = get_fs();
+-	set_fs(KERNEL_DS);
+ 	err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)data);
+-	set_fs(oldseg);
+ 	if (err < 0)
+-		goto __end;
+-	err = 0;
++		return err;
+ 	convert_to_32(pcm_hw_params, data32, data);
+-	if (copy_to_user((void __user *)arg, data32, sizeof(*data32)))
+-		err = -EFAULT;
+-	else
+-		recalculate_boundary(file);
+-      __end:
+-      	if (data)
+-      		kfree(data);
+-      	if (data32)
+-      		kfree(data32);
+-	return err;
++	recalculate_boundary(file);
++	return 0;
+ }
+ 
+ 
+@@ -243,24 +202,24 @@
+ static inline int _snd_ioctl32_xferi(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
+ {
+ 	struct sndrv_xferi32 data32;
+-	struct sndrv_xferi data;
+-	mm_segment_t oldseg;
++	struct sndrv_xferi __user *data;
++	snd_pcm_sframes_t result;
+ 	int err;
+ 
+ 	if (copy_from_user(&data32, (void __user *)arg, sizeof(data32)))
+ 		return -EFAULT;
+-	memset(&data, 0, sizeof(data));
+-	data.result = data32.result;
+-	data.buf = compat_ptr(data32.buf);
+-	data.frames = data32.frames;
+-	oldseg = get_fs();
+-	set_fs(KERNEL_DS);
+-	err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)&data);
+-	set_fs(oldseg);
++	data = compat_alloc_user_space(sizeof(*data));
++	if (put_user((snd_pcm_sframes_t)data32.result, &data->result) ||
++	    __put_user(compat_ptr(data32.buf), &data->buf) ||
++	    __put_user((snd_pcm_uframes_t)data32.frames, &data->frames))
++		return -EFAULT;
++	err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)data);
+ 	if (err < 0)
+ 		return err;
+ 	/* copy the result */
+-	data32.result = data.result;
++	if (__get_user(result, &data->result))
++		return -EFAULT;
++	data32.result = result;
+ 	if (copy_to_user((void __user *)arg, &data32, sizeof(data32)))
+ 		return -EFAULT;
+ 	return 0;
+@@ -284,12 +243,11 @@
+ {
+ 	snd_pcm_file_t *pcm_file;
+ 	snd_pcm_substream_t *substream;
++	struct sndrv_xfern32 __user *srcptr = compat_ptr(arg);
+ 	struct sndrv_xfern32 data32;
+-	struct sndrv_xfern32 __user *srcptr = (void __user *)arg;
+-	void __user **bufs = NULL;
++	void __user **bufs;
+ 	int err = 0, ch, i;
+ 	u32 __user *bufptr;
+-	mm_segment_t oldseg;
+ 
+ 	/* FIXME: need to check whether fop->ioctl is sane */
+ 
+@@ -312,22 +270,21 @@
+ 	}
+ 	if ((ch = substream->runtime->channels) > 128)
+ 		return -EINVAL;
+-	if (get_user(data32.frames, &srcptr->frames))
++	if (copy_from_user(&data32, (void __user *)arg, sizeof(data32)))
+ 		return -EFAULT;
+-	__get_user(data32.bufs, &srcptr->bufs);
+ 	bufptr = compat_ptr(data32.bufs);
+-	bufs = kmalloc(sizeof(void *) * 128, GFP_KERNEL);
++	bufs = kmalloc(sizeof(void __user *) * ch, GFP_KERNEL);
+ 	if (bufs == NULL)
+ 		return -ENOMEM;
+ 	for (i = 0; i < ch; i++) {
+ 		u32 ptr;
+-		if (get_user(ptr, bufptr))
++		if (get_user(ptr, bufptr)) {
++			kfree(bufs);
+ 			return -EFAULT;
++		}
+ 		bufs[ch] = compat_ptr(ptr);
+ 		bufptr++;
+ 	}
+-	oldseg = get_fs();
+-	set_fs(KERNEL_DS);
+ 	switch (native_ctl) {
+ 	case SNDRV_PCM_IOCTL_WRITEN_FRAMES:
+ 		err = snd_pcm_lib_writev(substream, bufs, data32.frames);
+@@ -336,109 +293,15 @@
+ 		err = snd_pcm_lib_readv(substream, bufs, data32.frames);
+ 		break;
+ 	}
+-	set_fs(oldseg);
+ 	if (err >= 0) {
+ 		if (put_user(err, &srcptr->result))
+ 			err = -EFAULT;
+ 	}
+ 	kfree(bufs);
+-	return 0;
+-}
+-
+-
+-struct sndrv_pcm_hw_params_old32 {
+-	u32 flags;
+-	u32 masks[SNDRV_PCM_HW_PARAM_SUBFORMAT -
+-			   SNDRV_PCM_HW_PARAM_ACCESS + 1];
+-	struct sndrv_interval32 intervals[SNDRV_PCM_HW_PARAM_TICK_TIME -
+-					SNDRV_PCM_HW_PARAM_SAMPLE_BITS + 1];
+-	u32 rmask;
+-	u32 cmask;
+-	u32 info;
+-	u32 msbits;
+-	u32 rate_num;
+-	u32 rate_den;
+-	u32 fifo_size;
+-	unsigned char reserved[64];
+-} __attribute__((packed));
+-
+-#define __OLD_TO_NEW_MASK(x) ((x&7)|((x&0x07fffff8)<<5))
+-#define __NEW_TO_OLD_MASK(x) ((x&7)|((x&0xffffff00)>>5))
+-
+-static void snd_pcm_hw_convert_from_old_params(snd_pcm_hw_params_t *params, struct sndrv_pcm_hw_params_old32 *oparams)
+-{
+-	unsigned int i;
+-
+-	memset(params, 0, sizeof(*params));
+-	params->flags = oparams->flags;
+-	for (i = 0; i < ARRAY_SIZE(oparams->masks); i++)
+-		params->masks[i].bits[0] = oparams->masks[i];
+-	memcpy(params->intervals, oparams->intervals, sizeof(oparams->intervals));
+-	params->rmask = __OLD_TO_NEW_MASK(oparams->rmask);
+-	params->cmask = __OLD_TO_NEW_MASK(oparams->cmask);
+-	params->info = oparams->info;
+-	params->msbits = oparams->msbits;
+-	params->rate_num = oparams->rate_num;
+-	params->rate_den = oparams->rate_den;
+-	params->fifo_size = oparams->fifo_size;
+-}
+-
+-static void snd_pcm_hw_convert_to_old_params(struct sndrv_pcm_hw_params_old32 *oparams, snd_pcm_hw_params_t *params)
+-{
+-	unsigned int i;
+-
+-	memset(oparams, 0, sizeof(*oparams));
+-	oparams->flags = params->flags;
+-	for (i = 0; i < ARRAY_SIZE(oparams->masks); i++)
+-		oparams->masks[i] = params->masks[i].bits[0];
+-	memcpy(oparams->intervals, params->intervals, sizeof(oparams->intervals));
+-	oparams->rmask = __NEW_TO_OLD_MASK(params->rmask);
+-	oparams->cmask = __NEW_TO_OLD_MASK(params->cmask);
+-	oparams->info = params->info;
+-	oparams->msbits = params->msbits;
+-	oparams->rate_num = params->rate_num;
+-	oparams->rate_den = params->rate_den;
+-	oparams->fifo_size = params->fifo_size;
+-}
+-
+-static inline int _snd_ioctl32_pcm_hw_params_old(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
+-{
+-	struct sndrv_pcm_hw_params_old32 *data32;
+-	struct sndrv_pcm_hw_params *data;
+-	mm_segment_t oldseg;
+-	int err;
+-
+-	data32 = kcalloc(1, sizeof(*data32), GFP_KERNEL);
+-	data = kcalloc(1, sizeof(*data), GFP_KERNEL);
+-	if (data32 == NULL || data == NULL) {
+-		err = -ENOMEM;
+-		goto __end;
+-	}
+-	if (copy_from_user(data32, (void __user *)arg, sizeof(*data32))) {
+-		err = -EFAULT;
+-		goto __end;
+-	}
+-	snd_pcm_hw_convert_from_old_params(data, data32);
+-	oldseg = get_fs();
+-	set_fs(KERNEL_DS);
+-	err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)data);
+-	set_fs(oldseg);
+-	if (err < 0)
+-		goto __end;
+-	snd_pcm_hw_convert_to_old_params(data32, data);
+-	err = 0;
+-	if (copy_to_user((void __user *)arg, data32, sizeof(*data32)))
+-		err = -EFAULT;
+-	else
+-		recalculate_boundary(file);
+-      __end:
+-      	if (data)
+-      		kfree(data);
+-      	if (data32)
+-      		kfree(data32);
+ 	return err;
+ }
+ 
++
+ struct sndrv_pcm_mmap_status32 {
+ 	s32 state;
+ 	s32 pad1;
+@@ -469,15 +332,15 @@
+ 	COPY(flags);\
+ 	COPY(s.status.state);\
+ 	COPY(s.status.pad1);\
+-	COPY(s.status.hw_ptr);\
+-	COPY(s.status.tstamp.tv_sec);\
+-	COPY(s.status.tstamp.tv_nsec);\
++	COPY_CVT(s.status.hw_ptr);\
++	COPY_CVT(s.status.tstamp.tv_sec);\
++	COPY_CVT(s.status.tstamp.tv_nsec);\
+ 	COPY(s.status.suspended_state);\
+-	COPY(c.control.appl_ptr);\
+-	COPY(c.control.avail_min);\
++	COPY_CVT(c.control.appl_ptr);\
++	COPY_CVT(c.control.avail_min);\
+ }
+ 
+-DEFINE_ALSA_IOCTL_BIG(pcm_sync_ptr);
++DEFINE_ALSA_IOCTL(pcm_sync_ptr);
+ 
+ /*
+  */
+@@ -485,8 +348,6 @@
+ DEFINE_ALSA_IOCTL_ENTRY(pcm_hw_refine, pcm_hw_params, SNDRV_PCM_IOCTL_HW_REFINE);
+ DEFINE_ALSA_IOCTL_ENTRY(pcm_hw_params, pcm_hw_params, SNDRV_PCM_IOCTL_HW_PARAMS);
+ DEFINE_ALSA_IOCTL_ENTRY(pcm_sw_params, pcm_sw_params, SNDRV_PCM_IOCTL_SW_PARAMS);
+-DEFINE_ALSA_IOCTL_ENTRY(pcm_hw_refine_old, pcm_hw_params_old, SNDRV_PCM_IOCTL_HW_REFINE);
+-DEFINE_ALSA_IOCTL_ENTRY(pcm_hw_params_old, pcm_hw_params_old, SNDRV_PCM_IOCTL_HW_PARAMS);
+ DEFINE_ALSA_IOCTL_ENTRY(pcm_status, pcm_status, SNDRV_PCM_IOCTL_STATUS);
+ DEFINE_ALSA_IOCTL_ENTRY(pcm_delay, pcm_sframes_str, SNDRV_PCM_IOCTL_DELAY);
+ DEFINE_ALSA_IOCTL_ENTRY(pcm_channel_info, pcm_channel_info, SNDRV_PCM_IOCTL_CHANNEL_INFO);
+@@ -538,8 +399,6 @@
+ 	SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct sndrv_xferi32),
+ 	SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct sndrv_xfern32),
+ 	SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct sndrv_xfern32),
+-	SNDRV_PCM_IOCTL_HW_REFINE_OLD32 = _IOWR('A', 0x10, struct sndrv_pcm_hw_params_old32),
+-	SNDRV_PCM_IOCTL_HW_PARAMS_OLD32 = _IOWR('A', 0x11, struct sndrv_pcm_hw_params_old32),
+ 	SNDRV_PCM_IOCTL_SYNC_PTR32 = _IOWR('A', 0x23, struct sndrv_pcm_sync_ptr32),
+ 
+ };
+@@ -551,8 +410,6 @@
+ 	MAP_COMPAT(SNDRV_PCM_IOCTL_TSTAMP),
+ 	{ SNDRV_PCM_IOCTL_HW_REFINE32, AP(pcm_hw_refine) },
+ 	{ SNDRV_PCM_IOCTL_HW_PARAMS32, AP(pcm_hw_params) },
+-	{ SNDRV_PCM_IOCTL_HW_REFINE_OLD32, AP(pcm_hw_refine_old) },
+-	{ SNDRV_PCM_IOCTL_HW_PARAMS_OLD32, AP(pcm_hw_params_old) },
+ 	MAP_COMPAT(SNDRV_PCM_IOCTL_HW_FREE),
+ 	{ SNDRV_PCM_IOCTL_SW_PARAMS32, AP(pcm_sw_params) },
+ 	{ SNDRV_PCM_IOCTL_STATUS32, AP(pcm_status) },
+Index: alsa-kernel/core/ioctl32/rawmidi32.c
+===================================================================
+RCS file: /suse/tiwai/cvs/alsa/alsa-kernel/core/ioctl32/rawmidi32.c,v
+retrieving revision 1.7
+diff -u -r1.7 rawmidi32.c
+--- alsa-kernel/core/ioctl32/rawmidi32.c	18 Jun 2003 10:34:08 -0000	1.7
++++ alsa-kernel/core/ioctl32/rawmidi32.c	23 Nov 2004 14:21:11 -0000
+@@ -38,9 +38,11 @@
+ #define CVT_sndrv_rawmidi_params()\
+ {\
+ 	COPY(stream);\
+-	COPY(buffer_size);\
+-	COPY(avail_min);\
+-	COPY(no_active_sensing);\
++	COPY_CVT(buffer_size);\
++	COPY_CVT(avail_min);\
++	if (copy_in_user(((size_t __user *)&dst->avail_min + 1),\
++			 ((size_t __user *)&src->avail_min + 1), 4)) \
++		return -EFAULT;\
+ }
+ 
+ struct sndrv_rawmidi_status32 {
+@@ -54,10 +56,10 @@
+ #define CVT_sndrv_rawmidi_status()\
+ {\
+ 	COPY(stream);\
+-	COPY(tstamp.tv_sec);\
+-	COPY(tstamp.tv_nsec);\
+-	COPY(avail);\
+-	COPY(xruns);\
++	COPY_CVT(tstamp.tv_sec);\
++	COPY_CVT(tstamp.tv_nsec);\
++	COPY_CVT(avail);\
++	COPY_CVT(xruns);\
+ }
+ 
+ DEFINE_ALSA_IOCTL(rawmidi_params);
+Index: alsa-kernel/core/ioctl32/seq32.c
+===================================================================
+RCS file: /suse/tiwai/cvs/alsa/alsa-kernel/core/ioctl32/seq32.c,v
+retrieving revision 1.8
+diff -u -r1.8 seq32.c
+--- alsa-kernel/core/ioctl32/seq32.c	6 Feb 2003 17:58:36 -0000	1.8
++++ alsa-kernel/core/ioctl32/seq32.c	23 Nov 2004 14:23:44 -0000
+@@ -42,13 +42,14 @@
+ 
+ 	u32 kernel;			/* reserved for kernel use (must be NULL) */
+ 	u32 flags;		/* misc. conditioning */
+-	char reserved[60];		/* for future use */
++	unsigned char time_queue;	/* queue # for timestamping */
++	char reserved[59];		/* for future use */
+ };
+ 
+ #define CVT_sndrv_seq_port_info()\
+ {\
+ 	COPY(addr);\
+-	memcpy(dst->name, src->name, sizeof(dst->name));\
++	COPY_ARRAY(name);\
+ 	COPY(capability);\
+ 	COPY(type);\
+ 	COPY(midi_channels);\
+@@ -57,6 +58,7 @@
+ 	COPY(read_use);\
+ 	COPY(write_use);\
+ 	COPY(flags);\
++	COPY(time_queue);\
+ }
+ 
+ DEFINE_ALSA_IOCTL(seq_port_info);
+Index: alsa-kernel/core/ioctl32/timer32.c
+===================================================================
+RCS file: /suse/tiwai/cvs/alsa/alsa-kernel/core/ioctl32/timer32.c,v
+retrieving revision 1.8
+diff -u -r1.8 timer32.c
+--- alsa-kernel/core/ioctl32/timer32.c	28 Mar 2004 15:57:48 -0000	1.8
++++ alsa-kernel/core/ioctl32/timer32.c	23 Nov 2004 14:12:47 -0000
+@@ -41,9 +41,9 @@
+ {\
+ 	COPY(flags);\
+ 	COPY(card);\
+-	memcpy(dst->id, src->id, sizeof(src->id));\
+-	memcpy(dst->name, src->name, sizeof(src->name));\
+-	COPY(resolution);\
++	COPY_ARRAY(id);\
++	COPY_ARRAY(name);\
++	COPY_CVT(resolution);\
+ }
+ 
+ struct sndrv_timer_status32 {
+@@ -57,8 +57,8 @@
+ 
+ #define CVT_sndrv_timer_status()\
+ {\
+-	COPY(tstamp.tv_sec);\
+-	COPY(tstamp.tv_nsec);\
++	COPY_CVT(tstamp.tv_sec);\
++	COPY_CVT(tstamp.tv_nsec);\
+ 	COPY(resolution);\
+ 	COPY(lost);\
+ 	COPY(overrun);\
diff --git a/media-sound/alsa-driver/files/digest-alsa-driver-1.0.7-r1 b/media-sound/alsa-driver/files/digest-alsa-driver-1.0.7-r1
new file mode 100644
index 000000000000..daf5cb7de471
--- /dev/null
+++ b/media-sound/alsa-driver/files/digest-alsa-driver-1.0.7-r1
@@ -0,0 +1 @@
+MD5 30be8b50ab699f917fb20537bc6509ad alsa-driver-1.0.7.tar.bz2 1829053