diff options
Diffstat (limited to 'setup/Linux/oss/build')
| -rw-r--r-- | setup/Linux/oss/build/Makefile.osscore | 32 | ||||
| -rw-r--r-- | setup/Linux/oss/build/Makefile.tmpl | 21 | ||||
| -rw-r--r-- | setup/Linux/oss/build/install.sh | 347 | ||||
| -rw-r--r-- | setup/Linux/oss/build/module.inc | 245 | ||||
| -rw-r--r-- | setup/Linux/oss/build/osscore.c | 2214 | ||||
| -rw-r--r-- | setup/Linux/oss/build/ossdip.h | 10 | ||||
| -rw-r--r-- | setup/Linux/oss/build/pci_wrapper.inc | 93 | ||||
| -rw-r--r-- | setup/Linux/oss/build/usb_wrapper.inc | 730 |
8 files changed, 3692 insertions, 0 deletions
diff --git a/setup/Linux/oss/build/Makefile.osscore b/setup/Linux/oss/build/Makefile.osscore new file mode 100644 index 0000000..30d0287 --- /dev/null +++ b/setup/Linux/oss/build/Makefile.osscore @@ -0,0 +1,32 @@ +include /etc/oss.conf + +EXTRA_CFLAGS += -I${OSSLIBDIR}/include/internals -I${OSSLIBDIR}/include/sys + +ifneq ($(KERNELRELEASE),) + + obj-m := osscore.o + +else + + KERNELDIR ?= /lib/modules/$(shell uname -r)/build + PWD := $(shell pwd) +endif + +default: + @echo "static const char __oss_compile_vermagic[]" > ubuntu_version_hack.inc +#The kernel build system saves kernel version (obtained via "utsrelease.h") +#used during compile in a "vermagic" symbol. soundon compares this with +#current version of running kernel to know when to relink modules. +#Some Ubuntu kernels have 'uname -r' output different from "utsrelease.h" +#contents, so we save the previous uname as a fallback check. +# https://bugs.launchpad.net/ubuntu/+source/linux/+bug/247055 + @echo "__attribute__((used))" >> ubuntu_version_hack.inc + @echo "__attribute__((section(\".modinfo\")))" >> ubuntu_version_hack.inc + @echo "= \"$(shell /usr/sbin/ossvermagic -z -s)\";" >> ubuntu_version_hack.inc + + $(MAKE) -C $(KERNELDIR) M=$(PWD) modules + @rm -f ubuntu_version_hack.inc + +clean: + rm -f *.o *.ko *.mod.c *.mod.o .*.cmd core core.* x y z ubuntu_version_hack.inc + rm -rf .tmp_versions diff --git a/setup/Linux/oss/build/Makefile.tmpl b/setup/Linux/oss/build/Makefile.tmpl new file mode 100644 index 0000000..fd331c1 --- /dev/null +++ b/setup/Linux/oss/build/Makefile.tmpl @@ -0,0 +1,21 @@ +include /etc/oss.conf + +EXTRA_CFLAGS += -I${OSSLIBDIR}/include/internals -I${OSSLIBDIR}/include/sys + +ifneq ($(KERNELRELEASE),) + + obj-m := MODNAME.o + +else + + KERNELDIR ?= /lib/modules/$(shell uname -r)/build + PWD := $(shell pwd) + +default: + $(MAKE) -C $(KERNELDIR) M=$(PWD) modules + +endif + +clean: + @rm -f *.o *.ko *.mod.c *.mod.o .*.cmd core core.* x y z + @rm -rf .tmp_versions diff --git a/setup/Linux/oss/build/install.sh b/setup/Linux/oss/build/install.sh new file mode 100644 index 0000000..13fdbc2 --- /dev/null +++ b/setup/Linux/oss/build/install.sh @@ -0,0 +1,347 @@ +#!/bin/sh +if test -f /etc/oss.conf +then + . /etc/oss.conf +else + OSSLIBDIR=/usr/lib/oss + echo "OSSLIBDIR=/usr/lib/oss" > /etc/oss.conf +fi + +[ -z "$LD" ] && LD=ld + +cd $OSSLIBDIR/build + +rm -f $OSSLIBDIR/.cuckoo_installed + +# Check if we should use REGPARM or non-REGPARM modules +if /usr/sbin/ossvermagic -r || /sbin/modinfo ext3|grep -q REGPARM +then + REGPARM=REGPARM + rm -rf $OSSLIBDIR/objects + ln -s $OSSLIBDIR/objects.regparm $OSSLIBDIR/objects + rm -rf $OSSLIBDIR/modules + ln -s $OSSLIBDIR/modules.regparm $OSSLIBDIR/modules +else + REGPARM=NOREGPARM + rm -rf $OSSLIBDIR/objects + ln -s $OSSLIBDIR/objects.noregparm $OSSLIBDIR/objects + rm -rf $OSSLIBDIR/modules + ln -s $OSSLIBDIR/modules.noregparm $OSSLIBDIR/modules +fi + +UNAME=`uname -r` + +if test -f /lib/modules/$UNAME/kernel/oss/vmix.ko || test -f /lib/modules/$UNAME/kernel/oss/ich.ko +then +# Older versions of OSS modules exist under /lib/modules. This indicates that +# previous version of OSS has not been properly uninstalled. Run osdetect +# again to fix rthe situation + + /usr/sbin/soundoff > /dev/null 2>&1 + /usr/sbin/ossdetect +fi + +# Remove previous OSS modules from the system +rm -rf /lib/modules/$UNAME/kernel/oss + +if test -f /usr/lib/oss/build/ich.c +then + # Older v4.0 modules found. Remove them + (cd /usr/lib/oss/build ; rm -f ali5455.c allegro.c als300.c als4000.c apci97.c atiaudio.c audigyls.c audioloop.c audiopci.c cmi8788.c cmpci.c cs4280.c cs4281.c digi32.c digi96.c emu10k1x.c envy24.c envy24ht.c fm801.c geode.c hdaudio.c hdsp.c ich.c imux.c maestro.c neomagic.c ossusb.c riptide.c s3vibes.c sblive.c sbxfi.c softoss.c solo.c sonorus.c trident.c via8233.c via97.c vmix.c vortex.c ymf7xx.c) + echo + echo + echo Error: Older OSS version seems to be installed in your system. + echo Please remove previous /usr/lib/oss directory and the install OSS v4.x again. + soundoff + exit 127 +fi + +if ! test -f $OSSLIBDIR/objects/osscore.o +then + echo Error: OSS core module for $REGPARM kernel is not available in $OSSLIBDIR/objects + exit 1 +fi + +echo +echo OSS build environment set up for $REGPARM kernels + +KERNELDIR=/lib/modules/$UNAME/build +UBUNTUPACKAGES="" + +OK=1 +echo + +if test "`which gcc 2>/dev/null` " = " " +then + echo " gcc" + UBUNTUPACKAGES="$UBUNTUPACKAGES gcc" + OK=0 +fi + +if test "`which make 2>/dev/null` " = " " +then + echo " make" + UBUNTUPACKAGES="$UBUNTUPACKAGES make" + OK=0 +fi + +if test "`which ld 2>/dev/null` " = " " +then + echo " binutils" + UBUNTUPACKAGES="$UBUNTUPACKAGES binutils" + OK=0 +fi + +if ! test -f /usr/include/stdio.h +then + echo " C library headers (glibc-devel or build-essential)" + OK=0 + UBUNTUPACKAGES="$UBUNTUPACKAGES build-essentials" +fi + +if test "$OK " = "0 " +then + echo + echo 'Error: The above Linux package(s) seem to be missing from your system.' + echo ' Please install them and then try to install OSS again.' + echo + echo Please refer to the documentation of your Linux distribution if you + echo have problems with installing the packages. + echo + + if grep -q Ubuntu /etc/issue # Ubuntu? + then + echo You can use the following commands to download and install all + echo required packages: + echo + + for n in $UBUNTUPACKAGES + do + echo " apt-get install $n" + done + + exit 1 + fi + + exit 1 +fi + + +if ! test -f $KERNELDIR/Makefile && ! test -f /lib/modules/$UNAME/sources/Makefile +then + echo + echo 'Warning: Cannot locate the Linux kernel development package for' + echo ' Linux kernel version ' $UNAME + echo ' Please install the kernel development package if linking the' + echo ' OSS modules fails.' + echo + echo The kernel development package may be called kernel-devel, kernel-smp-devel, + echo kernel-sources, kernel-headers or something like that. Please refer + echo to the documentation of your Linux distribution if there are any + echo difficulties in installing the kernel/driver development environment. + echo + + if grep -q 'Fedora Core release' /etc/issue + then + if uname -v|grep -q SMP + then + echo Assuming that you are using Fedora Core 5 or later + echo "the right kernel source package (RPM) is probably called" + echo kernel-smp-devel. + else + echo Assuming that you are using Fedora Core 5 or later + echo "the right kernel source package (RPM) is probably called" + echo kernel-devel. + fi + else + echo For your Linux distribution the right kernel source package + echo might be kernel-source. + fi + echo + + if grep -q Ubuntu /etc/issue || grep -q Debian /etc/issue # Ubuntu or Debian? + then + echo Under Ubuntu you may need to prepare the kernel environment + echo after downloading the kernel sources using + echo + echo " sudo apt-get install linux-headers-$UNAME" + echo " cd /usr/src/linux-headers-$UNAME/" +# echo " sudo make prepare" +# echo " sudo make prepare scripts" + echo + fi +fi + +if ! test -d /lib/modules/$UNAME +then + echo Error: Kernel directory /lib/modules/$UNAME does not exist + exit 1 +fi + +cp -f ../objects/osscore.o osscore_mainline.o + +rm -f Makefile +ln -s Makefile.osscore Makefile + +echo Building module osscore + +if ! make KERNELDIR=$KERNELDIR> build.list 2>&1 +then + echo Failed to compile OSS + cat build.list + exit 2 +fi + +if ! test -d /lib/modules/$UNAME/kernel/oss +then + mkdir /lib/modules/$UNAME/kernel/oss +fi + +if ! test -d /lib/modules/$UNAME/kernel/oss +then + echo OSS module directory /lib/modules/$UNAME/kernel/oss does not exist. + exit 3 +fi + +if ! $LD -r osscore.ko osscore_mainline.o -o /lib/modules/$UNAME/kernel/oss/osscore.ko +then + echo Linking the osscore module failed + exit 5 +fi + +if test -f Module.symvers +then + #Take generated symbol information and add it to module.inc + echo "static const struct modversion_info ____versions[]" > osscore_symbols.inc + echo " __attribute__((used))" >> osscore_symbols.inc + echo "__attribute__((section(\"__versions\"))) = {" >> osscore_symbols.inc + sed -e "s:^:{:" -e "s:\t:, \":" -e "s:\t\(.\)*:\"},:" < Module.symvers >> osscore_symbols.inc + echo "};" >> osscore_symbols.inc +else + echo > osscore_symbols.inc +fi + +#depmod -a + +for n in ../modules/*.o +do + N=`basename $n .o` + echo Building module $N + + rm -f $N_mainline.o Makefile + + sed "s/MODNAME/$N/" < Makefile.tmpl > Makefile + ln -s $n $N_mainline.o + + if ! make KERNELDIR=$KERNELDIR > build.list 2>&1 + then + echo Compiling module $N failed + cat build.list + exit 4 + fi + + if ! $LD -r $N.ko $N_mainline.o -o /lib/modules/$UNAME/kernel/oss/$N.ko + then + echo Linking $N module failed + exit 6 + fi + + rm -f $N_mainline.o + make clean +done + +rm -f Makefile + +echo "depmod -a" +depmod -a + +# Copy config files for any new driver modules + +if ! test -d $OSSLIBDIR/conf +then + mkdir $OSSLIBDIR/conf +fi + +if test -d $OSSLIBDIR/conf.tmpl +then + for n in $OSSLIBDIR/conf.tmpl/*.conf + do + N=`basename $n` + + if ! test -f $OSSLIBDIR/conf/$N + then + cp -f $n $OSSLIBDIR/conf/ + fi + done + rm -rf $OSSLIBDIR/conf.tmpl +fi + +if ! test -f $OSSLIBDIR/etc/installed_drivers +then + echo "-----------------------------" + /usr/sbin/ossdetect -v + echo "-----------------------------" + echo +fi + +if ! test -d /etc/init.d +then + mkdir /etc/init.d +fi + +rm -f /etc/init.d/oss /etc/rc.d/rc3.d/S89oss /etc/rc3.d/S89oss +cp -f $OSSLIBDIR/etc/S89oss /etc/init.d/oss + +chmod 744 /etc/init.d/oss + +if test -x /sbin/chkconfig +then + /sbin/chkconfig oss on > /dev/null 2>&1 +else + if test -x /usr/sbin/update-rc.d + then + /usr/sbin/update-rc.d oss defaults > /dev/null 2>&1 + else + if test -d etc/rc.d/rc3.d + then + rm -f /etc/rc.d/rc3.d/S89oss + ln -s /etc/init.d/oss /etc/rc.d/rc3.d/S89oss + else + if test -d /etc/rc3.d + then + rm -f /etc/rc3.d/S89oss + ln -s /etc/init.d/oss /etc/rc3.d/S89oss + fi + fi + fi +fi + +# Install ALSA interface module (Cuckoo) +#(cd $OSSLIBDIR/cuckoo && make clean) > /dev/null 2>&1 +#if (cd $OSSLIBDIR/cuckoo && make install) > /var/log/cuckoo.log 2>&1 +#then +# touch $OSSLIBDIR/.cuckoo_installed +#fi +#(cd $OSSLIBDIR/cuckoo && make clean) > /dev/null 2>&1 + +# Remove bogus char major 14 device files left from earlier OSS versions. + +rm -f `ls -l -d /dev/*|grep ^c|grep ' 14, '|sed 's/.* //'` + +# Recompile libflashsupport.so if possible. Otherwise use the precompiled +# version. +(cd $OSSLIBDIR/lib;cc -m64 -shared -fPIC -O2 -Wall -Werror flashsupport.c -o $OSSLIBDIR/lib/libflashsupport_64.so) > /dev/null 2>&1 +(cd $OSSLIBDIR/lib;cc -m32 -shared -fPIC -O2 -Wall -Werror flashsupport.c -o $OSSLIBDIR/lib/libflashsupport_32.so) > /dev/null 2>&1 + +if test ! -f $OSSLIBDIR/etc/userdefs +then + echo "autosave_mixer yes" > $OSSLIBDIR/etc/userdefs +fi + +# Hal 0.5.0+ hotplug +mkdir -p /usr/lib/hal/scripts +ln -sf $OSSLIBDIR/scripts/oss_usb-create-devices /usr/lib/hal/scripts/ +mkdir -p /usr/share/hal/fdi/policy/20thirdparty/ +ln -sf $OSSLIBDIR/scripts/90-oss_usb-create-device.fdi /usr/share/hal/fdi/policy/20thirdparty/ + +exit 0 diff --git a/setup/Linux/oss/build/module.inc b/setup/Linux/oss/build/module.inc new file mode 100644 index 0000000..4e34003 --- /dev/null +++ b/setup/Linux/oss/build/module.inc @@ -0,0 +1,245 @@ +/* + * Purpose: Template for OSS modules under Linux + * + * This file is included by the low level driver modules when they are + * compiled in the target system. In this way this file can be modified + * for non-standard kernels by the customer. Compiling in the target is + * necessary because the driver/module framework of Linux cannot support + * binary drivers. Another reason is that the kbuild mechanism used to build + * kernel modules under Linux is not compatible with the way how the source + * code of OSS is organized. + */ +/* + * Copyright (C) 4Front Technologies 2005-2007. Released under GPL2 license. + */ +#define strcpy dummy_strcpy +#include <linux/version.h> +#include <linux/init.h> +#include <linux/module.h> +#include <linux/errno.h> +#include <linux/kernel.h> +#include <linux/pci.h> +#include "timestamp.h" +#include "oss_exports.h" +#include "wrap.h" +#include "ossddk.h" +#include "ossdip.h" +#undef strcpy +#define strcpy oss_strcpy +#undef strlen +#define strlen oss_strlen + +static int module_major = 0; +static int instance = 0; + +MODULE_LICENSE ("GPL v2"); +MODULE_DESCRIPTION ("Open Sound System '" DRIVER_PURPOSE "' driver module"); +MODULE_AUTHOR ("4Front Technologies (support@opensound.com)"); + +extern int DRIVER_ATTACH (oss_device_t * osdev); +extern int DRIVER_DETACH (oss_device_t * osdev); + +#if DRIVER_TYPE==DRV_PCI +#define DRIVER_TYPE_OK + +#include "pci_wrapper.inc" + +// MODULE_DEVICE_TABLE(pci, id_table); +static struct pci_driver osspci_driver = { + .name = DRIVER_NICK, + .id_table = id_table, + .probe = osspci_probe, + .remove = osspci_remove +}; + +static int __init +pcidrv_init (void) +{ + int err; + + if ((err = pci_register_driver (&osspci_driver)) < 0) + return err; + oss_register_module (THIS_MODULE); + return 0; +} + +static void __exit +pcidrv_exit (void) +{ + if (module_major > 0) + { + oss_unregister_chrdev (module_major, DRIVER_NICK); + } + pci_unregister_driver (&osspci_driver); + oss_unregister_module (THIS_MODULE); +} + +module_init (pcidrv_init); +module_exit (pcidrv_exit); +#endif /* PCI driver */ + +#if DRIVER_TYPE==DRV_VIRTUAL || DRIVER_TYPE==DRV_VMIX +#define DRIVER_TYPE_OK +static oss_device_t *osdev = NULL; + +static int +virtualdrv_init (void) +{ + static int instance = 0, maj; + + if ((osdev = + osdev_create (NULL, DRIVER_TYPE, instance++, DRIVER_NICK, + NULL)) == NULL) + { + return -ENOMEM; + } + osdev_set_owner (osdev, THIS_MODULE); + maj = oss_request_major (osdev, 0, DRIVER_NICK); + osdev_set_major (osdev, maj); + if (!DRIVER_ATTACH (osdev)) + return -EIO; + oss_register_module (THIS_MODULE); + oss_audio_delayed_attach (); + return 0; +} + +static void +virtualdrv_exit (void) +{ + + if (!DRIVER_DETACH (osdev)) + printk (KERN_ALERT DRIVER_NICK ": Unloading busy device\n"); + osdev_delete (osdev); + oss_unregister_module (THIS_MODULE); +} + +module_init (virtualdrv_init); +module_exit (virtualdrv_exit); +#endif /* Virtual driver */ + +#if DRIVER_TYPE==DRV_USB +#define DRIVER_TYPE_OK +oss_device_t *osdev = NULL; +static int usb_major = 0; + +#include "usb_wrapper.inc" + +static int +usbdrv_init (void) +{ + int res; + + if (udi_usb_installed) + return 0; + if ((osdev = + osdev_create (NULL, DRV_VIRTUAL, instance++, DRIVER_NICK, + NULL)) == NULL) + { + return -ENOMEM; + } + osdev_set_owner (osdev, THIS_MODULE); + usb_major = oss_request_major (osdev, 0, DRIVER_NICK); + if (usb_major < 0) + { + oss_cmn_err (CE_WARN, "Failed to allocate USB major (%d)\n", usb_major); + return -EIO; + } + osdev_set_major (osdev, usb_major); + oss_register_device (osdev, "USB audio core services"); + if (!DRIVER_ATTACH (osdev)) + return -EIO; + oss_register_module (THIS_MODULE); + oss_audio_delayed_attach (); + + udi_usb_installed = 1; + + if ((res = usb_register (&oss_usb)) < 0) + { + printk ("oss: usb_register failed, err=%d\n", res); + drv = NULL; + return -ENXIO; + } + return 0; +} + +static void +usbdrv_exit (void) +{ + if (!udi_usb_installed) + return; + if (!DRIVER_DETACH (osdev)) + printk (KERN_ALERT DRIVER_NICK ": Unloading busy device\n"); + usb_deregister (&oss_usb); + udi_usb_installed = 0; + known_devices = NULL; + osdev_delete (osdev); + osdev = NULL; + oss_unregister_module (THIS_MODULE); +} + +module_init (usbdrv_init); +module_exit (usbdrv_exit); +#endif /* USB driver */ + +#ifndef DRIVER_TYPE_OK +#error Unrecognized driver type +#endif + +char * +strcpy (char *s1, const char *s2) +{ + char *s = s1; + + while (*s2) + *s1++ = *s2++; + *s1 = 0; + return s; +} + +void +oss_cmn_err (int level, const char *s, ...) +{ + char tmp[1024], *a[6]; + va_list ap; + int i, n = 0; + + va_start (ap, s); + + for (i = 0; i < strlen (s); i++) + if (s[i] == '%') + n++; + + for (i = 0; i < n && i < 6; i++) + { + a[i] = va_arg (ap, char *); + } + + for (i = n; i < 6; i++) + a[i] = NULL; + + if (level == CE_CONT) + { + sprintf (tmp, s, a[0], a[1], a[2], a[3], a[4], a[5], NULL, + NULL, NULL, NULL); + printk ("%s", tmp); + } + else + { + strcpy (tmp, DRIVER_NICK ": "); + + sprintf (tmp + strlen (tmp), s, a[0], a[1], a[2], a[3], a[4], a[5], + NULL, NULL, NULL, NULL); + if (level == CE_PANIC) + panic (tmp); + printk (KERN_ALERT "%s", tmp); + } +#if 0 + /* This may cause a crash under SMP */ + if (sound_started) + store_msg (tmp); +#endif + + va_end (ap); +} + +#include "osscore_symbols.inc" diff --git a/setup/Linux/oss/build/osscore.c b/setup/Linux/oss/build/osscore.c new file mode 100644 index 0000000..1a029b4 --- /dev/null +++ b/setup/Linux/oss/build/osscore.c @@ -0,0 +1,2214 @@ +/* + * Purpose: Linux kernel version specific wrapper routines. + * + * This file will be shipped in source format and compiled in the target + * (customer) system. In this way minor changes between Linux versions + * can be fixed by the customer. + */ + +/* + * Copyright (C) 4Front Technologies 2005-2009. Released under GPL2 license. + */ +//#include <linux/config.h> +typedef int *ioctl_arg; +#include <linux/init.h> +#include <linux/module.h> +#include <linux/delay.h> +#include <stdarg.h> +#include <linux/vmalloc.h> +#include "timestamp.h" +#include "local_config.h" +#include "oss_exports.h" +#include "wrap.h" +#include "ossdip.h" +#include <linux/version.h> +#include <linux/fs.h> +#include <linux/poll.h> +#include <linux/time.h> +#include <linux/proc_fs.h> +#include <linux/spinlock.h> +#include <linux/pci.h> +#include <linux/irq.h> +#include <linux/sched.h> +#include <linux/interrupt.h> +#undef strlen +#undef strcpy +#define strlen oss_strlen +#define strcpy oss_strcpy + +typedef struct _smap_t dmap_t; + +#include "soundcard.h" +#include "audio_core.h" +#include "mixer_core.h" +#include "ubuntu_version_hack.inc" + +MODULE_LICENSE ("GPL v2"); +MODULE_DESCRIPTION ("Open Sound System core services"); +MODULE_AUTHOR ("4Front Technologies (support@opensound.com)"); + +struct _oss_mutex_t +{ + /* Caution! This definition must match cuckoo.h */ + spinlock_t lock; + int filler; /* Make sure this structure doesn't become zero length */ +}; + +static oss_device_t *core_osdev = NULL; +/* + * Minor device list + */ +#define MAX_MINOR 256 +typedef struct +{ + int major, minor; + char name[32]; +} oss_minor_t; + +static oss_minor_t minors[MAX_MINOR]; +static int nminors = 0; + +/* + * Sleep flags. Make sure these definitions match oss_config.h. + */ +#define WK_NONE 0x00 +#define WK_WAKEUP 0x01 +#define WK_TIMEOUT 0x02 +#define WK_SIGNAL 0x04 +#define WK_SLEEP 0x08 +#define WK_SELECT 0x10 + +time_t +oss_get_time (void) +{ +#if 1 + return get_seconds (); +#else + return xtime.tv_sec; +#endif +} + +void *oss_memset (void *t, int val, size_t l); + +void * +oss_kmem_alloc (size_t size) +{ + void *ptr; + if ((ptr = vmalloc (size)) == NULL) + { + oss_cmn_err (CE_WARN, "vmalloc(%d) failed\n", size); + return NULL; + } + memset (ptr, 0, size); + return ptr; +} + +void +oss_kmem_free (void *addr) +{ + vfree (addr); +} + +/* oss_pmalloc() moved to os_linux.c */ + +extern oss_native_word +oss_virt_to_bus (void *addr) +{ + return virt_to_bus (addr); +} + +void * +oss_memcpy (void *t_, const void *f_, size_t l) +{ + unsigned char *t = t_; + unsigned const char *f = f_; + int i; + + for (i = 0; i < l; i++) + *t++ = *f++; + + return t; +} + +void * +oss_memset (void *t, int val, size_t l) +{ + char *c = t; + while (l-- > 0) + *c++ = val; + + return t; +} + +int +oss_strcmp (const char *s1, const char *s2) +{ + while (*s1 && *s2) + { + if (*s1 != *s2) + return *s1 - *s2; + s1++; + s2++; + } + + return *s1 - *s2; +} + +int +oss_strncmp (const char *s1, const char *s2, size_t len) +{ + while (*s1 && *s2 && len--) + { + if (*s1 != *s2) + return *s1 - *s2; + s1++; + s2++; + } + + return *s1 - *s2; +} + +char * +oss_strcpy (char *s1, const char *s2) +{ + char *s = s1; + + while (*s2) + *s1++ = *s2++; + *s1 = '\0'; + return s; +} + +size_t +oss_strlen (const char *s) +{ + int i; + + for (i = 0; s[i]; i++); + + return i; +} + +char * +oss_strncpy (char *s1, const char *s2, size_t l) +{ + char *s = s1; + int n = 0; + + while (*s2) + { + if (n++ >= l) + return s; + + *s1++ = *s2++; + } + *s1 = '\0'; + return s; +} + +int oss_hz = HZ; +extern int max_intrate; +extern int detect_trace; +extern int src_quality; +extern int flat_device_model; +extern int vmix_disabled; +extern int vmix_no_autoattach; +extern int vmix_loopdevs; +extern int ac97_amplifier; +extern int ac97_recselect; +extern int cooked_enable; +extern int dma_buffsize; +extern int excl_policy; +extern int mixer_muted; + +module_param (oss_hz, int, S_IRUGO); +module_param (max_intrate, int, S_IRUGO); +module_param (detect_trace, int, S_IRUGO); +module_param (src_quality, int, S_IRUGO); +module_param (flat_device_model, int, S_IRUGO); +module_param (vmix_disabled, int, S_IRUGO); +module_param (vmix_no_autoattach, int, S_IRUGO); +module_param (vmix_loopdevs, int, S_IRUGO); +module_param (ac97_amplifier, int, S_IRUGO); +module_param (ac97_recselect, int, S_IRUGO); +module_param (cooked_enable, int, S_IRUGO); +module_param (dma_buffsize, int, S_IRUGO); +module_param (excl_policy, int, S_IRUGO); +module_param (mixer_muted, int, S_IRUGO); + +static struct proc_dir_entry *oss_proc_root = NULL; +static struct proc_dir_entry *oss_proc_devfiles = NULL; + +static ssize_t +oss_read_devfiles (struct file *file, char __user * buf, size_t count, + loff_t * ppos) +{ + static char tmp[8192]; + char *s; + static int eof = 0; + int i; + + if (eof) + { + eof = 0; + return 0; + } + + *tmp = 0; + s = tmp; + + for (i = 0; i < nminors; i++) + { + if (strlen (tmp) > sizeof (tmp) - 20) + { + printk (KERN_ALERT "osscore: Procfs buffer too small\n"); + return -ENOMEM; + } + + s += sprintf (s, "%s %d %d\n", + minors[i].name, minors[i].major, minors[i].minor); + } + + if (copy_to_user (buf, (void *) tmp, strlen (tmp))) + return -EFAULT; + + eof = 1; + return strlen (tmp); +} + +static struct file_operations oss_proc_operations = { + .read = oss_read_devfiles, +}; + +static void +init_proc_fs (void) +{ + if ((oss_proc_root = + create_proc_entry ("opensound", 0700 | S_IFDIR, NULL)) == NULL) + { + oss_cmn_err (CE_CONT, "Cannot create /proc/opensound\n"); + return; + } + + if ((oss_proc_devfiles = + create_proc_entry ("devfiles", 0600, oss_proc_root)) == NULL) + { + oss_cmn_err (CE_CONT, "Cannot create /proc/opensound/devfiles\n"); + return; + } + + oss_proc_devfiles->proc_fops = &oss_proc_operations; +} + +static void +uninit_proc_fs (void) +{ + if (oss_proc_root) + { + if (oss_proc_devfiles) + remove_proc_entry ("devfiles", oss_proc_root); + remove_proc_entry ("opensound", NULL); + } +} + +static int +osscore_init (void) +{ + if ((core_osdev = + osdev_create (NULL, DRV_UNKNOWN, 0, "osscore", NULL)) == NULL) + { + oss_cmn_err (CE_WARN, "Failed to allocate OSDEV structure\n"); + return -ENOMEM; + } + + osdev_set_owner (core_osdev, THIS_MODULE); + + init_proc_fs (); + + return oss_init_osscore (core_osdev); +} + +static void +osscore_exit (void) +{ + uninit_proc_fs (); + oss_uninit_osscore (core_osdev); +} + +void +oss_udelay (unsigned long d) +{ + udelay (d); +} + +oss_mutex_t +oss_mutex_init (void) +{ + oss_mutex_t mutex; + + if ((mutex = vmalloc (sizeof (*mutex))) == NULL) + { + oss_cmn_err (CE_WARN, "vmalloc(%d) failed (mutex)\n", sizeof (*mutex)); + return NULL; + } + + spin_lock_init (&(mutex->lock)); + + return mutex; +} + +void +oss_mutex_cleanup (oss_mutex_t mutex) +{ + vfree (mutex); +} + +void +oss_spin_lock_irqsave (oss_mutex_t mutex, oss_native_word * flags) +{ + unsigned long flag; + if (mutex == NULL) + return; + spin_lock_irqsave (&mutex->lock, flag); + *flags = flag; +} + +void +oss_spin_unlock_irqrestore (oss_mutex_t mutex, oss_native_word flags) +{ + if (mutex == NULL) + return; + spin_unlock_irqrestore (&mutex->lock, flags); +} + +void +oss_spin_lock (oss_mutex_t mutex) +{ + if (mutex == NULL) + return; + spin_lock (&mutex->lock); +} + +void +oss_spin_unlock (oss_mutex_t mutex) +{ + if (mutex == NULL) + return; + spin_unlock (&mutex->lock); +} + +void * +oss_map_pci_mem (oss_device_t * osdev, int size, unsigned long offset) +{ +#ifdef __arm__ + return (void*)offset; +#else + return ioremap (offset, size); +#endif +} + +void +oss_unmap_pci_mem (void *addr) +{ +#ifndef __arm__ + iounmap (addr); +#endif +} + +unsigned long long +oss_get_jiffies (void) +{ + return jiffies_64; +} + +char * +oss_get_procname (void) +{ + return current->comm; +} + +int +oss_get_pid (void) +{ + return current->pid; +} + +int +oss_get_uid (void) +{ +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29) + return current->cred->uid; +#else + return current->uid; +#endif +} + +typedef struct tmout_desc +{ + volatile int active; + int timestamp; + void (*func) (void *); + void *arg; + + struct timer_list timer; +} tmout_desc_t; + +static volatile int next_id = 0; +#define MAX_TMOUTS 128 + +tmout_desc_t tmouts[MAX_TMOUTS] = { {0} }; + +int timeout_random = 0x12123400; + +void +oss_timer_callback (unsigned long id) +{ + tmout_desc_t *tmout; + int ix; + void *arg; + + timeout_random++; + + ix = id & 0xff; + if (ix < 0 || ix >= MAX_TMOUTS) + return; + tmout = &tmouts[ix]; + + if (tmout->timestamp != id) /* Expired timer */ + return; + + if (!tmout->active) + return; + + arg = tmout->arg; + tmout->active = 0; + tmout->timestamp = 0; + + tmout->func (arg); +} + +timeout_id_t +oss_timeout (void (*func) (void *), void *arg, unsigned long long ticks) +{ + tmout_desc_t *tmout = NULL; + int id, n; + + timeout_random++; + + n = 0; + id = -1; + + while (id == -1 && n < MAX_TMOUTS) + { + if (!tmouts[next_id].active) + { + tmouts[next_id].active = 1; + id = next_id++; + tmout = &tmouts[id]; + break; + } + + next_id = (next_id + 1) % MAX_TMOUTS; + } + + if (id == -1) /* No timer slots available */ + { + oss_cmn_err (CE_WARN, "Timeout table full\n"); + return 0; + } + + tmout->func = func; + tmout->arg = arg; + tmout->timestamp = id | (timeout_random & ~0xff); + + init_timer (&tmout->timer); + tmout->timer.expires = jiffies + ticks; + tmout->timer.data = id | (timeout_random & ~0xff); + tmout->timer.function = oss_timer_callback; + add_timer (&tmout->timer); + + return id | (timeout_random & ~0xff); +} + +void +oss_untimeout (timeout_id_t id) +{ + tmout_desc_t *tmout; + int ix; + + ix = id & 0xff; + if (ix < 0 || ix >= MAX_TMOUTS) + return; + + timeout_random++; + tmout = &tmouts[ix]; + + if (tmout->timestamp != id) /* Expired timer */ + return; + if (tmout->active) + del_timer (&tmout->timer); + tmout->active = 0; + tmout->timestamp = 0; +} + +int +oss_uiomove (void *addr, size_t nbytes, enum uio_rw rwflag, uio_t * uio) +{ +/* + * NOTE! Returns 0 upon success and EFAULT on failure (instead of -EFAULT + * (for Solaris/BSD compatibilityi)). + */ + + int c; + char *address = addr; + + if (rwflag != uio->rw) + { + oss_cmn_err (CE_WARN, "uiomove: Bad direction\n"); + return EFAULT; + } + + if (uio->resid < nbytes) + { + oss_cmn_err (CE_WARN, "uiomove: Bad count %d (%d)\n", nbytes, + uio->resid); + return EFAULT; + } + + if (uio->kernel_space) + return EFAULT; + + switch (rwflag) + { + case UIO_READ: + c = nbytes; + if (c > 10) + c = 0; + + if ((c = copy_to_user (uio->ptr, address, nbytes) != 0)) + { + uio->resid -= nbytes; + oss_cmn_err (CE_CONT, "copy_to_user(%d) failed (%d)\n", nbytes, c); + return EFAULT; + } + break; + + case UIO_WRITE: + if (copy_from_user (address, uio->ptr, nbytes) != 0) + { + oss_cmn_err (CE_CONT, "copy_from_user failed\n"); + uio->resid -= nbytes; + return EFAULT; + } + break; + } + + uio->resid -= nbytes; + uio->ptr += nbytes; + + return 0; +} + +int +oss_create_uio (uio_t * uio, char *buf, size_t count, uio_rw_t rw, + int is_kernel) +{ + memset (uio, 0, sizeof (*uio)); + + if (is_kernel) + { + oss_cmn_err (CE_CONT, + "oss_create_uio: Kernel space buffers not supported\n"); + return -EIO; + } + + uio->ptr = buf; + uio->resid = count; + uio->kernel_space = is_kernel; + uio->rw = rw; + + return 0; +} + +void +oss_cmn_err (int level, const char *s, ...) +{ + char tmp[1024], *a[6]; + va_list ap; + int i, n = 0; + + va_start (ap, s); + + for (i = 0; i < strlen (s); i++) + if (s[i] == '%') + n++; + + for (i = 0; i < n && i < 6; i++) + a[i] = va_arg (ap, char *); + + for (i = n; i < 6; i++) + a[i] = NULL; + + if (level == CE_CONT) + { + sprintf (tmp, s, a[0], a[1], a[2], a[3], a[4], a[5], NULL, + NULL, NULL, NULL); + printk ("%s", tmp); + } + else + { + strcpy (tmp, "osscore: "); + sprintf (tmp + strlen (tmp), s, a[0], a[1], a[2], a[3], a[4], a[5], + NULL, NULL, NULL, NULL); + if (level == CE_PANIC) + panic (tmp); + + printk (KERN_ALERT "%s", tmp); + } +#if 0 + /* This may cause a crash under SMP */ + if (sound_started) + store_msg (tmp); +#endif + + va_end (ap); +} + +/* + * Sleep/wakeup + */ + +struct oss_wait_queue +{ + volatile int flags; + wait_queue_head_t wq; +}; + +struct oss_wait_queue * +oss_create_wait_queue (oss_device_t * osdev, const char *name) +{ + struct oss_wait_queue *wq; + + if ((wq = vmalloc (sizeof (*wq))) == NULL) + { + oss_cmn_err (CE_WARN, "vmalloc(%d) failed (wq)\n", sizeof (*wq)); + return NULL; + } + init_waitqueue_head (&wq->wq); + + return wq; +} + +void +oss_reset_wait_queue (struct oss_wait_queue *wq) +{ + wq->flags = 0; +} + +void +oss_remove_wait_queue (struct oss_wait_queue *wq) +{ + vfree (wq); +} + +int +oss_sleep (struct oss_wait_queue *wq, oss_mutex_t * mutex, int ticks, + oss_native_word * flags, unsigned int *status) +{ + int result = 0; + *status = 0; + + if (wq == NULL) + return 0; + + wq->flags = 0; + oss_spin_unlock_irqrestore (*mutex, *flags); + + if (ticks <= 0) + result = wait_event_interruptible (wq->wq, (wq->flags & WK_WAKEUP)); + else + result = + wait_event_interruptible_timeout (wq->wq, (wq->flags & WK_WAKEUP), + ticks); + + oss_spin_lock_irqsave (*mutex, flags); + + if (result < 0) /* Signal received */ + { + *status |= WK_SIGNAL; + return 1; + } + + if (!(wq->flags & WK_WAKEUP)) /* Timeout */ + { + return 0; + } + + return 1; +} + +int +oss_register_poll (struct oss_wait_queue *wq, oss_mutex_t * mutex, + oss_native_word * flags, oss_poll_event_t * ev) +{ + oss_spin_unlock_irqrestore (*mutex, *flags); + poll_wait ((struct file *) ev->file, &wq->wq, + (struct poll_table_struct *) ev->wait); + oss_spin_lock_irqsave (*mutex, flags); + return 0; +} + +void +oss_wakeup (struct oss_wait_queue *wq, oss_mutex_t * mutex, + oss_native_word * flags, short events) +{ + if (wq == NULL) + return; + + wq->flags |= WK_WAKEUP; + oss_spin_unlock_irqrestore (*mutex, *flags); + wake_up (&wq->wq); + oss_spin_lock_irqsave (*mutex, flags); +} + +void +oss_reserve_pages (oss_native_word start_addr, oss_native_word end_addr) +{ + struct page *page, *lastpage; + + lastpage = virt_to_page (end_addr); + + for (page = virt_to_page (start_addr); page <= lastpage; page++) + set_bit (PG_reserved, &page->flags); +} + +void +oss_unreserve_pages (oss_native_word start_addr, oss_native_word end_addr) +{ + struct page *page, *lastpage; + + lastpage = virt_to_page (end_addr); + + for (page = virt_to_page (start_addr); page <= lastpage; page++) + clear_bit (PG_reserved, &page->flags); +} + +void * +oss_contig_malloc (oss_device_t * osdev, int buffsize, oss_uint64_t memlimit, + oss_native_word * phaddr) +{ + char *start_addr, *end_addr; + int sz, size; + int flags = 0; + + *phaddr = 0; + +#ifdef GFP_DMA32 + if (memlimit < 0x0000000100000000LL) + flags |= GFP_DMA32; +#endif + + if (memlimit < 0x00000000ffffffffLL) + flags |= GFP_DMA; + + start_addr = NULL; + + for (sz = 0, size = PAGE_SIZE; size < buffsize; sz++, size <<= 1); + + if (buffsize != (PAGE_SIZE * (1 << sz))) + { +#if 0 + printk + ("Contig_malloc: Invalid size %d != %ld\n", buffsize, + PAGE_SIZE * (1 << sz)); +#endif + } + + start_addr = (char *) __get_free_pages (GFP_KERNEL | flags, sz); + + if (start_addr == NULL) + { + cmn_err (CE_NOTE, "Failed to allocate memory buffer of %d bytes\n", + buffsize); + return NULL; + } + else + { + /* make some checks */ + end_addr = start_addr + buffsize - 1; + + oss_reserve_pages ((oss_native_word) start_addr, + (oss_native_word) end_addr); + } + + *phaddr = virt_to_bus (start_addr); + return start_addr; +} + +void +oss_contig_free (oss_device_t * osdev, void *p, int buffsize) +{ + int sz, size; + caddr_t start_addr, end_addr; + + if (p == NULL) + return; + + for (sz = 0, size = PAGE_SIZE; size < buffsize; sz++, size <<= 1); + + start_addr = p; + end_addr = p + buffsize - 1; + + oss_unreserve_pages ((oss_native_word) start_addr, + (oss_native_word) end_addr); + free_pages ((unsigned long) p, sz); +} + +/* + * These typedefs must match definition of struct file_operations. + * (See notes in routine oss_register_chrdev). + */ +typedef ssize_t (*read_t) (struct file *, char *, size_t, loff_t *); +typedef ssize_t (*write_t) (struct file *, const char *, size_t, loff_t *); +typedef unsigned int (*poll_t) (struct file *, poll_table *); +typedef poll_table select_table; + +typedef int (*readdir_t) (struct inode *, struct file *, void *, filldir_t); +typedef int (*ioctl_t) (struct inode *, struct file *, unsigned int, + unsigned long); +typedef long (*new_ioctl_t) (struct file *, unsigned int, unsigned long); +typedef int (*mmap_t) (struct file *, struct vm_area_struct *); +typedef int (*open_t) (struct inode *, struct file *); + +typedef int (*release_t) (struct inode *, struct file *); +typedef int (*fasync_t) (int, struct file *, int); +typedef int (*fsync_t) (struct inode *, struct file *); + +static loff_t +oss_no_llseek (struct file *file, loff_t offset, int orig) +{ + return -EINVAL; +} + +static int +oss_no_fsync (struct file *f, struct dentry *d, int datasync) +{ + return -EINVAL; +} + +static int +oss_no_fasync (int x, struct file *f, int m) +{ + return -EINVAL; +} + +/* + * Wrappers for installing and uninstalling character and block devices. + * + * The oss_file_operation_handle structure differs from kernel's + * file_operations structure in parameters of the driver entry points. + * Kernel inode, file, wait_struct, vm_are_struct etc. typed arguments + * are replaced by wrapper handles. + */ + +static struct file_operations * +alloc_fop (oss_device_t * osdev, struct oss_file_operation_handle *op) +{ +/* + * This routine performs initialization of kernel file_operations structure + * from oss_file_operation_handle structure. Each procedure pointer is copied + * to a temporary variable before doing the actual assignment. This + * prevents unnecessary warnings while it still enables compatibility + * warnings. + * + * Any warning given by this routine may indicate that kernel fs + * call interface has changed significantly (added parameters to the routines). + * In this case definition routine in oss_file_operation_handle must be updated + * and WRAPPER_VERSION must be incremented. + */ + + struct file_operations *fop; + + poll_t tmp_poll = (poll_t) op->poll; + read_t tmp_read = (read_t) op->read; + write_t tmp_write = (write_t) op->write; + /* readdir_t tmp_readdir = (readdir_t)op->readdir; */ +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,35) + ioctl_t tmp_ioctl = (ioctl_t) op->ioctl; +#endif + mmap_t tmp_mmap = (mmap_t) op->mmap; + open_t tmp_open = (open_t) op->open; + release_t tmp_release = (release_t) op->release; + new_ioctl_t tmp_unlocked_ioctl = (new_ioctl_t) op->unlocked_ioctl; + new_ioctl_t tmp_compat_ioctl = (new_ioctl_t) op->compat_ioctl; + + fop = (struct file_operations *) + oss_kmem_alloc (sizeof (struct file_operations)); + + memset ((char *) fop, 0, sizeof (struct file_operations)); + +/* + * Now the assignment + */ + fop->llseek = oss_no_llseek; + fop->read = tmp_read; + fop->write = tmp_write; + fop->readdir = NULL; /* tmp_readdir; */ + fop->poll = tmp_poll; +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,35) + fop->ioctl = tmp_ioctl; +#endif + fop->mmap = tmp_mmap; + fop->open = tmp_open; + fop->release = tmp_release; + fop->fsync = oss_no_fsync; + fop->fasync = oss_no_fasync; + fop->lock = NULL; + fop->flush = NULL; +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) + fop->owner = osdev_get_owner (osdev); +#endif +#ifdef HAVE_UNLOCKED_IOCTL + fop->unlocked_ioctl = tmp_unlocked_ioctl; +#endif +#ifdef HAVE_COMPAT_IOCTL + fop->compat_ioctl = tmp_compat_ioctl; +#endif + + return fop; +} + +int +oss_register_chrdev (oss_device_t * osdev, unsigned int major, + const char *name, struct oss_file_operation_handle *op) +{ + int maj; + maj = register_chrdev (major, name, alloc_fop (osdev, op)); + + return maj; +} + +void +oss_register_minor (int major, int minor, char *name) +{ + if (nminors >= MAX_MINOR) + { + oss_cmn_err (CE_WARN, "Too many device files\n"); + return; + } + + minors[nminors].major = major; + minors[nminors].minor = minor; + strcpy (minors[nminors].name, name); + nminors++; +} + +int +oss_unregister_chrdev (unsigned int major, const char *name) +{ + unregister_chrdev (major, name); + return 0; +} + +int +oss_inode_get_minor (oss_inode_handle_t * inode) +{ + return MINOR (((struct inode *) inode)->i_rdev); +} + +int +oss_file_get_flags (oss_file_handle_t * file) +{ + return ((struct file *) file)->f_flags; +} + +void * +oss_file_get_private (oss_file_handle_t * file) +{ + return ((struct file *) file)->private_data; +} + +void +oss_file_set_private (oss_file_handle_t * file, void *v) +{ + ((struct file *) file)->private_data = v; +} + +int +oss_vma_get_flags (oss_vm_area_handle_t * vma) +{ + return ((struct vm_area_struct *) vma)->vm_flags; +} + +int +oss_do_mmap (oss_vm_area_handle_t * v, oss_native_word dmabuf_phys, + int bytes_in_use) +{ + struct vm_area_struct *vma = (struct vm_area_struct *) v; + int res, size; + + if (vma->vm_pgoff != 0) + { + oss_cmn_err (CE_WARN, "mmap() offset must be 0.\n"); + return -EINVAL; + } + + size = vma->vm_end - vma->vm_start; + + if (size != bytes_in_use) + { + oss_cmn_err (CE_WARN, "mmap() size = %ld. Should be %d\n", + size, bytes_in_use); + return -EBUSY; + } + +#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,13) + res = io_remap_page_range (vma, vma->vm_start, + dmabuf_phys, size, vma->vm_page_prot); + +#else + res = io_remap_pfn_range (vma, vma->vm_start, + dmabuf_phys >> PAGE_SHIFT, + size, vma->vm_page_prot); +#endif + + if (res) + { + oss_cmn_err (CE_WARN, "io_remap_pfn_range returned %d\n", res); + return -EAGAIN; + } + + return 0; +} + +/* As a special exception, if you link this library with other files, + some of which are compiled with GCC, to produce an executable, + this library does not by itself cause the resulting executable + to be covered by the GNU General Public License. + This exception does not however invalidate any other reasons why + the executable file might be covered by the GNU General Public License. */ + +typedef unsigned int UQItype __attribute__ ((mode (QI))); +typedef int SItype __attribute__ ((mode (SI))); +typedef unsigned int USItype __attribute__ ((mode (SI))); +typedef int DItype __attribute__ ((mode (DI))); +typedef unsigned int UDItype __attribute__ ((mode (DI))); + +typedef int word_type __attribute__ ((mode (__word__))); + +/* DIstructs are pairs of SItype values in the order determined by + little/big ENDIAN. */ + +#if defined(__i386__) || defined(__x86_64__) +struct DIstruct +{ + SItype low, high; +}; +#endif + + +#ifndef __arm__ +/* We need this union to unpack/pack DImode values, since we don't have + any arithmetic yet. Incoming DImode parameters are stored into the + `ll' field, and the unpacked result is read from the struct `s'. */ + +typedef union +{ + struct DIstruct s; + DItype ll; +} DIunion; + + +/* From gcc/longlong.h */ + +#ifndef SI_TYPE_SIZE +#define SI_TYPE_SIZE 32 +#endif + +#define __BITS4 (SI_TYPE_SIZE / 4) +#define __ll_B (1L << (SI_TYPE_SIZE / 2)) +#define __ll_lowpart(t) ((USItype) (t) % __ll_B) +#define __ll_highpart(t) ((USItype) (t) / __ll_B) + +#if defined(__i386__) || defined(__x86_64__) +#define sub_ddmmss(sh, sl, ah, al, bh, bl) \ + __asm__ ("subl %5,%1\n" \ + "sbbl %3,%0" \ + : "=r" ((USItype) (sh)), \ + "=&r" ((USItype) (sl)) \ + : "0" ((USItype) (ah)), \ + "g" ((USItype) (bh)), \ + "1" ((USItype) (al)), \ + "g" ((USItype) (bl))) +#define umul_ppmm(w1, w0, u, v) \ + __asm__ ("mull %3" \ + : "=a" ((USItype) (w0)), \ + "=d" ((USItype) (w1)) \ + : "%0" ((USItype) (u)), \ + "rm" ((USItype) (v))) +#define udiv_qrnnd(q, r, n1, n0, d) \ + __asm__ ("divl %4" \ + : "=a" ((USItype) (q)), \ + "=d" ((USItype) (r)) \ + : "0" ((USItype) (n0)), \ + "1" ((USItype) (n1)), \ + "rm" ((USItype) (d))) +#define count_leading_zeros(count, x) \ + do { \ + USItype __cbtmp; \ + __asm__ ("bsrl %1,%0" \ + : "=r" (__cbtmp) : "rm" ((USItype) (x))); \ + (count) = __cbtmp ^ 31; \ + } while (0) +#endif /* __i386__ */ + +/* If this machine has no inline assembler, use C macros. */ + +/* Define this unconditionally, so it can be used for debugging. */ +#define __udiv_qrnnd_c(q, r, n1, n0, d) \ + do { \ + USItype __d1, __d0, __q1, __q0; \ + USItype __r1, __r0, __m; \ + __d1 = __ll_highpart (d); \ + __d0 = __ll_lowpart (d); \ + \ + __r1 = (n1) % __d1; \ + __q1 = (n1) / __d1; \ + __m = (USItype) __q1 * __d0; \ + __r1 = __r1 * __ll_B | __ll_highpart (n0); \ + if (__r1 < __m) \ + { \ + __q1--, __r1 += (d); \ + if (__r1 >= (d)) /* i.e. we didn't get carry when adding to __r1 */\ + if (__r1 < __m) \ + __q1--, __r1 += (d); \ + } \ + __r1 -= __m; \ + \ + __r0 = __r1 % __d1; \ + __q0 = __r1 / __d1; \ + __m = (USItype) __q0 * __d0; \ + __r0 = __r0 * __ll_B | __ll_lowpart (n0); \ + if (__r0 < __m) \ + { \ + __q0--, __r0 += (d); \ + if (__r0 >= (d)) \ + if (__r0 < __m) \ + __q0--, __r0 += (d); \ + } \ + __r0 -= __m; \ + \ + (q) = (USItype) __q1 * __ll_B | __q0; \ + (r) = __r0; \ + } while (0) + +/* If udiv_qrnnd was not defined for this processor, use __udiv_qrnnd_c. */ +#if !defined (udiv_qrnnd) +#define UDIV_NEEDS_NORMALIZATION 1 +#define udiv_qrnnd __udiv_qrnnd_c +#endif + +/* End of gcc/longlong.h */ + + +static inline DItype +__negdi2 (DItype u) +{ + DIunion w; + DIunion uu; + + uu.ll = u; + + w.s.low = -uu.s.low; + w.s.high = -uu.s.high - ((USItype) w.s.low > 0); + + return w.ll; +} + +static inline UDItype +__udivmoddi4 (UDItype n, UDItype d, UDItype * rp) +{ + DIunion ww; + DIunion nn, dd; + DIunion rr; + USItype d0, d1, n0, n1, n2; + USItype q0, q1; + USItype b, bm; + + nn.ll = n; + dd.ll = d; + + d0 = dd.s.low; + d1 = dd.s.high; + n0 = nn.s.low; + n1 = nn.s.high; + +#ifndef UDIV_NEEDS_NORMALIZATION + if (d1 == 0) + { + if (d0 > n1) + { + /* 0q = nn / 0D */ + + udiv_qrnnd (q0, n0, n1, n0, d0); + q1 = 0; + + /* Remainder in n0. */ + } + else + { + /* qq = NN / 0d */ + + if (d0 == 0) + d0 = 1 / d0; /* Divide intentionally by zero. */ + + udiv_qrnnd (q1, n1, 0, n1, d0); + udiv_qrnnd (q0, n0, n1, n0, d0); + + /* Remainder in n0. */ + } + + if (rp != 0) + { + rr.s.low = n0; + rr.s.high = 0; + *rp = rr.ll; + } + } + +#else /* UDIV_NEEDS_NORMALIZATION */ + + if (d1 == 0) + { + if (d0 > n1) + { + /* 0q = nn / 0D */ + + count_leading_zeros (bm, d0); + + if (bm != 0) + { + /* Normalize, i.e. make the most significant bit of the + denominator set. */ + + d0 = d0 << bm; + n1 = (n1 << bm) | (n0 >> (SI_TYPE_SIZE - bm)); + n0 = n0 << bm; + } + + udiv_qrnnd (q0, n0, n1, n0, d0); + q1 = 0; + + /* Remainder in n0 >> bm. */ + } + else + { + /* qq = NN / 0d */ + + if (d0 == 0) + d0 = 1 / d0; /* Divide intentionally by zero. */ + + count_leading_zeros (bm, d0); + + if (bm == 0) + { + /* From (n1 >= d0) /\ (the most significant bit of d0 is set), + conclude (the most significant bit of n1 is set) /\ (the + leading quotient digit q1 = 1). + + This special case is necessary, not an optimization. + (Shifts counts of SI_TYPE_SIZE are undefined.) */ + + n1 -= d0; + q1 = 1; + } + else + { + /* Normalize. */ + + b = SI_TYPE_SIZE - bm; + + d0 = d0 << bm; + n2 = n1 >> b; + n1 = (n1 << bm) | (n0 >> b); + n0 = n0 << bm; + + udiv_qrnnd (q1, n1, n2, n1, d0); + } + + /* n1 != d0... */ + + udiv_qrnnd (q0, n0, n1, n0, d0); + + /* Remainder in n0 >> bm. */ + } + + if (rp != 0) + { + rr.s.low = n0 >> bm; + rr.s.high = 0; + *rp = rr.ll; + } + } +#endif /* UDIV_NEEDS_NORMALIZATION */ + + else + { + if (d1 > n1) + { + /* 00 = nn / DD */ + + q0 = 0; + q1 = 0; + + /* Remainder in n1n0. */ + if (rp != 0) + { + rr.s.low = n0; + rr.s.high = n1; + *rp = rr.ll; + } + } + else + { + /* 0q = NN / dd */ + + count_leading_zeros (bm, d1); + if (bm == 0) + { + /* From (n1 >= d1) /\ (the most significant bit of d1 is set), + conclude (the most significant bit of n1 is set) /\ (the + quotient digit q0 = 0 or 1). + + This special case is necessary, not an optimization. */ + + /* The condition on the next line takes advantage of that + n1 >= d1 (true due to program flow). */ + if (n1 > d1 || n0 >= d0) + { + q0 = 1; + sub_ddmmss (n1, n0, n1, n0, d1, d0); + } + else + q0 = 0; + + q1 = 0; + + if (rp != 0) + { + rr.s.low = n0; + rr.s.high = n1; + *rp = rr.ll; + } + } + else + { + USItype m1, m0; + /* Normalize. */ + + b = SI_TYPE_SIZE - bm; + + d1 = (d1 << bm) | (d0 >> b); + d0 = d0 << bm; + n2 = n1 >> b; + n1 = (n1 << bm) | (n0 >> b); + n0 = n0 << bm; + + udiv_qrnnd (q0, n1, n2, n1, d1); + umul_ppmm (m1, m0, q0, d0); + + if (m1 > n1 || (m1 == n1 && m0 > n0)) + { + q0--; + sub_ddmmss (m1, m0, m1, m0, d1, d0); + } + + q1 = 0; + + /* Remainder in (n1n0 - m1m0) >> bm. */ + if (rp != 0) + { + sub_ddmmss (n1, n0, n1, n0, m1, m0); + rr.s.low = (n1 << b) | (n0 >> bm); + rr.s.high = n1 >> bm; + *rp = rr.ll; + } + } + } + } + + ww.s.low = q0; + ww.s.high = q1; + return ww.ll; +} + +DItype +__divdi3 (DItype u, DItype v) +{ + word_type c = 0; + DIunion uu, vv; + DItype w; + + uu.ll = u; + vv.ll = v; + + if (uu.s.high < 0) + c = ~c, uu.ll = __negdi2 (uu.ll); + if (vv.s.high < 0) + c = ~c, vv.ll = __negdi2 (vv.ll); + + w = __udivmoddi4 (uu.ll, vv.ll, (UDItype *) 0); + if (c) + w = __negdi2 (w); + + return w; +} + + +DItype +__moddi3 (DItype u, DItype v) +{ + word_type c = 0; + DIunion uu, vv; + DItype w; + + uu.ll = u; + vv.ll = v; + + if (uu.s.high < 0) + c = ~c, uu.ll = __negdi2 (uu.ll); + if (vv.s.high < 0) + vv.ll = __negdi2 (vv.ll); + + (void) __udivmoddi4 (uu.ll, vv.ll, (UDItype *) & w); + if (c) + w = __negdi2 (w); + + return w; +} + + +UDItype +__umoddi3 (UDItype u, UDItype v) +{ + UDItype w; + + (void) __udivmoddi4 (u, v, (UDItype *) & w); + + return w; +} + + +UDItype +__udivdi3 (UDItype n, UDItype d) +{ + return __udivmoddi4 (n, d, (UDItype *) 0); +} +#endif + +#ifdef __arm__ +void +raise(void) +{ + oss_cmn_err (CE_PANIC, "raise() got called\n"); +} + +#endif + +dev_info_t * +oss_create_pcidip (struct pci_dev * pcidev) +{ + dev_info_t *dip; + + if ((dip = oss_pmalloc (sizeof (*dip))) == NULL) + return NULL; + + memset (dip, 0, sizeof (*dip)); + dip->pcidev = pcidev; + + return dip; +} + +int +osscore_pci_read_config_byte (dev_info_t * dip, unsigned int where, + unsigned char *val) +{ + return pci_read_config_byte (dip->pcidev, where, val); +} + +int +osscore_pci_read_config_irq (dev_info_t * dip, unsigned int where, + unsigned char *val) +{ + *val = dip->pcidev->irq; + return 0; // PCIBIOS_SUCCESSFUL +} + +int +osscore_pci_read_config_word (dev_info_t * dip, unsigned int where, + unsigned short *val) +{ + if (dip == NULL) + { + oss_cmn_err (CE_CONT, "osscore_pci_read_config_word: dip==NULL\n"); + return -1; + } + return pci_read_config_word (dip->pcidev, where, val); +} + +int +osscore_pci_read_config_dword (dev_info_t * dip, unsigned int where, + unsigned int *val) +{ + return pci_read_config_dword (dip->pcidev, where, val); +} + +int +osscore_pci_write_config_byte (dev_info_t * dip, unsigned int where, + unsigned char val) +{ + return pci_write_config_byte (dip->pcidev, where, val); +} + +int +osscore_pci_write_config_word (dev_info_t * dip, unsigned int where, + unsigned short val) +{ + return pci_write_config_word (dip->pcidev, where, val); +} + +int +osscore_pci_write_config_dword (dev_info_t * dip, unsigned int where, + unsigned int val) +{ + return pci_write_config_dword (dip->pcidev, where, val); +} + +int +osscore_pci_enable_msi (dev_info_t * dip) +{ + pci_enable_msi (dip->pcidev); + return (dip->pcidev->irq); +} + +/* These definitions must match with oss_config.h */ +typedef int (*oss_tophalf_handler_t) (struct _oss_device_t * osdev); +typedef void (*oss_bottomhalf_handler_t) (struct _oss_device_t * osdev); + +typedef struct +{ + int irq; + oss_device_t *osdev; + oss_tophalf_handler_t top; + oss_bottomhalf_handler_t bottom; +} osscore_intr_t; + +#define MAX_INTRS 32 + +static osscore_intr_t intrs[MAX_INTRS] = { {0} }; +static int nintrs = 0; + +static irqreturn_t +osscore_intr (int irq, void *arg) +{ + int serviced; + osscore_intr_t *intr = arg; + + if (intr->osdev == NULL || intr->top == NULL) /* Removed interrupt */ + return 0; + + serviced = intr->top (intr->osdev); + oss_inc_intrcount (intr->osdev, serviced); + if (serviced) + { + if (intr->bottom != NULL) + intr->bottom (intr->osdev); + return IRQ_HANDLED; + } + return IRQ_NONE; +} + +extern int oss_pci_read_config_irq (oss_device_t * osdev, unsigned long where, + unsigned char *val); + +char * +oss_pci_read_devpath (dev_info_t * dip) +{ +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30) + return dev_name(&dip->pcidev->dev); +#else + return dip->pcidev->dev.bus_id; +#endif +} + +int +oss_register_interrupts (oss_device_t * osdev, int irqnum, + oss_tophalf_handler_t top, + oss_bottomhalf_handler_t bottom) +{ + + unsigned char pci_irq_line; + osscore_intr_t *intr; + char *name; + int err; + + if (nintrs >= MAX_INTRS) + { + oss_cmn_err (CE_CONT, + "oss_register_interrupts: Too many interrupt handlers\n"); + return -ENOMEM; + } + + intr = &intrs[nintrs]; + + if (oss_pci_read_config_irq (osdev, PCI_INTERRUPT_LINE, &pci_irq_line) > 0) + return -EIO; + + intr->irq = pci_irq_line; + intr->osdev = osdev; + intr->top = top; + intr->bottom = bottom; + + name = osdev_get_nick (osdev); +#ifndef IRQF_SHARED +#define IRQF_SHARED SA_SHIRQ +#endif + + if ((err = + request_irq (pci_irq_line, osscore_intr, IRQF_SHARED, name, intr)) < 0) + { + oss_cmn_err (CE_CONT, "request_irq(%d) failed, err=%d\n", pci_irq_line, + err); + return err; + } + + nintrs++; + + return 0; +} + +void +oss_unregister_interrupts (oss_device_t * osdev) +{ + int i; + + for (i = 0; i < nintrs; i++) + if (intrs[i].osdev == osdev) + { + free_irq (intrs[i].irq, &intrs[i]); + intrs[i].osdev = NULL; + intrs[i].top = NULL; + intrs[i].bottom = NULL; + } +} + +int +oss_copy_to_user (void *to, const void *from, unsigned long n) +{ + return copy_to_user (to, from, n); +} + +int +oss_copy_from_user (void *to, const void *from, unsigned long n) +{ + return copy_from_user (to, from, n); +} + +static int refcount = 0; + +typedef struct +{ + struct module *module; + int active; +} oss_module_t; + +#define OSS_MAX_MODULES 50 + +static oss_module_t oss_modules[OSS_MAX_MODULES]; +static int num_oss_modules = 0; + +void +oss_inc_refcounts (void) +{ + int i; + refcount++; + for (i = 0; i < num_oss_modules; i++) + if (oss_modules[i].active) + { + if (!try_module_get (oss_modules[i].module)) + oss_cmn_err (CE_WARN, "try_module_get() failed\n"); + } +} + +void +oss_dec_refcounts (void) +{ + int i; + refcount--; + for (i = 0; i < num_oss_modules; i++) + if (oss_modules[i].active) + { + module_put (oss_modules[i].module); + } +} + +void +oss_register_module (struct module *mod) +{ + int i, n = -1; + + for (i = 0; i < num_oss_modules; i++) + if (!oss_modules[i].active) + { + n = i; + break; + } + + if (n == -1) + { + if (num_oss_modules >= OSS_MAX_MODULES) + { + printk (KERN_ALERT "Too many OSS modules\n"); + return; + } + + n = num_oss_modules++; + } + + oss_modules[n].module = mod; + oss_modules[n].active = 1; +} + +void +oss_unregister_module (struct module *mod) +{ + int i; + + for (i = 0; i < num_oss_modules; i++) + if (oss_modules[i].active && oss_modules[i].module == mod) + { + oss_modules[i].active = 0; + oss_modules[i].module = NULL; + return; + } +} + +module_init (osscore_init); +module_exit (osscore_exit); + +#ifdef CONFIG_OSS_VMIX_FLOAT + +#define FP_SAVE(envbuf) asm ("fnsave %0":"=m" (*envbuf)); +#define FP_RESTORE(envbuf) asm ("frstor %0":"=m" (*envbuf)); + +/* SSE/SSE2 compatible macros */ +#define FX_SAVE(envbuf) asm ("fxsave %0":"=m" (*envbuf)); +#define FX_RESTORE(envbuf) asm ("fxrstor %0":"=m" (*envbuf)); + +static int old_arch = 0; /* No SSE/SSE2 instructions */ + +#if 0 +static inline unsigned long +read_cr0 (void) +{ + unsigned long cr0; + asm volatile ("movq %%cr0,%0":"=r" (cr0)); + return cr0; +} + +static inline void +write_cr0 (unsigned long val) +{ + asm volatile ("movq %0,%%cr0"::"r" (val)); +} + +static inline unsigned long +read_cr4 (void) +{ + unsigned long cr4; + asm volatile ("movq %%cr4,%0":"=r" (cr4)); + return cr4; +} + +static inline void +write_cr4 (unsigned long val) +{ + asm volatile ("movq %0,%%cr4"::"r" (val)); +} +#endif + +static inline unsigned long long +read_mxcsr (void) +{ + unsigned long long mxcsr; + asm volatile ("stmxcsr %0":"=m" (mxcsr)); + return mxcsr; +} + +static inline void +write_mxcsr (unsigned long long val) +{ + asm volatile ("ldmxcsr %0"::"m" (val)); +} + +int +oss_fp_check (void) +{ + int eax, ebx, ecx, edx; +#define FLAGS_ID (1<<21) + + oss_native_word flags_reg; + + local_save_flags (flags_reg); + flags_reg &= ~FLAGS_ID; + local_irq_restore (flags_reg); + + local_save_flags (flags_reg); + if (flags_reg & FLAGS_ID) + return 0; + + flags_reg |= FLAGS_ID; + local_irq_restore (flags_reg); + + local_save_flags (flags_reg); + if (!(flags_reg & FLAGS_ID)) + return 0; + +#define CPUID_FXSR (1<<24) +#define CPUID_SSE (1<<25) +#define CPUID_SSE2 (1<<26) + + cpuid (1, &eax, &ebx, &ecx, &edx); + + if (!(edx & CPUID_FXSR)) + return -1; + + /* + * Older machines require different FP handling than the latest ones. Use the SSE + * instruction set as an indicator. + */ + if (!(edx & CPUID_SSE)) + old_arch = 1; + + return 1; +} + +void +oss_fp_save (short *envbuf, unsigned int flags[]) +{ + flags[0] = read_cr0 (); + write_cr0 (flags[0] & ~0x0e); /* Clear CR0.TS/MP/EM */ + + if (old_arch) + { + FP_SAVE (envbuf); + } + else + { + flags[1] = read_cr4 (); + write_cr4 (flags[1] | 0x600); /* Set OSFXSR & OSXMMEXCEPT */ + FX_SAVE (envbuf); + asm ("fninit"); + asm ("fwait"); + write_mxcsr (0x1f80); + } + flags[2] = read_cr0 (); +} + +void +oss_fp_restore (short *envbuf, unsigned int flags[]) +{ + asm ("fwait"); + if (old_arch) + { + FP_RESTORE (envbuf); + } + else + { + FX_RESTORE (envbuf); + write_cr4 (flags[1]); /* Restore cr4 */ + } + write_cr0 (flags[0]); /* Restore cr0 */ +} +#endif + +#if 0 +void +__stack_chk_fail (void) +{ + panic ("__stack_chk_fail\n"); +} +#endif + +/* + * Exported symbols + */ + +#define EXPORT_FUNC(name) extern void name(void);EXPORT_SYMBOL(name); +#define EXPORT_DATA(name) extern int name;EXPORT_SYMBOL(name); + +/* EXPORT_SYMBOL (__stack_chk_fail); */ + +#ifdef CONFIG_OSS_VMIX_FLOAT +EXPORT_SYMBOL (oss_fp_check); +EXPORT_SYMBOL (oss_fp_save); +EXPORT_SYMBOL (oss_fp_restore); +#endif + +EXPORT_SYMBOL (oss_register_chrdev); +EXPORT_SYMBOL (oss_unregister_chrdev); +EXPORT_SYMBOL (oss_reserve_pages); +EXPORT_SYMBOL (oss_unreserve_pages); +EXPORT_FUNC (ac97_install); +EXPORT_FUNC (ac97_install_full); +EXPORT_FUNC (ac97_playrate); +EXPORT_FUNC (ac97_recrate); +EXPORT_FUNC (ac97_varrate); +EXPORT_FUNC (ac97_override_control); +EXPORT_FUNC (ac97_init_ext); +EXPORT_FUNC (ac97_mixer_set); +EXPORT_FUNC (ac97_spdif_setup); +EXPORT_FUNC (ac97_spdifout_ctl); +EXPORT_FUNC (ac97_remove_control); +EXPORT_SYMBOL (ac97_amplifier); +EXPORT_FUNC (ac97_disable_spdif); +EXPORT_FUNC (ac97_enable_spdif); +EXPORT_FUNC (ac97_mixext_ctl); +EXPORT_FUNC (ac97_spdifin_ctl); +EXPORT_FUNC (oss_pci_byteswap); +EXPORT_SYMBOL (mixer_ext_truncate); +EXPORT_SYMBOL (mixer_ext_rebuild_all); +EXPORT_FUNC (remux_install); +EXPORT_SYMBOL (oss_strlen); +EXPORT_SYMBOL (oss_strcmp); +EXPORT_FUNC (oss_install_mididev); +EXPORT_DATA (detect_trace); +EXPORT_SYMBOL (dmap_get_qhead); +EXPORT_SYMBOL (dmap_get_qtail); +EXPORT_FUNC (oss_alloc_dmabuf); +EXPORT_SYMBOL (oss_contig_free); +EXPORT_SYMBOL (oss_contig_malloc); +EXPORT_FUNC (oss_disable_device); +EXPORT_FUNC (oss_free_dmabuf); +EXPORT_SYMBOL (oss_map_pci_mem); +EXPORT_SYMBOL (oss_install_audiodev); +EXPORT_SYMBOL (oss_install_audiodev_with_devname); +EXPORT_FUNC (oss_audio_set_error); +EXPORT_SYMBOL (load_mixer_volumes); +EXPORT_SYMBOL (oss_unmap_pci_mem); +EXPORT_SYMBOL (oss_memset); +EXPORT_SYMBOL (oss_mutex_cleanup); +EXPORT_SYMBOL (oss_mutex_init); +EXPORT_SYMBOL (oss_register_device); +EXPORT_SYMBOL (oss_register_interrupts); +EXPORT_SYMBOL (oss_inc_intrcount); +EXPORT_SYMBOL (oss_spin_lock); +EXPORT_SYMBOL (oss_spin_lock_irqsave); +EXPORT_SYMBOL (oss_spin_unlock); +EXPORT_SYMBOL (oss_spin_unlock_irqrestore); +EXPORT_SYMBOL (oss_udelay); +EXPORT_FUNC (oss_unregister_device); +EXPORT_SYMBOL (oss_unregister_interrupts); +EXPORT_SYMBOL (oss_virt_to_bus); +EXPORT_FUNC (oss_pci_read_config_byte); +EXPORT_FUNC (oss_pci_read_config_word); +EXPORT_FUNC (oss_pci_read_config_dword); +EXPORT_FUNC (oss_pci_write_config_byte); +EXPORT_FUNC (oss_pci_write_config_word); +EXPORT_FUNC (oss_pci_write_config_dword); +EXPORT_FUNC (oss_pci_enable_msi); +EXPORT_SYMBOL (oss_pci_read_config_irq); +EXPORT_SYMBOL (oss_pci_read_devpath); +EXPORT_SYMBOL (oss_get_jiffies); +EXPORT_SYMBOL (mixer_find_ext); +EXPORT_SYMBOL (oss_install_mixer); +EXPORT_SYMBOL (oss_strcpy); +EXPORT_SYMBOL (oss_kmem_free); +#ifndef __arm__ +EXPORT_FUNC (uart401_init); +EXPORT_FUNC (uart401_disable); +EXPORT_FUNC (uart401_irq); +#endif +EXPORT_SYMBOL (mixer_ext_set_init_fn); +EXPORT_SYMBOL (mixer_ext_set_vmix_init_fn); +#ifdef CONFIG_OSS_VMIX +EXPORT_FUNC (vmix_attach_audiodev); +EXPORT_FUNC (vmix_detach_audiodev); +EXPORT_FUNC (vmix_change_devnames); +#endif +EXPORT_SYMBOL (mixer_ext_set_strings); +EXPORT_SYMBOL (mixer_ext_create_group); +EXPORT_SYMBOL (mixer_ext_create_group_flags); +EXPORT_SYMBOL (mixer_ext_create_control); +EXPORT_SYMBOL (oss_strncpy); +EXPORT_SYMBOL (oss_memcpy); +EXPORT_SYMBOL (oss_kmem_alloc); +EXPORT_DATA (oss_hz); +EXPORT_FUNC (oss_spdif_open); +EXPORT_FUNC (oss_spdif_ioctl); +EXPORT_FUNC (oss_spdif_install); +EXPORT_FUNC (oss_spdif_uninstall); +EXPORT_FUNC (oss_spdif_close); +EXPORT_FUNC (oss_spdif_mix_init); +EXPORT_FUNC (oss_spdif_setrate); +EXPORT_FUNC (create_new_card); +EXPORT_FUNC (oss_audio_ioctl); +EXPORT_FUNC (oss_audio_open_engine); +EXPORT_FUNC (oss_audio_release); +EXPORT_FUNC (oss_audio_set_rate); +EXPORT_SYMBOL (oss_uiomove); +EXPORT_SYMBOL (oss_get_pid); +EXPORT_SYMBOL (oss_get_uid); +EXPORT_SYMBOL (oss_get_procname); +EXPORT_SYMBOL (mix_cvt); +EXPORT_FUNC (oss_audio_set_format); +EXPORT_FUNC (oss_audio_set_channels); +EXPORT_FUNC (midiparser_create); +EXPORT_FUNC (midiparser_input); +EXPORT_FUNC (midiparser_unalloc); +EXPORT_FUNC (mixer_ext_create_device); +EXPORT_SYMBOL (mixer_ext_recrw); +EXPORT_SYMBOL (mixer_ext_rw); +EXPORT_SYMBOL (mixer_ext_set_enum); +EXPORT_SYMBOL (mixer_ext_set_description); +EXPORT_SYMBOL (osdev_create); +EXPORT_FUNC (osdev_clone); +EXPORT_SYMBOL (osdev_delete); +EXPORT_FUNC (oss_audio_chpoll); +EXPORT_FUNC (oss_audio_delayed_attach); +EXPORT_FUNC (oss_audio_read); +EXPORT_FUNC (oss_audio_write); +EXPORT_SYMBOL (oss_create_wait_queue); +EXPORT_SYMBOL (oss_remove_wait_queue); +EXPORT_SYMBOL (oss_reset_wait_queue); +EXPORT_SYMBOL (oss_sleep); +EXPORT_SYMBOL (oss_strncmp); +EXPORT_SYMBOL (oss_timeout); +EXPORT_SYMBOL (oss_untimeout); +EXPORT_SYMBOL (oss_wakeup); +#if 0 +EXPORT_FUNC (ossddk_ac97_install); +EXPORT_FUNC (ossddk_ac97_is_varrate); +EXPORT_FUNC (ossddk_ac97_remove); +EXPORT_FUNC (ossddk_ac97_set_ext_init); +EXPORT_FUNC (ossddk_ac97_set_playrate); +EXPORT_FUNC (ossddk_ac97_set_recrate); +EXPORT_FUNC (ossddk_adev_get_devc); +EXPORT_FUNC (ossddk_adev_get_dmapin); +EXPORT_FUNC (ossddk_adev_get_dmapout); +EXPORT_FUNC (ossddk_adev_get_flags); +EXPORT_FUNC (ossddk_adev_get_label); +EXPORT_FUNC (ossddk_adev_get_portc); +EXPORT_FUNC (ossddk_adev_get_portc_play); +EXPORT_FUNC (ossddk_adev_get_portc_record); +EXPORT_FUNC (ossddk_adev_get_songname); +EXPORT_FUNC (ossddk_adev_set_buflimits); +EXPORT_FUNC (ossddk_adev_set_caps); +EXPORT_FUNC (ossddk_adev_set_channels); +EXPORT_FUNC (ossddk_adev_set_devc); +EXPORT_FUNC (ossddk_adev_set_enable_flag); +EXPORT_FUNC (ossddk_adev_set_flags); +EXPORT_FUNC (ossddk_adev_set_formats); +EXPORT_FUNC (ossddk_adev_set_label); +EXPORT_FUNC (ossddk_adev_set_magic); +EXPORT_FUNC (ossddk_adev_set_mixer); +EXPORT_FUNC (ossddk_adev_set_portc); +EXPORT_FUNC (ossddk_adev_set_portc_play); +EXPORT_FUNC (ossddk_adev_set_portc_record); +EXPORT_FUNC (ossddk_adev_set_portnum); +EXPORT_FUNC (ossddk_adev_set_rates); +EXPORT_FUNC (ossddk_adev_set_ratesource); +EXPORT_FUNC (ossddk_adev_set_songname); +EXPORT_FUNC (ossddk_adev_set_unloaded_flag); +EXPORT_FUNC (ossddk_audio_inputintr); +EXPORT_FUNC (ossddk_audio_outputintr); +EXPORT_FUNC (ossddk_disable_device); +EXPORT_FUNC (ossddk_dmap_get_buffsize); +EXPORT_FUNC (ossddk_dmap_get_buffused); +EXPORT_FUNC (ossddk_dmap_get_dmabuf); +EXPORT_FUNC (ossddk_dmap_get_fragsize); +EXPORT_FUNC (ossddk_dmap_get_numfrags); +EXPORT_FUNC (ossddk_dmap_get_phys); +EXPORT_FUNC (ossddk_dmap_get_private); +EXPORT_FUNC (ossddk_dmap_get_qhead); +EXPORT_FUNC (ossddk_dmap_get_qtail); +EXPORT_FUNC (ossddk_dmap_set_buffsize); +EXPORT_FUNC (ossddk_dmap_set_callback); +EXPORT_FUNC (ossddk_dmap_set_dmabuf); +EXPORT_FUNC (ossddk_dmap_set_fragsize); +EXPORT_FUNC (ossddk_dmap_set_numfrags); +EXPORT_FUNC (ossddk_dmap_set_phys); +EXPORT_FUNC (ossddk_dmap_set_playerror); +EXPORT_FUNC (ossddk_dmap_set_private); +EXPORT_FUNC (ossddk_dmap_set_recerror); +EXPORT_FUNC (ossddk_install_audiodev); +EXPORT_FUNC (ossddk_install_mixer); +EXPORT_FUNC (ossddk_mixer_create_control); +EXPORT_FUNC (ossddk_mixer_create_group); +EXPORT_FUNC (ossddk_mixer_get_devc); +EXPORT_FUNC (ossddk_mixer_set_strings); +EXPORT_FUNC (ossddk_mixer_touch); +EXPORT_FUNC (ossddk_mixer_truncate); +EXPORT_FUNC (ossddk_osdev_get_devc); +EXPORT_FUNC (ossddk_register_device); +EXPORT_FUNC (ossddk_unregister_device); +#endif +EXPORT_SYMBOL (osdev_set_major); +EXPORT_SYMBOL (osdev_set_owner); +EXPORT_SYMBOL (osdev_get_owner); +EXPORT_SYMBOL (oss_create_pcidip); +EXPORT_SYMBOL (touch_mixer); +EXPORT_SYMBOL (oss_mixer_ext); +EXPORT_SYMBOL (oss_request_major); +EXPORT_SYMBOL (audio_engines); +EXPORT_DATA (midi_devs); +EXPORT_SYMBOL (mixer_devs); +EXPORT_SYMBOL (mixer_devs_p); +EXPORT_DATA (num_audio_engines); +EXPORT_DATA (num_mididevs); +EXPORT_SYMBOL (num_mixers); +EXPORT_DATA (oss_timing_mutex); +EXPORT_DATA (oss_num_cards); +EXPORT_FUNC (oss_do_timing); +EXPORT_FUNC (oss_do_timing2); +EXPORT_FUNC (oss_timing_enter); +EXPORT_FUNC (oss_timing_leave); +#ifndef __arm__ +EXPORT_SYMBOL (__udivdi3); +EXPORT_SYMBOL (__umoddi3); +EXPORT_SYMBOL (__divdi3); +#else +EXPORT_SYMBOL (raise); +#endif +EXPORT_SYMBOL (oss_copy_from_user); +EXPORT_SYMBOL (oss_copy_to_user); +EXPORT_SYMBOL (osdev_set_irqparms); +EXPORT_SYMBOL (osdev_get_irqparms); +EXPORT_SYMBOL (osdev_get_nick); +EXPORT_SYMBOL (osdev_get_instance); +EXPORT_SYMBOL (oss_inc_refcounts); +EXPORT_SYMBOL (oss_dec_refcounts); +EXPORT_SYMBOL (oss_register_module); +EXPORT_SYMBOL (oss_unregister_module); +EXPORT_SYMBOL (oss_audio_reset); +EXPORT_SYMBOL (oss_audio_start_syncgroup); +EXPORT_SYMBOL (oss_encode_enum); +EXPORT_SYMBOL (dmap_get_qlen); +EXPORT_SYMBOL (num_audio_devfiles); +EXPORT_SYMBOL (oss_audio_inc_byte_counter); +EXPORT_SYMBOL (oss_audio_register_client); +EXPORT_SYMBOL (audio_devfiles); +EXPORT_FUNC (oss_get_cardinfo); +EXPORT_SYMBOL (oss_pmalloc); +EXPORT_SYMBOL (oss_add_audio_devlist); +EXPORT_FUNC (oss_memblk_malloc); +EXPORT_FUNC (oss_memblk_free); +EXPORT_FUNC (oss_memblk_unalloc); +EXPORT_DATA (oss_global_memblk); +EXPORT_FUNC (oss_get_procinfo); +EXPORT_DATA (mixer_muted); + +#ifdef CONFIG_OSS_MIDI +EXPORT_FUNC (oss_midi_ioctl); +EXPORT_FUNC (oss_midi_copy_timer); +#endif diff --git a/setup/Linux/oss/build/ossdip.h b/setup/Linux/oss/build/ossdip.h new file mode 100644 index 0000000..811e70a --- /dev/null +++ b/setup/Linux/oss/build/ossdip.h @@ -0,0 +1,10 @@ +/* + * Purpose: Definition of the _dev_info_t structure for Linux + */ +#ifndef OSSDIP_H +#define OSSDIP_H +struct _dev_info_t +{ + struct pci_dev *pcidev; +}; +#endif diff --git a/setup/Linux/oss/build/pci_wrapper.inc b/setup/Linux/oss/build/pci_wrapper.inc new file mode 100644 index 0000000..e08ec3a --- /dev/null +++ b/setup/Linux/oss/build/pci_wrapper.inc @@ -0,0 +1,93 @@ +/* + * Purpose: PCI wrapper routines for Linux + * + * This source file contains probe and remove routines for PCI devices. + * This code will be compiled in the target system. + */ +/* + * Copyright (C) 4Front Technologies 2005-2007. Released under GPL2 license. + */ +typedef struct +{ + struct pci_dev *pcidev; + oss_device_t *osdev; +} dev_map_t; + +#define MAX_INSTANCE 10 +static dev_map_t dev_map[MAX_INSTANCE]; +static int n_devmap = 0; + +static int __devinit +osspci_probe (struct pci_dev *pcidev, const struct pci_device_id *pciid) +{ + oss_device_t *osdev; + dev_info_t *dip; + + if (n_devmap >= MAX_INSTANCE) + { + printk (KERN_ALERT "oss: Too many instances of " DRIVER_NICK); + return -ENOMEM; + } + + if ((dip = oss_create_pcidip (pcidev)) == NULL) + return -ENOMEM; + + if ((osdev = + osdev_create (dip, DRIVER_TYPE, instance++, DRIVER_NICK, + NULL)) == NULL) + { + return -ENOMEM; + } + + osdev_set_owner (osdev, THIS_MODULE); + + if (module_major == 0) + module_major = oss_request_major (osdev, 0, DRIVER_NICK); + if (module_major <= 0) + { + printk (KERN_ALERT "Failed to allocate major device for " DRIVER_NICK); + return -EIO; + + } + osdev_set_major (osdev, module_major); + + pci_enable_device (pcidev); + if (!DRIVER_ATTACH (osdev)) + { + pci_disable_device (pcidev); + return -EIO; + } + + dev_map[n_devmap].pcidev = pcidev; + dev_map[n_devmap++].osdev = osdev; + oss_audio_delayed_attach (); + + return 0; +} + +static void __devexit +osspci_remove (struct pci_dev *pcidev) +{ + int i; + oss_device_t *osdev; + + for (i = 0; i < n_devmap; i++) + if (dev_map[i].pcidev == pcidev) + { + osdev = dev_map[i].osdev; + if (!DRIVER_DETACH (osdev)) + printk (KERN_ALERT DRIVER_NICK ": Unloading busy device\n"); + pci_disable_device (dev_map[i].pcidev); + osdev_delete (osdev); + + return; + } + + printk (KERN_ALERT DRIVER_NICK ": Can't find the PCI device to detach\n"); +} + +void +oss_pcie_init (oss_device_t * osdev, int flags) +{ + /* TODO: Do we need to do something here? */ +} diff --git a/setup/Linux/oss/build/usb_wrapper.inc b/setup/Linux/oss/build/usb_wrapper.inc new file mode 100644 index 0000000..ee199a7 --- /dev/null +++ b/setup/Linux/oss/build/usb_wrapper.inc @@ -0,0 +1,730 @@ +/* + * Purpose: Low level USB wrapper routines for Linux (2.6.x and later) + * + * This file contains the Linux specific USB support routines defined in udi.h + */ +/* + * Copyright (C) 4Front Technologies 2005-2007. Released under GPL2 license. + */ +#include "udi.h" + +#undef IO_DEBUG +static const udi_usb_devinfo *known_devices = NULL; + +#define MAX_DEVICE_SLOTS 20 + +int udi_usb_trace = 0; + +static udi_usb_driver *drv = NULL; +extern void *oss_pmalloc (size_t sz); + +struct udi_usb_devc +{ + struct usb_device *usb_dev; + const struct usb_device_id *id; + const udi_usb_devinfo *udi_usb_dev; + char *devpath; + + int enabled; + + int vendor, product, class, subclass; + struct usb_interface *iface; + int iface_number; + char *dev_name; + char *altsetting_labels; + int default_altsetting; + unsigned int altsetting_mask; + udi_usb_driver *drv; + void *client_devc; + int num_altsettings; + int usb_version; + struct usb_host_interface *altsetting; + +}; + +struct _udi_endpoint_handle_t +{ + unsigned char desc[32]; +}; + +#define MAX_DEVC 32 + +static udi_usb_devc usb_devc_list[MAX_DEVC] = { {0} }; +static int ndevs = 0; + +udi_endpoint_handle_t * +udi_open_endpoint (udi_usb_devc * usbdev, void *ep_descr) +{ + return (udi_endpoint_handle_t *) ep_descr; +} + +void +udi_close_endpoint (udi_endpoint_handle_t * eph) +{ + // NOP +} + +int +udi_endpoint_get_num (udi_endpoint_handle_t * eph) +{ + return eph->desc[2] /* & 0x7f */; +} + +#if 1 +static void +dump_configs (struct usb_device *dev) +{ + int c; + + printk ("#configs %d\n", dev->descriptor.bNumConfigurations); + + for (c = 0; c < dev->descriptor.bNumConfigurations; c++) + { + int i, j, k; + struct usb_host_config *config = &dev->config[c]; + + printk ("\tConfig #%d - #interfaces=%d\n", c, + config->desc.bNumInterfaces); + + for (j = 0; j < config->desc.bNumInterfaces; j++) + { + struct usb_interface *ifp = config->interface[j]; + printk ("\t\tInterface #%d - altsettings=%d\n", j, + ifp->num_altsetting); + + for (k = 0; k < ifp->num_altsetting; k++) + { + struct usb_host_interface *alt = &ifp->altsetting[k]; + unsigned char *buf = alt->extra; + + printk ("\t\t\tAlt setting #%d:\n", k); + + for (i = 0; i < alt->extralen; i++) + { + if (!(i % 8)) + { + if (i) + printk ("\n"); + printk ("\t\t\t%04x: ", i); + } + printk ("%02x ", buf[i]); + } + + printk ("\n"); + } + } + } +} +#endif + +static int +udi_attach_usbdev (struct usb_device *dev, + oss_device_t * osdev, + char *devpath, + struct usb_interface *iface, + const struct usb_device_id *id, + const udi_usb_devinfo * udi_usb_dev) +{ + int cfg_num, ep; + + udi_usb_devc *devc = &usb_devc_list[ndevs]; + struct usb_host_interface *alts; + + if (ndevs >= MAX_DEVC) + { + printk ("OSS: Too many USB audio/midi devices\n"); + return -ENODEV; + } + + if (udi_usb_trace > 1) + printk ("OSS: Attaching USB device %x:%x/%d, class=%x:%x, name=%s\n", + dev->descriptor.idVendor, dev->descriptor.idProduct, + iface->altsetting[0].desc.bInterfaceNumber, + iface->altsetting[0].desc.bInterfaceClass, + iface->altsetting[0].desc.bInterfaceSubClass, udi_usb_dev->name); + + devc->usb_dev = dev; + devc->id = id; + devc->udi_usb_dev = udi_usb_dev; + + devc->vendor = dev->descriptor.idVendor; + devc->product = dev->descriptor.idProduct; + devc->usb_version = dev->descriptor.bcdUSB >> 8; + devc->class = iface->altsetting[0].desc.bInterfaceClass; + devc->subclass = iface->altsetting[0].desc.bInterfaceSubClass; + devc->iface_number = iface->altsetting[0].desc.bInterfaceNumber; + devc->iface = iface; + devc->dev_name = udi_usb_dev->name; + devc->devpath = devpath; + devc->num_altsettings = iface->num_altsetting; + devc->altsetting = iface->altsetting; + + alts = &iface->altsetting[devc->num_altsettings - 1]; + ep = 0; + + if (alts->desc.bNumEndpoints > 1) + ep = 1; + + if (udi_usb_trace > 2) + { + int i; + + for (i = 0; i < alts->desc.bNumEndpoints; i++) + { + printk ("Endpoint: %02x\n", + alts->endpoint[i].desc.bEndpointAddress); + } + } + + cfg_num = 0; + + devc->enabled = 1; + devc->drv = drv; + + if (udi_usb_trace > 2) + dump_configs (dev); + + if ((devc->client_devc = drv->attach (devc, osdev)) == NULL) + { + return -EIO; + } + + ndevs++; + + usb_set_intfdata (iface, devc); + return 0; +} + +static char *prev_devices[32] = { NULL }; +static int nprev_devices = 0; + +static int +udi_usb_probe (struct usb_interface *iface, const struct usb_device_id *id) +{ + int i; + static int ncalls = 0; + oss_device_t *osdev = NULL; + dev_info_t *dip = NULL; // TODO + + char nick[32]; + int inst = 0; + + struct usb_device *dev = interface_to_usbdev (iface); + + if (ncalls++ > 100) + return -EIO; + + sprintf (nick, "usb%04x%04x-", dev->descriptor.idVendor, + dev->descriptor.idProduct); + +/* + * Find out how many instances of this device (ID) are already attached. + */ + + for (i = 0; i < nprev_devices; i++) + { + if (strcmp (nick, prev_devices[i]) == 0) + { + inst++; + } + } + + prev_devices[nprev_devices] = oss_pmalloc (strlen (nick) + 1); + strcpy (prev_devices[nprev_devices], nick); + if (nprev_devices < 32) + nprev_devices++; + + if ((osdev = osdev_create (dip, DRV_USB, inst, nick, NULL)) == NULL) + { + return -ENOMEM; + } + osdev_set_owner (osdev, THIS_MODULE); + osdev_set_major (osdev, usb_major); + + i = 0; + if (udi_usb_trace > 1) + printk ("\n\nProbing dev=%s id=%x:%x/%d\n", dev->devpath, + dev->descriptor.idVendor, + dev->descriptor.idProduct, + iface->altsetting[0].desc.bInterfaceNumber); + + while (i >= 0 && known_devices[i].vendor >= 0) + { + if (dev->descriptor.idVendor == known_devices[i].vendor && + dev->descriptor.idProduct == known_devices[i].product) + { + int ret; + const udi_usb_devinfo *d = &known_devices[i]; + ret = udi_attach_usbdev (dev, osdev, dev->devpath, iface, id, d); + return ret; + } + else + i++; + } + +/* Try the "generic" device */ + { + int ret; + const udi_usb_devinfo *d = &known_devices[i]; + ret = udi_attach_usbdev (dev, osdev, dev->devpath, iface, id, d); + return ret; + } + + return -ENODEV; +} + +static void +udi_usb_disconnect (struct usb_interface *iface) +{ + udi_usb_devc *devc = usb_get_intfdata (iface); + //struct usb_device *dev = interface_to_usbdev (iface); + + if (devc == (udi_usb_devc *) - 1) + return; + + if (!devc->enabled) + return; + + if (udi_usb_trace > 0) + printk ("OSS: Disconnect USB device %x:%x %s\n", devc->vendor, + devc->product, devc->udi_usb_dev->name); + devc->drv->disconnect (devc->client_devc); + devc->enabled = 0; +} + +static struct usb_driver oss_usb = { +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15) +owner:THIS_MODULE, +#endif +name:"oss_usb", +probe:udi_usb_probe, +disconnect:udi_usb_disconnect, +id_table:udi_usb_table +}; + +static int udi_usb_installed = 0; + +int +udi_attach_usbdriver (oss_device_t * osdev, const udi_usb_devinfo * devlist, + udi_usb_driver * driver) +{ + drv = driver; + known_devices = devlist; + return 1; +} + +void +udi_unload_usbdriver (oss_device_t * osdev) +{ +} + +/* + * Device access routines + */ + +int +udi_usbdev_get_class (udi_usb_devc * usbdev) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + + return devc->class; +} + +int +udi_usbdev_get_subclass (udi_usb_devc * usbdev) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + + return devc->subclass; +} + +int +udi_usbdev_get_vendor (udi_usb_devc * usbdev) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + + return devc->vendor; +} + +int +udi_usbdev_get_product (udi_usb_devc * usbdev) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + + return devc->product; +} + +int +udi_usbdev_get_inum (udi_usb_devc * usbdev) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + + return devc->iface_number; +} + +int +udi_usbdev_set_interface (udi_usb_devc * usbdev, int inum, int altset) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + + return usb_set_interface (devc->usb_dev, inum, altset); +} + +unsigned char * +udi_usbdev_get_endpoint (udi_usb_devc * usbdev, int altsetting, int n, + int *len) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + int num_endpoints; + struct usb_device *dev; + struct usb_host_interface *alts; + struct usb_interface *iface; + + dev = devc->usb_dev; + iface = devc->iface; + + if (altsetting >= devc->num_altsettings) + return NULL; + + alts = &iface->altsetting[altsetting]; + + num_endpoints = alts->desc.bNumEndpoints; + + if (n >= num_endpoints) + return NULL; + + *len = alts->endpoint[n].desc.bLength; + return (unsigned char *) &alts->endpoint[n].desc; +} + +int +udi_usbdev_get_num_altsettings (udi_usb_devc * usbdev) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + + return devc->num_altsettings; +} + +int +udi_usbdev_get_usb_version (udi_usb_devc * usbdev) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + + return devc->usb_version; +} + +unsigned char * +udi_usbdev_get_altsetting (udi_usb_devc * usbdev, int n, int *size) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + struct usb_host_interface *alt; + + if (n < 0 || n >= devc->num_altsettings) + { + /* printk("udi usb: Bad altsetting %d (%d)\n", n, n >= devc->num_altsettings); */ + return NULL; + } + + alt = &devc->altsetting[n]; + + *size = alt->extralen; + return alt->extra; +} + +char * +udi_usbdev_get_name (udi_usb_devc * usbdev) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + + return devc->dev_name == NULL ? "Unknown" : devc->dev_name; +} + + +char * +udi_usbdev_get_altsetting_labels (udi_usb_devc * usbdev, int if_num, int *default_alt, unsigned int *mask) +{ + int i; + + *default_alt=1; + *mask=0xffffffff; + + if (usbdev->udi_usb_dev == NULL) /* No device definitions available */ + { + return NULL; + } + + for (i=0;usbdev->udi_usb_dev->altsettings[i].altsetting_labels!=NULL;i++) + if (i==if_num) + { + *default_alt = usbdev->udi_usb_dev->altsettings[i].default_altsetting; + *mask = usbdev->udi_usb_dev->altsettings[i].altsetting_mask; + if (*mask==0) + *mask=0xffffffff; + return usbdev->udi_usb_dev->altsettings[i].altsetting_labels; + } + + return NULL; /* Not found */ +} + +char * +udi_usbdev_get_string (udi_usb_devc * usbdev, int ix) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + static char str[100]; + int err; + + if (ix == 0) + return NULL; + + if ((err = usb_string (devc->usb_dev, ix, str, sizeof (str) - 1)) != 0) + { + return NULL; + } + + return str; +} + +char * +udi_usbdev_get_devpath (udi_usb_devc * usbdev) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + + return devc->devpath; +} + +int +udi_usb_snd_control_msg (udi_usb_devc * usbdev, unsigned int endpoint, + unsigned char rq, + unsigned char rqtype, + unsigned short value, + unsigned short index, + void *buf, int len, int timeout) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + int err; + + if (!devc->enabled) + return -EPIPE; + + if (timeout < 0) + timeout = 0; + +#ifdef IO_DEBUG + printk ("Snd %x (%x) rq=%x, rt=%x, v=%x, ix=%x, l=%d %02x %02x\n", + devc->usb_dev, + usb_sndctrlpipe (devc->usb_dev, endpoint), + rq, rqtype, value, index, len, b[0], b[1]); +#endif + err = usb_control_msg (devc->usb_dev, + usb_sndctrlpipe (devc->usb_dev, endpoint), + rq, rqtype, value, index, buf, len, timeout); +#ifdef IO_DEBUG + if (err < 0) + printk ("Usb write error %d\n", err); +#endif + + return err; +} + +int +udi_usb_rcv_control_msg (udi_usb_devc * usbdev, unsigned int endpoint, + unsigned char rq, + unsigned char rqtype, + unsigned short value, + unsigned short index, + void *buf, int len, int timeout) +{ + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + int err; + + if (!devc->enabled) + return -EPIPE; + + if (timeout < 0) + timeout = 0; + +#ifdef IO_DEBUG + printk ("Rcv %x (%x) rq=%x, rt=%x, v=%x, ix=%x, l=%d\n", + devc->usb_dev, + (unsigned int) usb_rcvctrlpipe (devc->usb_dev, endpoint), + rq, rqtype | USB_DIR_IN, value, index, len); +#endif + err = usb_control_msg (devc->usb_dev, + (unsigned int) usb_rcvctrlpipe (devc->usb_dev, + endpoint), rq, + rqtype | USB_DIR_IN, value, index, buf, len, + timeout); +#ifdef IO_DEBUG + if (err < 0) + printk ("Usb read error %d\n", err); + else + printk ("Got %02x %02x\n", b[0], b[1]); +#endif + + return err; +} + +/* Request stuff */ + +struct udi_usb_request +{ + struct urb *urb; + udi_usb_complete_func_t callback; + void *callback_arg; + int active; + void *data; +}; + +udi_usb_request_t + * udi_usb_alloc_request (udi_usb_devc * usbdev, udi_endpoint_handle_t * eph, + int nframes, int xfer_type) +{ + udi_usb_request_t *rq; + udi_usb_devc *devc = (udi_usb_devc *) usbdev; + + if ((rq = kmalloc (sizeof (*rq), GFP_KERNEL)) == NULL) + { + printk ("udi_usb_alloc_request: Out of memory\n"); + return NULL; + } + + memset (rq, 0, sizeof (*rq)); + + if ((rq->urb = usb_alloc_urb (nframes, 0)) == NULL) + { + kfree (rq); + printk ("udi_usb_alloc_request: Failed to allocate URB\n"); + return NULL; + } + + rq->urb->dev = devc->usb_dev; + rq->urb->number_of_packets = nframes; + rq->active = 0; + + return rq; +} + +void +udi_usb_free_request (udi_usb_request_t * request) +{ + if (request == NULL) + return; + + udi_usb_cancel_request (request); + + usb_free_urb (request->urb); + kfree (request); +} + +unsigned char * +udi_usb_request_actdata (udi_usb_request_t * request) +{ + return request->data; +} + +static void +complete_func (struct urb *urb) +{ + udi_usb_request_t *request = urb->context; + + request->active = 0; + request->callback (request, request->callback_arg); +} + +int +udi_usb_submit_request (udi_usb_request_t * request, + udi_usb_complete_func_t callback, void *callback_arg, + udi_endpoint_handle_t * eph, int xfer_type, + void *data, int data_len) +{ + struct urb *urb; + struct usb_device *d; + int i, err; + int endpoint = eph->desc[2] & 0x7f; + + if (request == NULL) + return -EINVAL; + + urb = request->urb; + d = urb->dev; + request->callback = callback; + request->callback_arg = callback_arg; + request->data = data; + urb->complete = (usb_complete_t) complete_func; + urb->context = request; + urb->transfer_buffer = data; + + for (i = 0; i < urb->number_of_packets; i++) + { + urb->iso_frame_desc[i].status = 0; + urb->iso_frame_desc[i].length = data_len; + urb->iso_frame_desc[i].offset = i * data_len; + } + + urb->transfer_buffer_length = urb->actual_length = data_len; + + switch (xfer_type) + { + case UDI_USBXFER_ISO_WRITE: + urb->pipe = usb_sndisocpipe (urb->dev, endpoint); + urb->transfer_flags = URB_ISO_ASAP; + urb->interval = 1; + break; + + case UDI_USBXFER_ISO_READ: + urb->pipe = usb_rcvisocpipe (urb->dev, endpoint); + urb->transfer_flags = URB_ISO_ASAP; + urb->interval = 1; + break; + + case UDI_USBXFER_BULK_READ: + usb_fill_bulk_urb (urb, d, usb_rcvbulkpipe (d, endpoint), + data, data_len, + (usb_complete_t) complete_func, request); + break; + + case UDI_USBXFER_INTR_READ: + usb_fill_int_urb (urb, d, usb_rcvintpipe (d, endpoint), + data, data_len, + (usb_complete_t) complete_func, request, 8); + break; + + case UDI_USBXFER_BULK_WRITE: + usb_fill_bulk_urb (urb, d, usb_sndbulkpipe (d, endpoint), + data, data_len, + (usb_complete_t) complete_func, request); + break; + + default: + printk ("udi usb: Bad xfer type %d\n", xfer_type); + return -EINVAL; + } + +#ifdef SLAB_ATOMIC + if ((err = usb_submit_urb (request->urb, SLAB_ATOMIC)) >= 0) + request->active = 1; +#else + /* + * Linux 2.6.20 and later don't have SLAB_ATOMIC + */ + if ((err = usb_submit_urb (request->urb, GFP_ATOMIC)) >= 0) + request->active = 1; +#endif + return err; +} + +int +udi_usb_request_actlen (udi_usb_request_t * request) +{ + return request->urb->actual_length; +} + +void +udi_usb_cancel_request (udi_usb_request_t * request) +{ + if (request == NULL || !request->active) + return; + + usb_kill_urb (request->urb); + +} |