Changeset 250

Timestamp:

Aug 27, 2007, 7:41:50 PM (18 years ago)

Author:

Brendan Oakley

Message:

Merged to ALSA 0.9.5

Location:

GPL/branches/alsa-resync1/alsa-kernel

Files:

• core/control.c (modified) (2 diffs)
• core/info.c (modified) (12 diffs)
• core/init.c (modified) (2 diffs)
• core/pcm_lib.c (modified) (1 diff)
• core/pcm_native.c (modified) (3 diffs)
• core/rawmidi.c (modified) (3 diffs)
• core/sound.c (modified) (1 diff)
• drivers/dummy.c (modified) (2 diffs)
• include/sound/ad1848.h (modified) (2 diffs)
• include/sound/adriver.h (modified) (5 diffs)
• include/sound/ak4xxx-adda.h (modified) (2 diffs)
• include/sound/compat_22.h (modified) (1 diff)
• include/sound/core.h (modified) (4 diffs)
• include/sound/hdsp.h (modified) (1 diff)
• include/sound/initval.h (modified) (1 diff)
• include/sound/mpu401.h (modified) (1 diff)
• include/sound/ymfpci.h (modified) (1 diff)
• isa/ad1848/ad1848.c (modified) (6 diffs)
• isa/ad1848/ad1848_lib.c (modified) (4 diffs)
• isa/azt2320.c (modified) (2 diffs)
• isa/cs423x/cs4231_lib.c (modified) (1 diff)
• isa/cs423x/cs4236.c (modified) (3 diffs)
• isa/cs423x/cs4236_lib.c (modified) (1 diff)
• isa/dt019x.c (modified) (4 diffs)
• isa/gus/gus_main.c (modified) (2 diffs)
• isa/gus/gus_synth.c (modified) (1 diff)
• isa/gus/interwave.c (modified) (1 diff)
• isa/opl3sa2.c (modified) (2 diffs)
• isa/opti9xx/opti92x-ad1848.c (modified) (5 diffs)
• isa/sb/emu8000.c (modified) (2 diffs)
• isa/sb/es968.c (modified) (1 diff)
• isa/sb/sb16.c (modified) (5 diffs)
• isa/sb/sb16_csp.c (modified) (1 diff)
• isa/sb/sb8_midi.c (modified) (15 diffs)
• isa/wavefront/wavefront.c (modified) (1 diff)
• pci/cs4281.c (modified) (7 diffs)
• pci/es1968.c (modified) (1 diff)
• pci/ice1712/ak4xxx.c (modified) (3 diffs)
• pci/ice1712/aureon.c (added)
• pci/ice1712/aureon.h (added)
• pci/ice1712/ews.c (modified) (4 diffs)
• pci/ice1712/ice1712.c (modified) (12 diffs)
• pci/ice1712/ice1712.h (modified) (1 diff)
• pci/ice1712/ice1724.c (modified) (17 diffs)
• pci/ice1712/makefile.os2 (modified) (1 diff)
• pci/ice1712/revo.c (modified) (4 diffs)
• pci/korg1212/korg1212.c (modified) (2 diffs)
• pci/maestro3.c (modified) (2 diffs)
• pci/rme96.c (modified) (5 diffs)
• pci/rme9652/hammerfall_mem.c (deleted)
• pci/rme9652/hdsp.c (modified) (48 diffs)
• pci/rme9652/makefile.os2 (modified) (1 diff)
• pci/rme9652/rme9652.c (modified) (3 diffs)
• pci/sonicvibes.c (modified) (3 diffs)
• pci/ymfpci/ymfpci_main.c (modified) (1 diff)

GPL/branches/alsa-resync1/alsa-kernel/core/control.c

@@ -1295 +1295 @@
  */
 
-#ifdef TARGET_OS2
 static struct file_operations snd_ctl_f_ops =
 {
-#ifdef LINUX_2_3
-    THIS_MODULE,
-#endif
-    0,
-    snd_ctl_read,
-    0,0,
-    snd_ctl_poll,
-    snd_ctl_ioctl,
-    0,
-    snd_ctl_open,0,
-    snd_ctl_release,
-    0,
-    snd_ctl_fasync,
-    0,0,0
+#ifndef TARGET_OS2
+        .owner =        THIS_MODULE,
+#endif /* !TARGET_OS2 */
+        .read =         snd_ctl_read,
+        .open =         snd_ctl_open,
+        .release =      snd_ctl_release,
+        .poll =         snd_ctl_poll,
+        .ioctl =        snd_ctl_ioctl,
+        .fasync =       snd_ctl_fasync,
 };
 
@@ -1319 +1313 @@
         .f_ops =        &snd_ctl_f_ops,
 };
-
-#else
-static struct file_operations snd_ctl_f_ops =
-{
-#ifdef LINUX_2_3
-owner:          THIS_MODULE,
-#endif
-    read:               snd_ctl_read,
-    open:               snd_ctl_open,
-    release:    snd_ctl_release,
-    poll:               snd_ctl_poll,
-    ioctl:              snd_ctl_ioctl,
-    fasync:             snd_ctl_fasync,
-};
-
-static snd_minor_t snd_ctl_reg =
-{
-comment:        "ctl",
-    f_ops:              &snd_ctl_f_ops,
-};
-#endif
 
 /*

GPL/branches/alsa-resync1/alsa-kernel/core/info.c

@@ -46 +46 @@
     static char *reserved[] =
     {
-                "dev",
         "version",
         "meminfo",
@@ -124 +123 @@
 
 static struct proc_dir_entry *snd_proc_root = NULL;
-struct proc_dir_entry *snd_proc_dev = NULL;
 snd_info_entry_t *snd_seq_root = NULL;
 #ifdef CONFIG_SND_OSSEMUL
@@ -283 +281 @@
         p = PDE(inode);
     entry = p == NULL ? NULL : (snd_info_entry_t *)p->data;
-    if (entry == NULL) {
+        if (entry == NULL || entry->disconnected) {
         up(&info_mutex);
         return -ENODEV;
@@ -506 +504 @@
 }
 
-#ifdef TARGET_OS2
 static struct file_operations snd_info_entry_operations =
 {
-#ifdef LINUX_2_3
-    THIS_MODULE,
-#endif
-    snd_info_entry_llseek,
-    snd_info_entry_read,
-    snd_info_entry_write,
-    0,
-    snd_info_entry_poll,
-    snd_info_entry_ioctl,
-    snd_info_entry_mmap,
-    0,
-    //  snd_info_entry_open,
-    0,
-    snd_info_entry_release,
-    0,0,0,0,0
-};
-#else
-static struct file_operations snd_info_entry_operations =
-{
-#ifndef LINUX_2_2
+#ifndef TARGET_OS2
         .owner =        THIS_MODULE,
-#endif
+#endif /* !TARGET_OS2 */
         .llseek =       snd_info_entry_llseek,
         .read =         snd_info_entry_read,
@@ -537 +515 @@
         .ioctl =        snd_info_entry_ioctl,
         .mmap =         snd_info_entry_mmap,
+#ifndef TARGET_OS2
         .open =         snd_info_entry_open,
+#endif /* !TARGET_OS2 */
         .release =      snd_info_entry_release,
 };
-
-#ifdef LINUX_2_2
-static struct inode_operations snd_info_entry_inode_operations =
-{
-    &snd_info_entry_operations, /* default sound info directory file-ops */
-};
-
-static struct inode_operations snd_info_device_inode_operations =
-{
-    &snd_fops,          /* default sound info directory file-ops */
-};
-#endif  /* LINUX_2_2 */
-
-static int snd_info_card_readlink(struct dentry *dentry,
-                                  char *buffer, int buflen)
-{
-        char *s = PDE(dentry->d_inode)->data;
-#ifndef LINUX_2_2
-    return vfs_readlink(dentry, buffer, buflen, s);
-#else
-    int len;
-
-    if (s == NULL)
-        return -EIO;
-    len = strlen(s);
-    if (len > buflen)
-        len = buflen;
-    if (copy_to_user(buffer, s, len))
-        return -EFAULT;
-    return len;
-#endif
-}
-
-#ifndef LINUX_2_2
-static int snd_info_card_followlink(struct dentry *dentry,
-                                    struct nameidata *nd)
-{
-        char *s = PDE(dentry->d_inode)->data;
-    return vfs_follow_link(nd, s);
-}
-#else
-static struct dentry *snd_info_card_followlink(struct dentry *dentry,
-                                               struct dentry *base,
-                                               unsigned int follow)
-{
-        char *s = PDE(dentry->d_inode)->data;
-    return lookup_dentry(s, base, follow);
-}
-#endif
-
-#ifdef LINUX_2_2
-static struct file_operations snd_info_card_link_operations =
-{
-    NULL
-};
-#endif
-
-struct inode_operations snd_info_card_link_inode_operations =
-{
-#ifdef LINUX_2_2
-        .default_file_ops =     &snd_info_card_link_operations,
-#endif
-        .readlink =             snd_info_card_readlink,
-        .follow_link =          snd_info_card_followlink,
-};
-#endif //TARGET_OS2
 
 /**
@@ -636 +550 @@
         return -ENOMEM;
     snd_proc_root = p;
-        p = snd_create_proc_entry("dev", S_IFDIR | S_IRUGO | S_IXUGO, snd_proc_root);
-        if (p == NULL)
-                return -ENOMEM;
-        snd_proc_dev = p;
 #ifdef CONFIG_SND_OSSEMUL
     {
@@ -667 +577 @@
 #endif
     snd_info_version_init();
-#ifdef CONFIG_SND_DEBUG_MEMORY
     snd_memory_info_init();
-#endif
     snd_minor_info_init();
-#ifdef CONFIG_SND_OSSEMUL
     snd_minor_info_oss_init();
-#endif
     snd_card_info_init();
     return 0;
@@ -681 +587 @@
 {
     snd_card_info_done();
-#ifdef CONFIG_SND_OSSEMUL
     snd_minor_info_oss_done();
-#endif
     snd_minor_info_done();
-#ifdef CONFIG_SND_DEBUG_MEMORY
     snd_memory_info_done();
-#endif
     snd_info_version_done();
     if (snd_proc_root) {
@@ -698 +600 @@
                         snd_info_unregister(snd_oss_root);
 #endif
-                snd_remove_proc_entry(snd_proc_root, snd_proc_dev);
         snd_remove_proc_entry(&proc_root, snd_proc_root);
     }
@@ -968 +869 @@
  * Returns zero if successful, or a negative error code on failure.
  */
-//#ifndef TARGET_OS2
 int snd_card_proc_new(snd_card_t *card, const char *name,
                       snd_info_entry_t **entryp)
 {
     static snd_device_ops_t ops = {
-        /*.dev_free = */snd_info_dev_free_entry,
-        /*.dev_register =*/ snd_info_dev_register_entry,
-        /*.dev_disconnect = */snd_info_dev_disconnect_entry,
-        /*.dev_unregister = */snd_info_dev_unregister_entry
+        .dev_free = snd_info_dev_free_entry,
+        .dev_register = snd_info_dev_register_entry,
+        .dev_disconnect = snd_info_dev_disconnect_entry,
+        .dev_unregister = snd_info_dev_unregister_entry
     };
     snd_info_entry_t *entry;
@@ -992 +892 @@
     return 0;
 }
-//#endif
 
 /**
@@ -1031 +930 @@
         return -ENOMEM;
     }
-#ifndef LINUX_2_2
     p->owner = entry->module;
-#endif
-
 #ifndef TARGET_OS2
-    if (!S_ISDIR(entry->mode)) {
-#ifndef LINUX_2_2
+        if (!S_ISDIR(entry->mode))
         p->proc_fops = &snd_info_entry_operations;
-#else
-        p->ops = &snd_info_entry_inode_operations;
-#endif
-    }
 #endif
     p->size = entry->size;

GPL/branches/alsa-resync1/alsa-kernel/core/init.c

@@ -27 +27 @@
 #include <linux/time.h>
 #include <linux/ctype.h>
-#ifndef TARGET_OS2 // TODO: implement linux/workqueue.h
-#include <linux/workqueue.h>
-#endif /* !TARGET_OS2 */
 #include <sound/core.h>
 #include <sound/control.h>
@@ -208 +205 @@
 
                 memset(f_ops, 0, sizeof(*f_ops));
-#ifdef LINUX_2_3
+#ifndef TARGET_OS2
                 f_ops->owner = file->f_op->owner;
-#endif
+#endif /* !TARGET_OS2 */
                 f_ops->release = file->f_op->release;
                 f_ops->poll = snd_disconnect_poll;

GPL/branches/alsa-resync1/alsa-kernel/core/pcm_lib.c

@@ -70 +70 @@
         if (frames > runtime->silence_size)
             frames = runtime->silence_size;
+                else
+                        frames = runtime->silence_threshold;
     } else {
         if (new_hw_ptr == ULONG_MAX) {  /* initialization */

GPL/branches/alsa-resync1/alsa-kernel/core/pcm_native.c

@@ -1568 +1568 @@
     inode = file->f_dentry->d_inode;
     if (!S_ISCHR(inode->i_mode) ||
-        MAJOR(inode->i_rdev) != CONFIG_SND_MAJOR) {
+            major(inode->i_rdev) != snd_major) {
         fput(file);
         return 0;
     }
-    minor = MINOR(inode->i_rdev);
-    if (minor >= 256 ||
+        minor = minor(inode->i_rdev);
+        if (minor >= 256 || 
         minor % SNDRV_MINOR_DEVICES < SNDRV_MINOR_PCM_PLAYBACK) {
         fput(file);
@@ -2105 +2105 @@
 int snd_pcm_open(struct inode *inode, struct file *file)
 {
-    int cardnum = SNDRV_MINOR_CARD(MINOR(inode->i_rdev));
-    int device = SNDRV_MINOR_DEVICE(MINOR(inode->i_rdev));
+        int cardnum = SNDRV_MINOR_CARD(minor(inode->i_rdev));
+        int device = SNDRV_MINOR_DEVICE(minor(inode->i_rdev));
     int err;
     snd_pcm_t *pcm;
@@ -3292 +3292 @@
 
 static struct file_operations snd_pcm_f_ops_playback = {
-#ifdef LINUX_2_3
+#ifndef TARGET_OS2
     .owner =    THIS_MODULE,
-#endif
+#endif /* !TARGET_OS2 */
     .write =    snd_pcm_write,
-#ifdef LINUX_2_3
+#ifndef TARGET_OS2
     .writev =   snd_pcm_writev,
-#endif
+#endif /* !TARGET_OS2 */
     .open =     snd_pcm_open,
     .release =  snd_pcm_release,
     .poll =     snd_pcm_playback_poll,
     .ioctl =    snd_pcm_playback_ioctl,
-#ifdef LINUX_2_3
+#ifndef TARGET_OS2
     .compat_ioctl = snd_pcm_ioctl_compat,
     .mmap =             snd_pcm_mmap,
-#endif
+    .fasync =   snd_pcm_fasync,
+#endif
+};
+
+static struct file_operations snd_pcm_f_ops_capture = {
 #ifndef TARGET_OS2
-    .fasync =   snd_pcm_fasync,
-#endif
-};
-
-static struct file_operations snd_pcm_f_ops_capture = {
-#ifdef LINUX_2_3
     .owner =    THIS_MODULE,
-#endif
+#endif /* !TARGET_OS2 */
     .read =             snd_pcm_read,
-#ifdef LINUX_2_3
+#ifndef TARGET_OS2
     .readv =    snd_pcm_readv,
-#endif
+#endif /* !TARGET_OS2 */
     .open =             snd_pcm_open,
     .release =  snd_pcm_release,
     .poll =             snd_pcm_capture_poll,
     .ioctl =    snd_pcm_capture_ioctl,
-#ifdef LINUX_2_3
+#ifndef TARGET_OS2
     .ioctl = snd_pcm_ioctl_compat,
     .mmap =             snd_pcm_mmap,
-#endif
-#ifndef TARGET_OS2
     .fasync =   snd_pcm_fasync,
 #endif

GPL/branches/alsa-resync1/alsa-kernel/core/rawmidi.c

@@ -1467 +1467 @@
 }
 
-#if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
+#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
 static void snd_rawmidi_dev_seq_free(snd_seq_device_t *device)
 {
@@ -1542 +1542 @@
     }
     rmidi->proc_entry = entry;
-#if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
+#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
     if (!rmidi->ops || !rmidi->ops->dev_register) { /* own registration mechanism */
         if (snd_seq_device_new(rmidi->card, rmidi->device, SNDRV_SEQ_DEV_ID_MIDISYNTH, 0, &rmidi->seq_dev) >= 0) {
@@ -1597 +1597 @@
     snd_unregister_device(SNDRV_DEVICE_TYPE_RAWMIDI, rmidi->card, rmidi->device);
     up(&register_mutex);
-#if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
+#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
     if (rmidi->seq_dev) {
         snd_device_free(rmidi->card, rmidi->seq_dev);

GPL/branches/alsa-resync1/alsa-kernel/core/sound.c

@@ -164 +164 @@
 }
 
-#ifdef TARGET_OS2
 struct file_operations snd_fops =
 {
-    0,0,0,0,0,0,0,
-    snd_open,0,0,0,0,0,0,0
-};
-#else
-struct file_operations snd_fops =
-{
-#ifndef LINUX_2_2
+#ifndef TARGET_OS2
         .owner =        THIS_MODULE,
-#endif
+#endif /* !TARGET_OS2 */
         .open =         snd_open
 };
-#endif
 
 static int snd_kernel_minor(int type, struct snd_card * card, int dev)

GPL/branches/alsa-resync1/alsa-kernel/drivers/dummy.c

@@ -22 +22 @@
 #include <linux/version.h>
 #include <linux/init.h>
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)
+#ifndef TARGET_OS2 //TODO: Implement linux/jiffies.h
 #include <linux/jiffies.h>
-#else
-#include <linux/sched.h>
-#endif
+#endif /* !TARGET_OS2 */
 #include <linux/slab.h>
 #include <linux/time.h>
@@ -60 +58 @@
 #define MAX_BUFFER_SIZE         (256 * 1024)
 #define USE_FORMATS             SNDRV_PCM_FMTBIT_S32_LE
-#define USE_CHANNELS_MIN        12
-#define USE_CHANNELS_MAX        12
+#define USE_CHANNELS_MIN        10
+#define USE_CHANNELS_MAX        10
 #define USE_PERIODS_MIN         1
 #define USE_PERIODS_MAX         1024

GPL/branches/alsa-resync1/alsa-kernel/include/sound/ad1848.h

@@ -121 +121 @@
 #define AD1848_HW_CS4248        0x0003  /* CS4248 chip */
 #define AD1848_HW_CMI8330       0x0004  /* CMI8330 chip */
+#define AD1848_HW_THINKPAD      0x0005  /* Thinkpad 360/750/755 */
+
+/* IBM Thinkpad specific stuff */
+#define AD1848_THINKPAD_CTL_PORT1               0x15e8
+#define AD1848_THINKPAD_CTL_PORT2               0x15e9
+#define AD1848_THINKPAD_CS4248_ENABLE_BIT       0x02
 
 struct _snd_ad1848 {
@@ -142 +148 @@
         int dma_size;
         int thinkpad_flag;              /* Thinkpad CS4248 needs some extra help */
+        int thinkpad_flag;              /* Thinkpad CS4248 needs some extra help */
+#ifdef CONFIG_PM
+        struct pm_dev *thinkpad_pmstate;
+#endif
 
         spinlock_t reg_lock;

GPL/branches/alsa-resync1/alsa-kernel/include/sound/adriver.h

@@ -51 +51 @@
 #include <linux/module.h>
 
+#ifdef CONFIG_HAVE_OLD_REQUEST_MODULE
+#include <linux/kmod.h>
+#undef request_module
+void snd_compat_request_module(const char *name, ...);
+#define request_module(name, args...) snd_compat_request_module(name, ##args)
+#endif
+
+#ifndef TARGET_OS2
+#include <linux/compiler.h>
+#endif /* !TARGET_OS2 */
+#ifndef __user
+#define __user
+#endif
+
 #ifdef CONFIG_PCI
 #include <linux/pci.h>
@@ -71 +85 @@
 #include <linux/init.h>
 #include <linux/pm.h>
+#include <asm/page.h>
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 3)
 #define pci_set_dma_mask(pci, mask) pci->dma_mask = mask
@@ -109 +124 @@
 #endif
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 3)
+#include <linux/sched.h>
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 3) && !defined(need_resched)
 #define need_resched() (current->need_resched)
 #endif
@@ -136 +152 @@
 
 #if defined(CONFIG_ISAPNP) || (defined(CONFIG_ISAPNP_MODULE) && defined(MODULE))
-#if (defined(CONFIG_ISAPNP_KERNEL) && defined(ALSA_BUILD)) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 3, 30) && !defined(ALSA_BUILD))
-#include <linux/isapnp.h>
-#define isapnp_dev pci_dev
-#define isapnp_card pci_bus
-#else
 #ifdef TARGET_OS2
 #include "isapnp.h"
 #else /* !TARGET_OS2 */
 #include <linux/isapnp.h>
-#endif /* TARGET_OS2 */
+#endif /* !TARGET_OS2 */
+#ifndef CONFIG_PNP
+#define CONFIG_PNP
+#endif
+#if (defined(CONFIG_ISAPNP_KERNEL) && defined(ALSA_BUILD)) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 3, 30) && !defined(ALSA_BUILD))
+#define isapnp_dev pci_dev
+#define isapnp_card pci_bus
 #endif
 #undef __ISAPNP__
 #define __ISAPNP__
+#else
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
+#undef CONFIG_PNP
+#endif
 #endif
 
@@ -159 +180 @@
 #endif
 
-/* no vsnprintf yet? */
-/* FIXME: the version number is not sure.. at least it exists already on 2.4.10 */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 10) && !TARGET_OS2
-#define snprintf(buf,size,fmt,args...) sprintf(buf,fmt,##args)
-#define vsnprintf(buf,size,fmt,args) vsprintf(buf,fmt,args)
+#if !defined CONFIG_HAVE_STRLCPY && !defined TARGET_OS2
+size_t snd_compat_strlcpy(char *dest, const char *src, size_t size);
+#define strlcpy(dest, src, size) snd_compat_strlcpy(dest, src, size)
+size_t snd_compat_strlcat(char *dest, const char *src, size_t size);
+#define strlcat(dest, src, size) snd_compat_strlcat(dest, src, size)
+#endif
+
+#if !defined CONFIG_HAVE_SNPRINTF && !defined TARGET_OS2
+#include <stdarg.h>
+int snd_compat_snprintf(char * buf, size_t size, const char * fmt, ...);
+int snd_compat_vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
+#define snprintf(buf,size,fmt,args...) snd_compat_snprintf(buf,size,fmt,##args)
+#define vsnprintf(buf,size,fmt,args) snd_compat_vsnprintf(buf,size,fmt,args)
 #endif
 

GPL/branches/alsa-resync1/alsa-kernel/include/sound/ak4xxx-adda.h

@@ -38 +38 @@
 };
 
+#define AK4XXX_IMAGE_SIZE       (AK4XXX_MAX_CHIPS * 16) /* 64 bytes */
+
 struct snd_akm4xxx {
         snd_card_t *card;
         unsigned int num_adcs;                          /* AK4524 or AK4528 ADCs */
         unsigned int num_dacs;                          /* AK4524 or AK4528 DACs */
-        unsigned char images[AK4XXX_MAX_CHIPS][16];     /* saved register image */
+        unsigned char images[AK4XXX_IMAGE_SIZE];        /* saved register image */
         unsigned char ipga_gain[AK4XXX_MAX_CHIPS][2];   /* saved register image for IPGA (AK4528) */
         unsigned long private_value[AK4XXX_MAX_CHIPS];  /* helper for driver */
@@ -59 +61 @@
 int snd_akm4xxx_build_controls(akm4xxx_t *ak);
 
+#define snd_akm4xxx_get(ak,chip,reg) (ak)->images[(chip) * 16 + (reg)]
+#define snd_akm4xxx_set(ak,chip,reg,val) ((ak)->images[(chip) * 16 + (reg)] = (val))
+#define snd_akm4xxx_get_ipga(ak,chip,reg) (ak)->ipga_gain[chip][(reg)-4]
+#define snd_akm4xxx_set_ipga(ak,chip,reg,val) ((ak)->ipga_gain[chip][(reg)-4] = (val))
+
 #endif /* __SOUND_AK4XXX_ADDA_H */

GPL/branches/alsa-resync1/alsa-kernel/include/sound/compat_22.h

@@ -90 +90 @@
 
 /* Some distributions use modified kill_fasync */
+#ifdef CONFIG_OLD_KILL_FASYNC
 #include <linux/fs.h>
 #undef kill_fasync
 #define kill_fasync(fp, sig, band) snd_wrapper_kill_fasync(fp, sig, band)
 void snd_wrapper_kill_fasync(struct fasync_struct **, int, int);
+#endif
 
 /* this is identical with tq_struct but the "routine" field is renamed to "func" */

GPL/branches/alsa-resync1/alsa-kernel/include/sound/core.h

@@ -25 +25 @@
 #include <linux/sched.h>                /* wake_up() */
 #include <asm/semaphore.h>
-#ifndef TARGET_OS2 //TODO: implement linux/rwsem.h
+#ifndef TARGET_OS2 //TODO: implement linux/rwsem.h, workqueue.h
 #include <linux/rwsem.h>                /* struct rw_semaphore */
+#include <linux/workqueue.h>            /* struct workqueue_struct */
 #endif /* !TARGET_OS2 */
 #include <sound/typedefs.h>
@@ -213 +214 @@
         int device;                     /* device number */
         const char *comment;            /* for /proc/asound/devices */
-        snd_info_entry_t *dev;          /* for /proc/asound/dev */
         struct file_operations *f_ops;  /* file operations */
         char name[1];
@@ -241 +241 @@
 
 #ifdef CONFIG_SND_OSSEMUL
-
 int snd_minor_info_oss_init(void);
 int snd_minor_info_oss_done(void);
-
 int snd_oss_init_module(void);
-
+#else
+#define snd_minor_info_oss_init() /*NOP*/
+#define snd_minor_info_oss_done() /*NOP*/
+#define snd_oss_init_module() /*NOP*/
 #endif
 
@@ -269 +270 @@
 #define kstrdup(s, flags)  snd_hidden_kstrdup(s, flags)
 #else
+#define snd_memory_init() /*NOP*/
+#define snd_memory_done() /*NOP*/
+#define snd_memory_info_init() /*NOP*/
+#define snd_memory_info_done() /*NOP*/
 #define kmalloc_nocheck(size, flags) kmalloc(size, flags)
 #define vmalloc_nocheck(size) vmalloc(size)

GPL/branches/alsa-resync1/alsa-kernel/include/sound/hdsp.h

@@ -25 +25 @@
         Digiface,
         Multiface,
+        H9652,
         Undefined,
 } HDSP_IO_Type;

GPL/branches/alsa-resync1/alsa-kernel/include/sound/initval.h

@@ -87 +87 @@
 #define SNDRV_DEFAULT_ENABLE    { 1, [1 ... (SNDRV_CARDS-1)] = 0 }
 #define SNDRV_DEFAULT_ENABLE_PNP { [0 ... (SNDRV_CARDS-1)] = 1 }
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
 #define SNDRV_DEFAULT_ENABLE_ISAPNP SNDRV_DEFAULT_ENABLE_PNP
 #else

GPL/branches/alsa-resync1/alsa-kernel/include/sound/mpu401.h

@@ -92 +92 @@
         spinlock_t timer_lock;
         
+        atomic_t rx_loop;
+        atomic_t tx_loop;
+
         struct timer_list timer;
 

GPL/branches/alsa-resync1/alsa-kernel/include/sound/ymfpci.h

@@ -26 +26 @@
 #include "rawmidi.h"
 #include "ac97_codec.h"
+#ifndef TARGET_OS2 //TODO: Implement linux/gameport.h
+#include <linux/gameport.h>
+#endif /* !TARGET_OS2 */
 
 #ifndef PCI_VENDOR_ID_YAMAHA

GPL/branches/alsa-resync1/alsa-kernel/isa/ad1848/ad1848.c

@@ -47 +47 @@
 static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;        /* 5,7,9,11,12,15 */
 static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;       /* 0,1,3,5,6,7 */
+static int thinkpad[SNDRV_CARDS];                       /* Thinkpad special case */
 
 MODULE_PARM(index, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
@@ -66 +67 @@
 MODULE_PARM_DESC(dma1, "DMA1 # for AD1848 driver.");
 MODULE_PARM_SYNTAX(dma1, SNDRV_DMA_DESC);
+MODULE_PARM(thinkpad, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
+MODULE_PARM_DESC(thinkpad, "Enable only for the onboard CS4248 of IBM Thinkpad 360/750/755 series.");
+MODULE_PARM_SYNTAX(thinkpad,  SNDRV_ENABLED "," SNDRV_BOOLEAN_FALSE_DESC);
 
 static snd_card_t *snd_ad1848_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
@@ -78 +82 @@
 
         if (port[dev] == SNDRV_AUTO_PORT) {
-                snd_printk("specify port\n");
+                snd_printk(KERN_ERR "ad1848: specify port\n");
                 return -EINVAL;
         }
         if (irq[dev] == SNDRV_AUTO_IRQ) {
-                snd_printk("specify irq\n");
+                snd_printk(KERN_ERR "ad1848: specify irq\n");
                 return -EINVAL;
         }
         if (dma1[dev] == SNDRV_AUTO_DMA) {
-                snd_printk("specify dma1\n");
+                snd_printk(KERN_ERR "ad1848: specify dma1\n");
                 return -EINVAL;
         }
@@ -97 +101 @@
                                      irq[dev],
                                      dma1[dev],
-                                     AD1848_HW_DETECT,
+                                     thinkpad[dev] ? AD1848_HW_THINKPAD : AD1848_HW_DETECT,
                                      &chip)) < 0) {
                 snd_card_free(card);
@@ -116 +120 @@
         sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
                 pcm->name, chip->port, irq[dev], dma1[dev]);
+
+        if (thinkpad[dev]) {
+                strcat(card->longname, " [Thinkpad]");
+        }
 
         if ((err = snd_card_register(card)) < 0) {
@@ -169 +177 @@
                get_option(&str,(int *)&port[nr_dev]) == 2 &&
                get_option(&str,&irq[nr_dev]) == 2 &&
-               get_option(&str,&dma1[nr_dev]) == 2);
+               get_option(&str,&dma1[nr_dev]) == 2 &&
+               get_option(&str,&thinkpad[nr_dev]) == 2);
         nr_dev++;
         return 1;

GPL/branches/alsa-resync1/alsa-kernel/isa/ad1848/ad1848_lib.c

@@ -625 +625 @@
 
  */
+
+static void snd_ad1848_thinkpad_twiddle(ad1848_t *chip, int on) {
+
+        int tmp;
+
+        if (!chip->thinkpad_flag) return;
+
+        outb(0x1c, AD1848_THINKPAD_CTL_PORT1);
+        tmp = inb(AD1848_THINKPAD_CTL_PORT2);
+
+        if (on)
+                /* turn it on */
+                tmp |= AD1848_THINKPAD_CS4248_ENABLE_BIT;
+        else
+                /* turn it off */
+                tmp &= ~AD1848_THINKPAD_CS4248_ENABLE_BIT;
+        
+        outb(tmp, AD1848_THINKPAD_CTL_PORT2);
+
+}
+
+#ifdef CONFIG_PM
+static void snd_ad1848_suspend(ad1848_t *chip) {
+
+        snd_card_t *card = chip->card;
+
+        if (card->power_state == SNDRV_CTL_POWER_D3hot)
+                return;
+
+        snd_pcm_suspend_all(chip->pcm);
+        /* FIXME: save registers? */
+
+        if (chip->thinkpad_flag)
+                snd_ad1848_thinkpad_twiddle(chip, 0);
+
+        snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
+}
+
+static void snd_ad1848_resume(ad1848_t *chip) {
+
+        snd_card_t *card = chip->card;
+
+        if (card->power_state == SNDRV_CTL_POWER_D0)
+                return;
+
+        if (chip->thinkpad_flag)
+                snd_ad1848_thinkpad_twiddle(chip, 1);
+
+        /* FIXME: restore registers? */
+
+        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
+}
+
+/* callback for control API */
+static int snd_ad1848_set_power_state(snd_card_t *card, unsigned int power_state)
+{
+        ad1848_t *chip = (ad1848_t *) card->power_state_private_data;
+        switch (power_state) {
+        case SNDRV_CTL_POWER_D0:
+        case SNDRV_CTL_POWER_D1:
+        case SNDRV_CTL_POWER_D2:
+                snd_ad1848_resume(chip);
+                break;
+        case SNDRV_CTL_POWER_D3hot:
+        case SNDRV_CTL_POWER_D3cold:
+                snd_ad1848_suspend(chip);
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int snd_ad1848_pm_callback(struct pm_dev *dev, pm_request_t rqst, void *data)
+{
+        ad1848_t *chip = snd_magic_cast(ad1848_t, dev->data, return 0);
+
+        switch (rqst) {
+        case PM_SUSPEND:
+                snd_ad1848_suspend(chip);
+                break;
+        case PM_RESUME:
+                snd_ad1848_resume(chip);
+                break;
+        }
+        return 0;
+}
+
+#endif /* CONFIG_PM */
 
 static int snd_ad1848_probe(ad1848_t * chip)
@@ -800 +889 @@
 static int snd_ad1848_free(ad1848_t *chip)
 {
+#ifdef CONFIG_PM
+        if (chip->thinkpad_pmstate)
+                pm_unregister(chip->thinkpad_pmstate);
+#endif
         if (chip->res_port) {
                 release_resource(chip->res_port);
@@ -870 +963 @@
         }
         chip->dma = dma;
+
+        if (hardware == AD1848_HW_THINKPAD) {
+                chip->thinkpad_flag = 1;
+                chip->hardware = AD1848_HW_DETECT; /* reset */
+                snd_ad1848_thinkpad_twiddle(chip, 1);
+#ifdef CONFIG_PM
+                chip->thinkpad_pmstate = pm_register(PM_ISA_DEV, 0, snd_ad1848_pm_callback);
+                if (chip->thinkpad_pmstate) {
+                        chip->thinkpad_pmstate->data = chip;
+                        card->set_power_state = snd_ad1848_set_power_state; /* callback */
+                        card->power_state_private_data = chip;
+                }
+#endif
+        }
 
         if (snd_ad1848_probe(chip) < 0) {
@@ -1149 +1256 @@
         if (! ctl)
                 return -ENOMEM;
-        strncpy(ctl->id.name, name, sizeof(ctl->id.name)-1);
+        strlcpy(ctl->id.name, name, sizeof(ctl->id.name));
         ctl->id.index = index;
         ctl->private_value = value;

GPL/branches/alsa-resync1/alsa-kernel/isa/azt2320.c

@@ -1 @@
-
 /*
     card-azt2320.c - driver for Aztech Systems AZT2320 based soundcards.
@@ -106 +105 @@
 
 struct snd_card_azt2320 {
-#ifdef CONFIG_PNP
         int dev_no;
         struct pnp_dev *dev;
         struct pnp_dev *devmpu;
-#endif  /* CONFIG_PNP */
 };
 

GPL/branches/alsa-resync1/alsa-kernel/isa/cs423x/cs4231_lib.c

@@ -1402 +1402 @@
         switch (rqst) {
         case PM_SUSPEND:
-                if (chip->suspend)
+                if (chip->suspend) {
+                        snd_pcm_suspend_all(chip->pcm);
                         (*chip->suspend)(chip);
+                }
                 break;
         case PM_RESUME:

GPL/branches/alsa-resync1/alsa-kernel/isa/cs423x/cs4236.c

@@ -309 +309 @@
         int err;
 
+        if (!cfg)
+                return -ENOMEM;
+
         acard->wss = pnp_request_card_device(card, id->devs[0].id, NULL);
         if (acard->wss == NULL) {
@@ -393 +396 @@
                 err = pnp_activate_dev(pdev);
                 if (err < 0) {
-                        kfree(cfg);
                         printk(KERN_ERR IDENT " MPU401 PnP configure failed for WSS (out of resources?)\n");
                         mpu_port[dev] = SNDRV_AUTO_PORT;
@@ -410 +412 @@
         return 0;
 }
-#endif
+#endif /* CONFIG_PNP */
 
 static void snd_card_cs4236_free(snd_card_t *card)

GPL/branches/alsa-resync1/alsa-kernel/isa/cs423x/cs4236_lib.c

@@ -285 +285 @@
 
         if (!(chip->hardware & CS4231_HW_CS4236B_MASK)) {
-                snd_printk("CS4236+: MODE3 and extended registers not available, hardware=0x%lx\n",chip->hardware);
+                snd_printk("CS4236+: MODE3 and extended registers not available, hardware=0x%x\n",chip->hardware);
                 snd_device_free(card, chip);
                 return -ENODEV;

GPL/branches/alsa-resync1/alsa-kernel/isa/dt019x.c

@@ -128 +128 @@
                 pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
         if (dma8[dev] != SNDRV_AUTO_DMA)
-                pnp_resource_change(&cfg->dma_resource[0], dma8[dev],
-                        1);
+                pnp_resource_change(&cfg->dma_resource[0], dma8[dev], 1);
         if (irq[dev] != SNDRV_AUTO_IRQ)
                 pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
@@ -159 +158 @@
                         snd_printk(KERN_ERR PFX "DT-019X MPU401 the requested resources are invalid, using auto config\n");
                 err = pnp_activate_dev(pdev);
-                if (err < 0)
+                if (err < 0) {
+                        pnp_release_card_device(pdev);
+                        snd_printk(KERN_ERR PFX "DT-019X MPU401 pnp configure failure, skipping\n");
                         goto __mpu_error;
+                }
                 mpu_port[dev] = pnp_port_start(pdev, 0);
                 mpu_irq[dev] = pnp_irq(pdev, 0);
@@ -166 +168 @@
                                 mpu_port[dev],mpu_irq[dev]);
         } else {
-                __mpu_error:
-                if (pdev) {
-                        pnp_release_card_device(pdev);
-                        snd_printk(KERN_ERR PFX "DT-019X MPU401 pnp configure failure, skipping\n");
-                }
+        __mpu_error:
                 acard->devmpu = NULL;
                 mpu_port[dev] = -1;
@@ -183 +181 @@
                         snd_printk(KERN_ERR PFX "DT-019X OPL3 the requested resources are invalid, using auto config\n");
                 err = pnp_activate_dev(pdev);
-                if (err < 0)
+                if (err < 0) {
+                        pnp_release_card_device(pdev);
+                        snd_printk(KERN_ERR PFX "DT-019X OPL3 pnp configure failure, skipping\n");
                         goto __fm_error;
+                }
                 fm_port[dev] = pnp_port_start(pdev, 0);
                 snd_printdd("dt019x: found OPL3 synth: port=0x%lx\n",fm_port[dev]);
         } else {
-                __fm_error:
-                if (pdev) {
-                        pnp_release_card_device(pdev);
-                        snd_printk(KERN_ERR PFX "DT-019X OPL3 pnp configure failure, skipping\n");
-                }
+        __fm_error:
                 acard->devopl = NULL;
                 fm_port[dev] = -1;

GPL/branches/alsa-resync1/alsa-kernel/isa/gus/gus_main.c

@@ -115 +115 @@
         if (gus->gf1.res_port2 == NULL)
                 goto __hw_end;
-#if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
+#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
         if (gus->seq_dev) {
                 snd_device_free(gus->card, gus->seq_dev);
@@ -443 +443 @@
         if ((err = snd_gus_init_dma_irq(gus, 1)) < 0)
                 return err;
-#if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
+#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
         if (snd_seq_device_new(gus->card, 1, SNDRV_SEQ_DEV_ID_GUS,
                                sizeof(snd_gus_card_t*), &gus->seq_dev) >= 0) {

GPL/branches/alsa-resync1/alsa-kernel/isa/gus/gus_synth.c

@@ -193 +193 @@
                                                    &callbacks,
                                                    SNDRV_SEQ_PORT_CAP_WRITE | SNDRV_SEQ_PORT_CAP_SUBS_WRITE,
-                                                   SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |
-                                                   SNDRV_SEQ_PORT_TYPE_MIDI_GM |
-                                                   SNDRV_SEQ_PORT_TYPE_MIDI_GS |
                                                    SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE |
                                                    SNDRV_SEQ_PORT_TYPE_SYNTH,

GPL/branches/alsa-resync1/alsa-kernel/isa/gus/interwave.c

@@ -770 +770 @@
         if (request_irq(xirq, snd_interwave_interrupt, SA_INTERRUPT, "InterWave", (void *)iwcard)) {
                 snd_card_free(card);
-                snd_printk("unable to grab IRQ %d\n", irq);
+                snd_printk("unable to grab IRQ %d\n", xirq);
                 return -EBUSY;
         }

GPL/branches/alsa-resync1/alsa-kernel/isa/opl3sa2.c

@@ -612 +612 @@
         if (sb_port[dev] != SNDRV_AUTO_PORT)
                 pnp_resource_change(&cfg->port_resource[0], sb_port[dev], 16);
+        if (wss_port[dev] != SNDRV_AUTO_PORT)
                 pnp_resource_change(&cfg->port_resource[1], wss_port[dev], 8);
         if (fm_port[dev] != SNDRV_AUTO_PORT)
@@ -631 +632 @@
         if (err < 0) {
                 kfree(cfg);
-                snd_printk(KERN_ERR "PnP configure failure (out of resources?)\n");
+                snd_printk(KERN_ERR "PnP configure failure (out of resources?) err = %d\n", err);
                 return -EBUSY;
         }

GPL/branches/alsa-resync1/alsa-kernel/isa/opti9xx/opti92x-ad1848.c

@@ -44 +44 @@
 #include <sound/mpu401.h>
 #include <sound/opl3.h>
-#ifdef USE_OPL4
 #ifndef OPTi93X
-#include "opl4.h" /* <sound/opl4.h> */
-#endif
+#include <sound/opl4.h>
 #endif
 #define SNDRV_LEGACY_FIND_FREE_IRQ
@@ -280 +278 @@
 #ifdef CONFIG_PNP
 
-#define ISAPNP_OPTI9XX(_va, _vb, _vc, _device, _fa, _fb, _fc, _audio, _mpu401) \
-        { \
-                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-                .devs = { ISAPNP_DEVICE_ID(_fa, _fb, _fc, _audio), \
-                        ISAPNP_DEVICE_ID(_fa, _fb, _fc, _mpu401), } \
-        }
-
 static struct pnp_card_device_id snd_opti9xx_pnpids[] = {
 #ifndef OPTi93X
@@ -2113 +2104 @@
         if (chip->fm_port > 0) {
                 opl3_t *opl3 = NULL;
-#ifdef USE_OPL4
 #ifndef OPTi93X
                 if (chip->hardware == OPTi9XX_HW_82C928 ||
@@ -2132 +2122 @@
                 }
 #endif  /* !OPTi93X */
-#endif
                 if (!opl3 && snd_opl3_create(card,
                                              chip->fm_port,
@@ -2203 +2192 @@
         int cards, error;
 
+#ifdef CONFIG_PNP
         cards = pnp_register_card_driver(&opti9xx_pnpc_driver);
+#else
+        cards = 0;
+#endif
         if (cards == 0 && (error = snd_card_opti9xx_probe(NULL, NULL)) < 0) {
 #ifdef CONFIG_PNP

GPL/branches/alsa-resync1/alsa-kernel/isa/sb/emu8000.c

@@ -1139 +1139 @@
                 return err;
         }
-#if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE)
+#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
         if (snd_seq_device_new(card, index, SNDRV_SEQ_DEV_ID_EMU8000,
                                sizeof(emu8000_t*), &awe) >= 0) {
@@ -1145 +1145 @@
                 *(emu8000_t**)SNDRV_SEQ_DEVICE_ARGPTR(awe) = hw;
         }
+#else
+        awe = NULL;
 #endif
         if (awe_ret)

GPL/branches/alsa-resync1/alsa-kernel/isa/sb/es968.c

@@ -122 +122 @@
         if (err < 0) {
                 snd_printk(KERN_ERR PFX "AUDIO pnp configure failure\n");
+                kfree(cfg);
                 return err;
         }

GPL/branches/alsa-resync1/alsa-kernel/isa/sb/sb16.c

@@ -67 +67 @@
 #endif
 
-#if defined(SNDRV_SBAWE) && (defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE))
+#if defined(SNDRV_SBAWE) && (defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)))
 #define SNDRV_SBAWE_EMU8000
 #endif
@@ -275 +275 @@
 #endif
 
+#ifdef CONFIG_PNP
+
 static int __devinit snd_card_sb16_pnp(int dev, struct snd_card_sb16 *acard,
                                        struct pnp_card_link *card,
@@ -365 +367 @@
 }
 
+#endif /* CONFIG_PNP */
+
 static int __init snd_sb16_probe(int dev,
                                  struct pnp_card_link *pcard,
@@ -389 +393 @@
         return -ENOMEM;
         acard = (struct snd_card_sb16 *) card->private_data;
+#ifdef CONFIG_PNP
         if (isapnp[dev]) {
                 if ((err = snd_card_sb16_pnp(dev, acard, pcard, pid))) {
@@ -395 +400 @@
                 }
         }
+#endif
 
         xirq = irq[dev];

GPL/branches/alsa-resync1/alsa-kernel/isa/sb/sb16_csp.c

@@ -392 +392 @@
 
             /* fill in codec header */
-            strncpy(p->codec_name, info.codec_name, sizeof(p->codec_name) - 1);
-            p->codec_name[sizeof(p->codec_name) - 1] = 0;
+                        strlcpy(p->codec_name, info.codec_name, sizeof(p->codec_name));
             p->func_nr = func_nr;
             p->mode = LE_SHORT(funcdesc_h.flags_play_rec);

GPL/branches/alsa-resync1/alsa-kernel/isa/sb/sb8_midi.c

@@ -22 +22 @@
  *   Fixed typo in snd_sb8dsp_midi_new_device which prevented midi from
  *   working.
+ *
+ * Sun May 11 12:34:56 UTC 2003 Clemens Ladisch <clemens@ladisch.de>
+ *   Added full duplex UART mode for DSP version 2.0 and later.
  */
 
@@ -41 +44 @@
 
     if (chip == NULL || (rmidi = chip->rmidi) == NULL) {
-        inb(SBP(chip, READ));   /* ack interrupt */
+                inb(SBP(chip, DATA_AVAIL));     /* ack interrupt */
                 return IRQ_NONE;
     }
@@ -48 +51 @@
         if (inb(SBP(chip, DATA_AVAIL)) & 0x80) {
             byte = inb(SBP(chip, READ));
+                        if (chip->open & SB_OPEN_MIDI_INPUT_TRIGGER) {
             spin_unlock(&chip->midi_input_lock);
             snd_rawmidi_receive(chip->midi_substream_input, &byte, 1);
@@ -53 +57 @@
             spin_unlock(&chip->midi_input_lock);
         }
+                } else {
+                        spin_unlock(&chip->midi_input_lock);
+                }
     }
         return IRQ_HANDLED;
@@ -65 +72 @@
     unsigned long flags;
     sb_t *chip;
-
-    chip = snd_magic_cast(sb_t, substream->rmidi->private_data, return -ENXIO);
-    spin_lock_irqsave(&chip->open_lock, flags);
-    if (chip->open) {
+        unsigned int valid_open_flags;
+
+        chip = snd_magic_cast(sb_t, substream->rmidi->private_data, return -ENXIO);
+        valid_open_flags = chip->hardware >= SB_HW_20
+                ? SB_OPEN_MIDI_OUTPUT | SB_OPEN_MIDI_OUTPUT_TRIGGER : 0;
+        spin_lock_irqsave(&chip->open_lock, flags);
+        if (chip->open & ~valid_open_flags) {
         spin_unlock_irqrestore(&chip->open_lock, flags);
         return -EAGAIN;
@@ -77 +87 @@
         spin_unlock_irqrestore(&chip->open_lock, flags);
         snd_sbdsp_reset(chip);          /* reset DSP */
+                if (chip->hardware >= SB_HW_20)
+                        snd_sbdsp_command(chip, SB_DSP_MIDI_UART_IRQ);
     } else {
         spin_unlock_irqrestore(&chip->open_lock, flags);
@@ -87 +99 @@
     unsigned long flags;
     sb_t *chip;
-
-    chip = substream->rmidi->private_data;
-    spin_lock_irqsave(&chip->open_lock, flags);
-    if (chip->open) {
+        unsigned int valid_open_flags;
+
+    chip = substream->rmidi->private_data;
+        valid_open_flags = chip->hardware >= SB_HW_20
+                ? SB_OPEN_MIDI_INPUT | SB_OPEN_MIDI_INPUT_TRIGGER : 0;
+        spin_lock_irqsave(&chip->open_lock, flags);
+        if (chip->open & ~valid_open_flags) {
         spin_unlock_irqrestore(&chip->open_lock, flags);
         return -EAGAIN;
@@ -99 +114 @@
         spin_unlock_irqrestore(&chip->open_lock, flags);
         snd_sbdsp_reset(chip);          /* reset DSP */
+                if (chip->hardware >= SB_HW_20)
+                        snd_sbdsp_command(chip, SB_DSP_MIDI_UART_IRQ);
     } else {
         spin_unlock_irqrestore(&chip->open_lock, flags);
@@ -112 +129 @@
     chip = substream->rmidi->private_data;
     spin_lock_irqsave(&chip->open_lock, flags);
-    chip->open &= ~(SB_OPEN_MIDI_INPUT | SB_OPEN_MIDI_TRIGGER);
+        chip->open &= ~(SB_OPEN_MIDI_INPUT | SB_OPEN_MIDI_INPUT_TRIGGER);
     chip->midi_substream_input = NULL;
     if (!(chip->open & SB_OPEN_MIDI_OUTPUT)) {
@@ -130 +147 @@
     chip = substream->rmidi->private_data;
     spin_lock_irqsave(&chip->open_lock, flags);
-    chip->open &= ~SB_OPEN_MIDI_OUTPUT;
+        chip->open &= ~(SB_OPEN_MIDI_OUTPUT | SB_OPEN_MIDI_OUTPUT_TRIGGER);
     chip->midi_substream_output = NULL;
     if (!(chip->open & SB_OPEN_MIDI_INPUT)) {
@@ -149 +166 @@
     spin_lock_irqsave(&chip->open_lock, flags);
     if (up) {
-        if (!(chip->open & SB_OPEN_MIDI_TRIGGER)) {
+                if (!(chip->open & SB_OPEN_MIDI_INPUT_TRIGGER)) {
+                        if (chip->hardware < SB_HW_20)
             snd_sbdsp_command(chip, SB_DSP_MIDI_INPUT_IRQ);
-            chip->open |= SB_OPEN_MIDI_TRIGGER;
-        }
-    } else {
-        if (chip->open & SB_OPEN_MIDI_TRIGGER) {
+                        chip->open |= SB_OPEN_MIDI_INPUT_TRIGGER;
+                }
+        } else {
+                if (chip->open & SB_OPEN_MIDI_INPUT_TRIGGER) {
+                        if (chip->hardware < SB_HW_20)
             snd_sbdsp_command(chip, SB_DSP_MIDI_INPUT_IRQ);
-            chip->open &= ~SB_OPEN_MIDI_TRIGGER;
+                        chip->open &= ~SB_OPEN_MIDI_INPUT_TRIGGER;
         }
     }
@@ -173 +192 @@
     while (max-- > 0) {
         spin_lock_irqsave(&chip->open_lock, flags);
-        if (snd_rawmidi_transmit(substream, &byte, 1) != 1) {
-            chip->open &= ~SB_OPEN_MIDI_TRIGGER;
+                if (snd_rawmidi_transmit_peek(substream, &byte, 1) != 1) {
+                        chip->open &= ~SB_OPEN_MIDI_OUTPUT_TRIGGER;
             del_timer(&chip->midi_timer);
             spin_unlock_irqrestore(&chip->open_lock, flags);
-            return;
-        }
+                        break;
+                }
+                if (chip->hardware >= SB_HW_20) {
+                        int timeout = 8;
+                        while ((inb(SBP(chip, STATUS)) & 0x80) != 0 && --timeout > 0)
+                                ;
+                        if (timeout == 0) {
+                                /* Tx FIFO full - try again later */
+                                spin_unlock_irqrestore(&chip->open_lock, flags);
+                                break;
+                        }
+                        outb(byte, SBP(chip, WRITE));
+                } else {
         snd_sbdsp_command(chip, SB_DSP_MIDI_OUTPUT);
         snd_sbdsp_command(chip, byte);
+                }
+                snd_rawmidi_transmit_ack(substream, 1);
         spin_unlock_irqrestore(&chip->open_lock, flags);
     }
@@ -206 +238 @@
     spin_lock_irqsave(&chip->open_lock, flags);
     if (up) {
-        if (!(chip->open & SB_OPEN_MIDI_TRIGGER)) {
+                if (!(chip->open & SB_OPEN_MIDI_OUTPUT_TRIGGER)) {
                         init_timer(&chip->midi_timer);
             chip->midi_timer.function = snd_sb8dsp_midi_output_timer;
@@ -212 +244 @@
             chip->midi_timer.expires = 1 + jiffies;
             add_timer(&chip->midi_timer);
-            chip->open |= SB_OPEN_MIDI_TRIGGER;
-        }
-    } else {
-        if (chip->open & SB_OPEN_MIDI_TRIGGER) {
-            chip->open &= ~SB_OPEN_MIDI_TRIGGER;
+                        chip->open |= SB_OPEN_MIDI_OUTPUT_TRIGGER;
+                }
+        } else {
+                if (chip->open & SB_OPEN_MIDI_OUTPUT_TRIGGER) {
+                        chip->open &= ~SB_OPEN_MIDI_OUTPUT_TRIGGER;
         }
     }
@@ -255 +287 @@
     snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_sb8dsp_midi_output);
     snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_sb8dsp_midi_input);
-    rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX;
+        rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT;
+        if (chip->hardware >= SB_HW_20)
+                rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;
     rmidi->private_data = chip;
     chip->rmidi = rmidi;

GPL/branches/alsa-resync1/alsa-kernel/isa/wavefront/wavefront.c

@@ -180 +180 @@
 
         if (cs4232_pcm_port[dev] != SNDRV_AUTO_PORT)
+                pnp_resource_change(&cfg->port_resource[0], cs4232_pcm_port[dev], 4);
         if (fm_port[dev] != SNDRV_AUTO_PORT)
                 pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4);

GPL/branches/alsa-resync1/alsa-kernel/pci/cs4281.c

@@ -27 +27 @@
 #include <linux/pci.h>
 #include <linux/slab.h>
+#ifndef TARGET_OS2 //TODO: Implement linux/gameport.h
+#include <linux/gameport.h>
+#endif /* TARGET_OS2 */
 #include <sound/core.h>
 #include <sound/control.h>
@@ -36 +39 @@
 #include <sound/initval.h>
 
-#ifndef LINUX_2_2
-#include <linux/gameport.h>
-#endif
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
@@ -1247 +1247 @@
  */
 
-#ifndef LINUX_2_2
+#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
 
 typedef struct snd_cs4281_gameport {
@@ -1342 +1342 @@
 static int snd_cs4281_free(cs4281_t *chip)
 {
-#ifndef LINUX_2_2
+#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
     if (chip->gameport) {
         gameport_unregister_port(&chip->gameport->info);
@@ -1730 +1730 @@
     chip->uartm |= CS4281_MODE_OUTPUT;
     chip->midcr |= BA0_MIDCR_TXE;
-    chip->midi_input = substream;
+        chip->midi_output = substream;
     if (!(chip->uartm & CS4281_MODE_INPUT)) {
         snd_cs4281_midi_reset(chip);
@@ -1913 +1913 @@
     /* EOI to the PCI part... reenables interrupts */
     snd_cs4281_pokeBA0(chip, BA0_HICR, BA0_HICR_EOI);
+
     return IRQ_HANDLED;
 
@@ -1991 +1992 @@
         return err;
     }
-#ifndef LINUX_2_2
+#ifndef TARGET_OS2
     snd_cs4281_gameport(chip);
-#endif
+#endif /* !TARGET_OS2 */
     strcpy(card->driver, "CS4281");
     strcpy(card->shortname, "Cirrus Logic CS4281");

GPL/branches/alsa-resync1/alsa-kernel/pci/es1968.c

@@ -667 +667 @@
 }
 
+#define big_mdelay(msec) do {\
+        set_current_state(TASK_UNINTERRUPTIBLE);\
+        schedule_timeout(((msec) * HZ + 999) / 1000);\
+} while (0)
+        
 /* Wait for the codec bus to be free */
 static int snd_es1968_ac97_wait(es1968_t *chip)

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ak4xxx.c

@@ -28 +28 @@
 #include <linux/init.h>
 #include <sound/core.h>
+#include <sound/initval.h>
 #include "ice1712.h"
+
+MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
+MODULE_DESCRIPTION("ICEnsemble ICE17xx <-> AK4xxx AD/DA chip interface");
+MODULE_LICENSE("GPL");
+MODULE_CLASSES("{sound}");
 
 static void snd_ice1712_akm4xxx_lock(akm4xxx_t *ak, int chip)
@@ -98 +104 @@
         }
 
-        /* save the data */
-        if (ak->type == SND_AK4524 || ak->type == SND_AK4528) {
-                if ((addr != 0x04 && addr != 0x05) || (data & 0x80) == 0)
-                        ak->images[chip][addr] = data;
-                else
-                        ak->ipga_gain[chip][addr-4] = data;
-        } else {
-                /* AK4529, or else */
-                ak->images[chip][addr] = data;
-        }
-        
         if (priv->cs_mask == priv->cs_addr) {
                 if (priv->cif) {
@@ -180 +175 @@
         return 0;
 }
+
+EXPORT_SYMBOL(snd_ice1712_akm4xxx_init);
+EXPORT_SYMBOL(snd_ice1712_akm4xxx_free);
+EXPORT_SYMBOL(snd_ice1712_akm4xxx_build_controls);

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ews.c

@@ -390 +390 @@
  */
 
+/* 6fire specific */
+#define PCF9554_REG_INPUT      0
+#define PCF9554_REG_OUTPUT     1
+#define PCF9554_REG_POLARITY   2
+#define PCF9554_REG_CONFIG     3
+
+static int snd_ice1712_6fire_write_pca(ice1712_t *ice, unsigned char reg, unsigned char data);
+
 static int __devinit snd_ice1712_ews_init(ice1712_t *ice)
 {
@@ -426 +434 @@
                         return err;
                 }
+                snd_ice1712_6fire_write_pca(ice, PCF9554_REG_CONFIG, 0x80);
                 break;
         case ICE1712_SUBDEVICE_EWS88MT:
@@ -450 +459 @@
                 if ((err = snd_ice1712_init_cs8427(ice, CS8427_BASE_ADDR)) < 0)
                         return err;
+                snd_cs8427_reg_write(ice->cs8427, CS8427_REG_RECVERRMASK, CS8427_UNLOCK | CS8427_CONF | CS8427_BIP | CS8427_PAR);
                 break;
         case ICE1712_SUBDEVICE_DMX6FIRE:
                 if ((err = snd_ice1712_init_cs8427(ice, ICE1712_6FIRE_CS8427_ADDR)) < 0)
                         return err;
+                snd_cs8427_reg_write(ice->cs8427, CS8427_REG_RECVERRMASK, CS8427_UNLOCK | CS8427_CONF | CS8427_BIP | CS8427_PAR);
                 break;
         case ICE1712_SUBDEVICE_EWS88MT:
@@ -750 +761 @@
  * DMX 6Fire specific controls
  */
-
-#define PCF9554_REG_INPUT       0
-#define PCF9554_REG_OUTPUT      1
-#define PCF9554_REG_POLARITY    2
-#define PCF9554_REG_CONFIG      3
 
 static int snd_ice1712_6fire_read_pca(ice1712_t *ice, unsigned char reg)

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ice1712.c

@@ -119 +119 @@
 
 /*
- *  AK4xxx stuff
- */
-
-#include "ak4xxx.c"
-
-/*
  *  Basic I/O
  */
@@ -305 +299 @@
 {
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, data);
+        inb(ICEREG(ice, DATA)); /* dummy read for pci-posting */
 }
 
@@ -310 +305 @@
 {
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, data);
+        inb(ICEREG(ice, DATA)); /* dummy read for pci-posting */
 }
 
@@ -320 +316 @@
 {
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, val);
+        inb(ICEREG(ice, DATA)); /* dummy read for pci-posting */
 }
 
@@ -667 +664 @@
                 return 0;
         ptr = runtime->buffer_size - inw(ice->ddma_port + 4);
+        if (ptr == runtime->buffer_size)
+                ptr = 0;
         return bytes_to_frames(substream->runtime, ptr);
 }
@@ -684 +683 @@
         ptr = snd_ice1712_ds_read(ice, substream->number * 2, addr) -
                 ice->playback_con_virt_addr[substream->number];
+        if (ptr == substream->runtime->buffer_size)
+                ptr = 0;
         return bytes_to_frames(substream->runtime, ptr);
 }
@@ -695 +696 @@
                 return 0;
         ptr = inl(ICEREG(ice, CONCAP_ADDR)) - ice->capture_con_virt_addr;
+        if (ptr == substream->runtime->buffer_size)
+                ptr = 0;
         return bytes_to_frames(substream->runtime, ptr);
 }
@@ -1105 +1108 @@
                 return 0;
         ptr = ice->playback_pro_size - (inw(ICEMT(ice, PLAYBACK_SIZE)) << 2);
+        if (ptr == substream->runtime->buffer_size)
+                ptr = 0;
         return bytes_to_frames(substream->runtime, ptr);
 }
@@ -1116 +1121 @@
                 return 0;
         ptr = ice->capture_pro_size - (inw(ICEMT(ice, CAPTURE_SIZE)) << 2);
+        if (ptr == substream->runtime->buffer_size)
+                ptr = 0;
         return bytes_to_frames(substream->runtime, ptr);
 }
@@ -2152 +2159 @@
 {
         int dev = 0xa0;         /* EEPROM device address */
-        unsigned int i;
+        unsigned int i, size;
 
         if ((inb(ICEREG(ice, I2C_CTRL)) & ICE1712_I2C_EEPROM) == 0) {
@@ -2163 +2170 @@
                                 (snd_ice1712_read_i2c(ice, dev, 0x03) << 24);
         ice->eeprom.size = snd_ice1712_read_i2c(ice, dev, 0x04);
-        if (ice->eeprom.size > 32) {
+        if (ice->eeprom.size < 6)
+                ice->eeprom.size = 32; /* FIXME: any cards without the correct size? */
+        else if (ice->eeprom.size > 32) {
                 snd_printk("invalid EEPROM (size = %i)\n", ice->eeprom.size);
                 return -EIO;
@@ -2172 +2181 @@
                 /* return -EIO; */
         }
-        for (i = 0; i < ice->eeprom.size; i++)
+        size = ice->eeprom.size - 6;
+        for (i = 0; i < size; i++)
                 ice->eeprom.data[i] = snd_ice1712_read_i2c(ice, dev, i + 6);
 

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ice1712.h

@@ -457 +457 @@
         int (*build_controls)(ice1712_t *);
         int no_mpu401: 1;
+        unsigned int eeprom_size;
+        unsigned char *eeprom_data;
 };
 

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ice1724.c

@@ -43 +43 @@
 #include "amp.h"
 #include "revo.h"
+#include "aureon.h"
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
@@ -51 +52 @@
                REVO_DEVICE_DESC
                AMP_AUDIO2000_DEVICE_DESC
+               AUREON_DEVICE_DESC
                 "{VIA,VT1724},"
                 "{ICEnsemble,Generic ICE1724},"
@@ -89 +91 @@
 
 /*
- *  AK4xxx stuff
- */
-
-#include "ak4xxx.c"
-
-/*
  *  Basic I/O
  */
@@ -123 +119 @@
                 if (!(old_cmd & VT1724_AC97_READY))
                         continue;
-                return 0;
-        }
+                return old_cmd;
+        }
+        snd_printd(KERN_ERR "snd_vt1724_ac97_ready: timeout\n");
         return old_cmd;
 }
@@ -134 +131 @@
                 if ((inb(ICEMT1724(ice, AC97_CMD)) & bit) == 0)
                         return 0;
+        snd_printd(KERN_ERR "snd_vt1724_ac97_wait_bit: timeout\n");
         return -EIO;
 }
@@ -145 +143 @@
 
         old_cmd = snd_vt1724_ac97_ready(ice);
+        old_cmd &= ~VT1724_AC97_ID_MASK;
+        old_cmd |= ac97->num;
         outb(reg, ICEMT1724(ice, AC97_INDEX));
         outw(val, ICEMT1724(ice, AC97_DATA));
-        old_cmd &= ~(VT1724_AC97_PBK_VSR | VT1724_AC97_CAP_VSR);
         outb(old_cmd | VT1724_AC97_WRITE, ICEMT1724(ice, AC97_CMD));
         snd_vt1724_ac97_wait_bit(ice, VT1724_AC97_WRITE);
@@ -158 +157 @@
 
         old_cmd = snd_vt1724_ac97_ready(ice);
+        old_cmd &= ~VT1724_AC97_ID_MASK;
+        old_cmd |= ac97->num;
         outb(reg, ICEMT1724(ice, AC97_INDEX));
         outb(old_cmd | VT1724_AC97_READ, ICEMT1724(ice, AC97_CMD));
@@ -174 +175 @@
 {
         outl(data, ICEREG1724(ice, GPIO_DIRECTION));
+        inw(ICEREG1724(ice, GPIO_DIRECTION)); /* dummy read for pci-posting */
 }
 
@@ -181 +183 @@
         outw(data, ICEREG1724(ice, GPIO_WRITE_MASK));
         outb((data >> 16) & 0xff, ICEREG1724(ice, GPIO_WRITE_MASK_22));
+        inw(ICEREG1724(ice, GPIO_WRITE_MASK)); /* dummy read for pci-posting */
 }
 
@@ -187 +190 @@
         outw(data, ICEREG1724(ice, GPIO_DATA));
         outb(data >> 16, ICEREG1724(ice, GPIO_DATA_22));
+        inw(ICEREG1724(ice, GPIO_DATA)); /* dummy read for pci-posting */
 }
 
@@ -417 +421 @@
                 if (val != old) {
                         outb(val, ICEMT1724(ice, I2S_FORMAT));
-                        /* FIXME: is this revo only? */
-                        /* assert PRST# to converters; MT05 bit 7 */
-                        outb(inb(ICEMT1724(ice, AC97_CMD)) | 0x80, ICEMT1724(ice, AC97_CMD));
-                        spin_unlock_irqrestore(&ice->reg_lock, flags);
-                        mdelay(5);
-                        spin_lock_irqsave(&ice->reg_lock, flags);
-                        /* deassert PRST# */
-                        outb(inb(ICEMT1724(ice, AC97_CMD)) & ~0x80, ICEMT1724(ice, AC97_CMD));
+                        if (ice->eeprom.subvendor == VT1724_SUBDEVICE_REVOLUTION71) {
+                                /* FIXME: is this revo only? */
+                                /* assert PRST# to converters; MT05 bit 7 */
+                                outb(inb(ICEMT1724(ice, AC97_CMD)) | 0x80, ICEMT1724(ice, AC97_CMD));
+                                spin_unlock_irqrestore(&ice->reg_lock, flags);
+                                mdelay(5);
+                                spin_lock_irqsave(&ice->reg_lock, flags);
+                                /* deassert PRST# */
+                                outb(inb(ICEMT1724(ice, AC97_CMD)) & ~0x80, ICEMT1724(ice, AC97_CMD));
+                        }
                 }
         }
@@ -885 +891 @@
         if (! (ice->eeprom.data[ICE_EEP2_ACLINK] & VT1724_CFG_PRO_I2S)) {
                 ac97_t ac97;
+                /* cold reset */
+                outb(inb(ICEMT1724(ice, AC97_CMD)) | 0x80, ICEMT1724(ice, AC97_CMD));
+                mdelay(5); /* FIXME */
+                outb(inb(ICEMT1724(ice, AC97_CMD)) & ~0x80, ICEMT1724(ice, AC97_CMD));
+
                 memset(&ac97, 0, sizeof(ac97));
                 ac97.write = snd_vt1724_ac97_write;
@@ -1541 +1552 @@
  */
 
+static struct snd_ice1712_card_info no_matched __devinitdata;
+
+static struct snd_ice1712_card_info *card_tables[] __devinitdata = {
+        snd_vt1724_revo_cards,
+        snd_vt1724_amp_cards, 
+        snd_vt1724_aureon_cards,
+        0,
+};
+
+
+/*
+ */
+
 static unsigned char __devinit snd_vt1724_read_i2c(ice1712_t *ice,
                                                  unsigned char dev,
@@ -1556 +1580 @@
 {
         int dev = 0xa0;         /* EEPROM device address */
-        unsigned int i;
+        unsigned int i, size;
+        struct snd_ice1712_card_info **tbl, *c;
 
         if ((inb(ICEREG1724(ice, I2C_CTRL)) & VT1724_I2C_EEPROM) == 0) {
@@ -1566 +1591 @@
                                 (snd_vt1724_read_i2c(ice, dev, 0x02) << 16) | 
                                 (snd_vt1724_read_i2c(ice, dev, 0x03) << 24);
+
+        /* if the EEPROM is given by the driver, use it */
+        for (tbl = card_tables; *tbl; tbl++) {
+                for (c = *tbl; c->subvendor; c++) {
+                        if (c->subvendor == ice->eeprom.subvendor) {
+                                if (! c->eeprom_size || ! c->eeprom_data)
+                                        goto found;
+                                snd_printdd("using the defined eeprom..\n");
+                                ice->eeprom.version = 2;
+                                ice->eeprom.size = c->eeprom_size + 6;
+                                memcpy(ice->eeprom.data, c->eeprom_data, c->eeprom_size);
+                                goto read_skipped;
+                        }
+                }
+        }
+
+ found:
         ice->eeprom.size = snd_vt1724_read_i2c(ice, dev, 0x04);
-        if (ice->eeprom.size > 32) {
+        if (ice->eeprom.size < 6)
+                ice->eeprom.size = 32;
+        else if (ice->eeprom.size > 32) {
                 snd_printk("invalid EEPROM (size = %i)\n", ice->eeprom.size);
                 return -EIO;
@@ -1576 +1620 @@
                 // return -EIO;
         }
-        for (i = 0; i < ice->eeprom.size; i++)
+        size = ice->eeprom.size - 6;
+        for (i = 0; i < size; i++)
                 ice->eeprom.data[i] = snd_vt1724_read_i2c(ice, dev, i + 6);
 
+ read_skipped:
         ice->eeprom.gpiomask = eeprom_triple(ice, ICE_EEP2_GPIO_MASK);
         ice->eeprom.gpiostate = eeprom_triple(ice, ICE_EEP2_GPIO_STATE);
@@ -1804 +1850 @@
  */
 
-static struct snd_ice1712_card_info no_matched __devinitdata;
-
-static struct snd_ice1712_card_info *card_tables[] __devinitdata = {
-        snd_vt1724_revo_cards,
-        snd_vt1724_amp_cards, 
-        0,
-};
-
-
 static int __devinit snd_vt1724_probe(struct pci_dev *pci,
                                       const struct pci_device_id *pci_id)

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/makefile.os2

@@ -15 +15 @@
 FILE1    = ak4xxx.obj delta.obj ews.obj hoontech.obj ice1712.obj
 FILE2    = ice1724.obj revo.obj
-FILE3    = 
+FILE3    = aureon.obj
 FILE4    = 
 FILE5    = 

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/revo.c

@@ -60 +60 @@
                 shift = 3;
         }
-        tmp = ak->images[0][reg];
+        tmp = snd_akm4xxx_get(ak, 0, reg);
         old = (tmp >> shift) & 0x03;
         if (old == dfs)
@@ -67 +67 @@
         /* reset DFS */
         snd_akm4xxx_reset(ak, 1);
-        tmp = ak->images[0][reg];
+        tmp = snd_akm4xxx_get(ak, 0, reg);
         tmp &= ~(0x03 << shift);
         tmp |= dfs << shift;
@@ -122 +122 @@
 {
         akm4xxx_t *ak;
+        int err;
 
         /* determine I2C, DACs and ADCs */
@@ -140 +141 @@
         switch (ice->eeprom.subvendor) {
         case VT1724_SUBDEVICE_REVOLUTION71:
-                snd_ice1712_akm4xxx_init(ak, &akm_revo_front, &akm_revo_front_priv, ice);
-                snd_ice1712_akm4xxx_init(ak + 1, &akm_revo_surround, &akm_revo_surround_priv, ice);
+                if ((err = snd_ice1712_akm4xxx_init(ak, &akm_revo_front, &akm_revo_front_priv, ice)) < 0)
+                        return err;
+                if ((err = snd_ice1712_akm4xxx_init(ak + 1, &akm_revo_surround, &akm_revo_surround_priv, ice)) < 0)
+                        return err;
                 /* unmute all codecs */
                 snd_ice1712_gpio_write_bits(ice, VT1724_REVO_MUTE, VT1724_REVO_MUTE);

GPL/branches/alsa-resync1/alsa-kernel/pci/korg1212/korg1212.c

@@ -1145 +1145 @@
 
         if (!doorbellValue)
-                return IRQ_HANDLED;
+                return IRQ_NONE;
 
         spin_lock(&korg1212->lock);
@@ -1219 +1219 @@
 
         spin_unlock(&korg1212->lock);
+
         return IRQ_HANDLED;
 }

GPL/branches/alsa-resync1/alsa-kernel/pci/maestro3.c

@@ -44 +44 @@
 #include <sound/control.h>
 #include <sound/pcm.h>
+#include <sound/mpu401.h>
 #include <sound/ac97_codec.h>
 #define SNDRV_GET_ID
@@ -1055 +1056 @@
  */
 
+#define big_mdelay(msec) do {\
+        set_current_state(TASK_UNINTERRUPTIBLE);\
+        schedule_timeout(((msec) * HZ) / 1000);\
+} while (0)
+        
 inline static void snd_m3_outw(m3_t *chip, u16 value, unsigned long reg)
 {

GPL/branches/alsa-resync1/alsa-kernel/pci/rme96.c

@@ -807 +807 @@
         switch (mode) {
         case RME96_CLOCKMODE_SLAVE:
+                /* AutoSync */ 
                 rme96->wcreg &= ~RME96_WCR_MASTER;
                 rme96->areg &= ~RME96_AR_WSEL;
                 break;
         case RME96_CLOCKMODE_MASTER:
+                /* Internal */
                 rme96->wcreg |= RME96_WCR_MASTER;
                 rme96->areg &= ~RME96_AR_WSEL;
@@ -1319 +1321 @@
 
         runtime->hw = snd_rme96_capture_adat_info;
-        if (snd_rme96_getinputtype(rme96) != RME96_INPUT_ANALOG) {
+        if (snd_rme96_getinputtype(rme96) == RME96_INPUT_ANALOG) {
                 /* makes no sense to use analog input. Note that analog
                    expension cards AEB4/8-I are RME96_INPUT_INTERNAL */
@@ -1863 +1865 @@
         }
         if (rme96->areg & RME96_AR_WSEL) {
-                snd_iprintf(buffer, "  clock mode: word clock\n");
+                snd_iprintf(buffer, "  sample clock source: word clock\n");
         } else if (rme96->wcreg & RME96_WCR_MASTER) {
-                snd_iprintf(buffer, "  clock mode: master\n");
+                snd_iprintf(buffer, "  sample clock source: internal\n");
         } else if (snd_rme96_getinputtype(rme96) == RME96_INPUT_ANALOG) {
-                snd_iprintf(buffer, "  clock mode: slave (master anyway due to analog input setting)\n");
+                snd_iprintf(buffer, "  sample clock source: autosync (internal anyway due to analog input setting)\n");
         } else if (snd_rme96_capture_getrate(rme96, &n) < 0) {
-                snd_iprintf(buffer, "  clock mode: slave (master anyway due to no valid signal)\n");
+                snd_iprintf(buffer, "  sample clock source: autosync (internal anyway due to no valid signal)\n");
         } else {
-                snd_iprintf(buffer, "  clock mode: slave\n");
+                snd_iprintf(buffer, "  sample clock source: autosync\n");
         }
         if (rme96->wcreg & RME96_WCR_PRO) {
@@ -2102 +2104 @@
 snd_rme96_info_clockmode_control(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 {
-        static char *texts[3] = { "Slave", "Master", "Wordclock" };
+        static char *texts[3] = { "AutoSync", "Internal", "Word" };
         
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
@@ -2425 +2427 @@
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
-        .name =         "Clock Mode",
+        .name =         "Sample Clock Source",
         .info =         snd_rme96_info_clockmode_control, 
         .get =          snd_rme96_get_clockmode_control,

GPL/branches/alsa-resync1/alsa-kernel/pci/rme9652/hdsp.c

@@ -23 +23 @@
 
 #include <sound/driver.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
@@ -76 +77 @@
 #define MULTIFACE_SS_CHANNELS    18
 #define MULTIFACE_DS_CHANNELS    14
+#define H9652_DS_CHANNELS        26
+#define H9652_SS_CHANNELS        14
 
 /* Write registers. These are defined as byte-offsets from the iobase value.
@@ -85 +88 @@
 #define HDSP_interruptConfirmation      96
 #define HDSP_outputEnable               128
-#define HDSP_jtagReg                    256
+#define HDSP_control2Reg                256
 #define HDSP_midiDataOut0               352
 #define HDSP_midiDataOut1               356
@@ -121 +124 @@
 #define HDSP_IO_EXTENT     5192
 
-/* jtag register bits */
+/* control2 register bits */
 
 #define HDSP_TMS                0x01
@@ -134 +137 @@
 #define HDSP_BIGENDIAN_MODE     0x200
 #define HDSP_RD_MULTIPLE        0x400
+#define HDSP_9652_ENABLE_MIXER  0x800
 
 #define HDSP_S_PROGRAM          (HDSP_PROGRAM|HDSP_CONFIG_MODE_0)
@@ -359 +363 @@
         struct tasklet_struct midi_tasklet;
         int                   precise_ptr;
-        u32                   control_register;          /* cached value */
+        u32                   control_register;      /* cached value */
+        u32                   control2_register;     /* cached value */
         u32                   creg_spdif;
         u32                   creg_spdif_stream;
-        char                 *card_name;                    /* digiface/multiface */
+        char                 *card_name;             /* digiface/multiface */
         HDSP_IO_Type          io_type;               /* ditto, but for code use */
         unsigned short        firmware_rev;
         unsigned short        state;                 /* stores state bits */
         u32                   firmware_cache[24413]; /* this helps recover from accidental iobox power failure */
-        size_t                period_bytes;         /* guess what this is */
+        size_t                period_bytes;          /* guess what this is */
         unsigned char         ds_channels;
         unsigned char         ss_channels;          /* different for multiface/digiface */
@@ -434 +439 @@
 
 #ifdef HDSP_PREALLOCATE_MEMORY
-extern void *snd_hammerfall_get_buffer(struct pci_dev *, dma_addr_t *dmaaddr);
-extern void snd_hammerfall_free_buffer(struct pci_dev *, void *ptr);
+static void *snd_hammerfall_get_buffer(struct pci_dev *pci, size_t size, dma_addr_t *addrp, int capture)
+{
+        struct snd_dma_device pdev;
+        struct snd_dma_buffer dmbuf;
+
+        snd_dma_device_pci(&pdev, pci, capture);
+        dmbuf.bytes = 0;
+        if (! snd_dma_get_reserved(&pdev, &dmbuf)) {
+                if (snd_dma_alloc_pages(&pdev, size, &dmbuf) < 0)
+                        return NULL;
+                snd_dma_set_reserved(&pdev, &dmbuf);
+        }
+        *addrp = dmbuf.addr;
+        return dmbuf.area;
+}
+
+static void snd_hammerfall_free_buffer(struct pci_dev *pci, size_t size, void *ptr, dma_addr_t addr, int capture)
+{
+        struct snd_dma_device dev;
+        snd_dma_device_pci(&dev, pci, capture);
+        snd_dma_free_reserved(&dev);
+}
+
+#else
+static void *snd_hammerfall_get_buffer(struct pci_dev *pci, size_t size, dma_addr_t *addrp, int capture)
+{
+        return snd_malloc_pci_pages(pci, size, addrp);
+}
+
+static void snd_hammerfall_free_buffer(struct pci_dev *pci, size_t size, void *ptr, dma_addr_t addr, int capture)
+{
+        snd_free_pci_pages(pci, size, ptr, addr);
+}
 #endif
 
@@ -453 +489 @@
 static int __devinit snd_hdsp_create_alsa_devices(snd_card_t *card, hdsp_t *hdsp);
 static int __devinit snd_hdsp_create_pcm(snd_card_t *card, hdsp_t *hdsp);
-static inline int snd_hdsp_initialize_input_enable (hdsp_t *hdsp);
+static inline int snd_hdsp_enable_io (hdsp_t *hdsp);
 static inline void snd_hdsp_initialize_midi_flush (hdsp_t *hdsp);
 static inline void snd_hdsp_initialize_channels (hdsp_t *hdsp);
@@ -461 +497 @@
 static int snd_hdsp_set_defaults(hdsp_t *hdsp);
 
-static inline int hdsp_is_9652 (hdsp_t *hdsp)
-{
-        switch (hdsp->firmware_rev) {
-        case 0x64:
-        case 0x65:
-        case 0x68:
-                return 1;
-        default:
-                return 0;
-        }
-}
-
 static inline int hdsp_playback_to_output_key (hdsp_t *hdsp, int in, int out)
 {
@@ -505 +529 @@
 static inline int hdsp_check_for_iobox (hdsp_t *hdsp)
 {
+
+        if (hdsp->io_type == H9652) return 0;
         if (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_ConfigError) {
                 snd_printk ("Hammerfall-DSP: no Digiface or Multiface connected!\n");
@@ -511 +537 @@
         }
         return 0;
+
 }
 
@@ -522 +549 @@
                 snd_printk ("loading firmware\n");
 
-                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_PROGRAM);
+                hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_PROGRAM);
                 hdsp_write (hdsp, HDSP_fifoData, 0);
                 
@@ -530 +557 @@
                 }
                 
-                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
+                hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_LOAD);
                 
                 for (i = 0; i < 24413; ++i) {
@@ -545 +572 @@
                 }
 
-                hdsp_write (hdsp, HDSP_jtagReg, 0);
+#ifdef SNDRV_BIG_ENDIAN
+                hdsp->control2_register = HDSP_BIGENDIAN_MODE;
+#else
+                hdsp->control2_register = 0;
+#endif
+                hdsp_write (hdsp, HDSP_control2Reg, hdsp->control2_register);
                 snd_printk ("finished firmware loading\n");
                 
@@ -575 +607 @@
         }
 
-        if ((err = snd_hdsp_initialize_input_enable(hdsp)) < 0) {
+        if ((err = snd_hdsp_enable_io(hdsp)) < 0) {
                 return err;
         }
@@ -581 +613 @@
         if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
         
-                hdsp_write (hdsp, HDSP_jtagReg, HDSP_PROGRAM);
+                hdsp_write (hdsp, HDSP_control2Reg, HDSP_PROGRAM);
                 hdsp_write (hdsp, HDSP_fifoData, 0);
                 if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT) < 0) {
@@ -587 +619 @@
                 }
 
-                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
+                hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_LOAD);
                 hdsp_write (hdsp, HDSP_fifoData, 0);
 
                 if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT)) {
                         hdsp->io_type = Multiface;
-                        hdsp_write (hdsp, HDSP_jtagReg, HDSP_VERSION_BIT);
-                        hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
+                        hdsp_write (hdsp, HDSP_control2Reg, HDSP_VERSION_BIT);
+                        hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_LOAD);
                         hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT);
                 } else {
@@ -658 +690 @@
         unsigned int ad;
 
-        if (hdsp_is_9652 (hdsp)) {
-
-                if ((ad = addr/2) < 676) {
-
-                        /* from martin björnsen:
-
-                           "You can only write dwords to the
-                           mixer memory which contain two
-                           mixer values in the low and high
-                           word. So if you want to change
-                           value 0 you have to read value 1
-                           from the cache and write both to
-                           the first dword in the mixer
-                           memory."
-                        */
-
-                        hdsp->mixer_matrix[addr] = data;
-                        hdsp_write (hdsp, 1024 + ad, 
-                                    (hdsp->mixer_matrix[(addr&0x7fe)+1] << 16) + 
-                                    hdsp->mixer_matrix[addr&0x7fe]);
-                        return 0;
-                } else {
-                        return -1;
-                }
+        if (addr >= HDSP_MATRIX_MIXER_SIZE)
+                return -1;
                 
+        if (hdsp->io_type == H9652) {
+
+                /* from martin björnsen:
+                   
+                   "You can only write dwords to the
+                   mixer memory which contain two
+                   mixer values in the low and high
+                   word. So if you want to change
+                   value 0 you have to read value 1
+                   from the cache and write both to
+                   the first dword in the mixer
+                   memory."
+                */
+
+                hdsp->mixer_matrix[addr] = data;
+
+                /* `addr' addresses a 16-bit wide address, but
+                   the address space accessed via hdsp_write
+                   uses byte offsets. put another way, addr
+                   varies from 0 to 1351, but to access the
+                   corresponding memory location, we need
+                   to access 0 to 2703 ...
+                */
+
+                hdsp_write (hdsp, 4096 + (addr*2), 
+                            (hdsp->mixer_matrix[(addr&0x7fe)+1] << 16) + 
+                            hdsp->mixer_matrix[addr&0x7fe]);
+                
+                return 0;
 
         } else {
-                if (addr >= HDSP_MATRIX_MIXER_SIZE)
-                        return -1;
-                
+
                 ad = (addr << 16) + data;
                 
@@ -830 +867 @@
         int rate_bits;
 
+        /* ASSUMPTION: hdsp->lock is either help, or
+           there is no need for it (e.g. during module
+           initialization).
+        */
+        
         if (!(hdsp->control_register & HDSP_ClockModeMaster)) { 
                 if (called_internally) {
@@ -861 +903 @@
            is to flag rate changes in the read/write routines.  */
 
-        spin_lock_irq(&hdsp->lock);
-
         switch (rate) {
         case 32000:
@@ -901 +941 @@
                 break;
         default:
-                spin_unlock_irq(&hdsp->lock);
                 return -EINVAL;
         }
@@ -909 +948 @@
                             hdsp->capture_pid,
                             hdsp->playback_pid);
-                spin_unlock_irq(&hdsp->lock);
                 return -EBUSY;
         }
@@ -925 +963 @@
                         break;
                 case Digiface:
+                case H9652:
                         hdsp->channel_map = channel_map_df_ss;
                         break;
@@ -939 +978 @@
         }
 
-        spin_unlock_irq(&hdsp->lock);
         return 0;
 }
@@ -1132 +1170 @@
         hdsp_midi_t *hmidi;
         unsigned long flags;
+        u32 ie;
 
         hmidi = (hdsp_midi_t *) substream->rmidi->private_data;
         hdsp = hmidi->hdsp;
+        ie = hmidi->id ? HDSP_Midi1InterruptEnable : HDSP_Midi0InterruptEnable;
         spin_lock_irqsave (&hdsp->lock, flags);
         if (up) {
-                snd_hdsp_flush_midi_input (hdsp, hmidi->id);
-                if (hmidi->id) 
-                        hdsp->control_register |= HDSP_Midi1InterruptEnable;
-                else 
-                        hdsp->control_register |= HDSP_Midi0InterruptEnable;
+                if (!(hdsp->control_register & ie)) {
+                        snd_hdsp_flush_midi_input (hdsp, hmidi->id);
+                        hdsp->control_register |= ie;
+                }
         } else {
-                if (hmidi->id) 
-                        hdsp->control_register &= ~HDSP_Midi1InterruptEnable;
-                else 
-                        hdsp->control_register &= ~HDSP_Midi0InterruptEnable;
+                hdsp->control_register &= ~ie;
         }
 
@@ -2005 +2041 @@
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
-        uinfo->value.enumerated.items = (hdsp->io_type == Digiface) ? 6 : 4;
+
+        switch (hdsp->io_type) {
+        case Digiface:
+        case H9652:
+                uinfo->value.enumerated.items = 6;
+                break;
+        case Multiface:
+                uinfo->value.enumerated.items = 4;
+        default:
+                uinfo->value.enumerated.items = 0;
+                break;
+        }
+                
         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
@@ -2029 +2077 @@
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
-        max = (hdsp->io_type == Digiface) ? 6 : 4;
+
+        switch (hdsp->io_type) {
+        case Digiface:
+        case H9652:
+                max = 6;
+                break;
+        case Multiface:
+                max = 4;
+                break;
+        default:
+                return -EIO;
+        }
+
         val = ucontrol->value.enumerated.item[0] % max;
         spin_lock_irqsave(&hdsp->lock, flags);
@@ -2497 +2557 @@
 
         offset = ucontrol->id.index - 1;
-        snd_assert(offset >= 0 || offset < ((hdsp->io_type == Digiface) ? 3 : 1), return -EINVAL);
+        snd_assert(offset >= 0);
+
+        switch (hdsp->io_type) {
+        case Digiface:
+        case H9652:
+                if (offset >= 3)
+                        return -EINVAL;
+                break;
+        case Multiface:
+                if (offset >= 1) 
+                        return -EINVAL;
+                break;
+        default:
+                return -EIO;
+        }
+
         ucontrol->value.enumerated.item[0] = hdsp_adat_sync_check(hdsp, offset);
         return 0;
@@ -2594 +2669 @@
 
         for (idx = 0; idx < HDSP_CONTROLS; idx++) {
-                if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_hdsp_controls[idx], hdsp))) < 0)
+                if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_hdsp_controls[idx], hdsp))) < 0) {
                         return err;
+                }
                 if (idx == 1)   /* IEC958 (S/PDIF) Stream */
                         hdsp->spdif_ctl = kctl;
@@ -2603 +2679 @@
         snd_hdsp_adat_sync_check.name = "ADAT Lock Status";
 
-        if (hdsp->io_type == Digiface) {
+        switch (hdsp->io_type) {
+        case Digiface:
                 limit = DIGIFACE_SS_CHANNELS;
-        } else {
+                break;
+        case H9652:
+                limit = H9652_SS_CHANNELS;
+                break;
+        case Multiface:
                 limit = MULTIFACE_SS_CHANNELS;
+                break;
+        default:
+                return -EIO;
         }
         
@@ -2628 +2712 @@
                 return err;
         }       
-        if (hdsp->io_type == Digiface) {
+        if (hdsp->io_type == Digiface || hdsp->io_type == H9652) {
                 for (idx = 1; idx < 3; ++idx) {
                         snd_hdsp_adat_sync_check.index = idx+1;
@@ -2682 +2766 @@
                     hdsp->irq, hdsp->port, hdsp->iobase);
         snd_iprintf(buffer, "Control register: 0x%x\n", hdsp->control_register);
+        snd_iprintf(buffer, "Control2 register: 0x%x\n", hdsp->control2_register);
         snd_iprintf(buffer, "Status register: 0x%x\n", status);
         snd_iprintf(buffer, "Status2 register: 0x%x\n", status2);
@@ -2855 +2940 @@
         switch (hdsp->io_type) {
         case Digiface:
+        case H9652:
                 x = status & HDSP_Sync1;
                 if (status & HDSP_Lock1) {
@@ -2914 +3000 @@
 {
         if (hdsp->capture_buffer_unaligned) {
-#ifndef HDSP_PREALLOCATE_MEMORY
-                snd_free_pci_pages(hdsp->pci,
-                                   HDSP_DMA_AREA_BYTES,
-                                   hdsp->capture_buffer_unaligned,
-                                   hdsp->capture_buffer_addr);
-#else
-                snd_hammerfall_free_buffer(hdsp->pci, hdsp->capture_buffer_unaligned);
-#endif
+                snd_hammerfall_free_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES,
+                                           hdsp->capture_buffer_unaligned,
+                                           hdsp->capture_buffer_addr, 1);
         }
 
         if (hdsp->playback_buffer_unaligned) {
-#ifndef HDSP_PREALLOCATE_MEMORY
-                snd_free_pci_pages(hdsp->pci,
-                                   HDSP_DMA_AREA_BYTES,
-                                   hdsp->playback_buffer_unaligned,
-                                   hdsp->playback_buffer_addr);
-#else
-                snd_hammerfall_free_buffer(hdsp->pci, hdsp->playback_buffer_unaligned);
-#endif
+                snd_hammerfall_free_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES,
+                                           hdsp->playback_buffer_unaligned,
+                                           hdsp->playback_buffer_addr, 0);
         }
 }
@@ -2942 +3018 @@
         unsigned long pb_bus, cb_bus;
 
-#ifndef HDSP_PREALLOCATE_MEMORY
-        cb = snd_malloc_pci_pages(hdsp->pci, HDSP_DMA_AREA_BYTES, &cb_addr);
-        pb = snd_malloc_pci_pages(hdsp->pci, HDSP_DMA_AREA_BYTES, &pb_addr);
-#else
-        cb = snd_hammerfall_get_buffer(hdsp->pci, &cb_addr);
-        pb = snd_hammerfall_get_buffer(hdsp->pci, &pb_addr);
-#endif
+        cb = snd_hammerfall_get_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES, &cb_addr, 1);
+        pb = snd_hammerfall_get_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES, &pb_addr, 0);
 
         if (cb == 0 || pb == 0) {
                 if (cb) {
-#ifdef HDSP_PREALLOCATE_MEMORY
-                        snd_hammerfall_free_buffer(hdsp->pci, cb);
-#else
-                        snd_free_pci_pages(hdsp->pci, HDSP_DMA_AREA_BYTES, cb, cb_addr);
-#endif
+                        snd_hammerfall_free_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES, cb, cb_addr, 1);
                 }
                 if (pb) {
-#ifdef HDSP_PREALLOCATE_MEMORY
-                        snd_hammerfall_free_buffer(hdsp->pci, pb);
-#else
-                        snd_free_pci_pages(hdsp->pci, HDSP_DMA_AREA_BYTES, pb, pb_addr);
-#endif
+                        snd_hammerfall_free_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES, pb, pb_addr, 0);
                 }
 
@@ -3026 +3089 @@
         }
 
-        for (i = 0; i < (hdsp_is_9652(hdsp) ? 1352 : HDSP_MATRIX_MIXER_SIZE); i++) {
+        for (i = 0; i < (hdsp->io_type == H9652 ? 1352 : HDSP_MATRIX_MIXER_SIZE); i++) {
                 if (hdsp_write_gain (hdsp, i, MINUS_INFINITY_GAIN)) {
                         return -EIO;
@@ -3032 +3095 @@
         }
         
-        if (!hdsp_is_9652(hdsp) && line_outs_monitor[hdsp->dev]) {
+        if ((hdsp->io_type != H9652) && line_outs_monitor[hdsp->dev]) {
                 
                 snd_printk ("sending all inputs and playback streams to line outs.\n");
@@ -3292 +3355 @@
          */
 
+        spin_lock_irq(&hdsp->lock);
         if ((err = hdsp_set_rate(hdsp, params_rate(params), 0)) < 0) {
+                spin_unlock_irq(&hdsp->lock);
                 _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_RATE);
                 return err;
+        } else {
+                spin_unlock_irq(&hdsp->lock);
         }
 
@@ -3784 +3851 @@
                 break;
         case SNDRV_HDSP_IOCTL_GET_VERSION:
-                if (hdsp_is_9652(hdsp)) return -EINVAL;
+                if (hdsp->io_type == H9652) return -EINVAL;
                 if (hdsp->io_type == Undefined) {
                         if ((err = hdsp_get_iobox_version(hdsp)) < 0) {
@@ -3797 +3864 @@
                 break;
         case SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE:
-                if (hdsp_is_9652(hdsp)) return -EINVAL;
+                if (hdsp->io_type == H9652) return -EINVAL;
                 /* SNDRV_HDSP_IOCTL_GET_VERSION must have been called */
                 if (hdsp->io_type == Undefined) return -EINVAL;
@@ -3905 +3972 @@
 }
 
-static inline int snd_hdsp_initialize_input_enable (hdsp_t *hdsp)
+static inline void snd_hdsp_9652_enable_mixer (hdsp_t *hdsp)
+{
+        hdsp->control2_register |= HDSP_9652_ENABLE_MIXER;
+        hdsp_write (hdsp, HDSP_control2Reg, hdsp->control2_register);
+}
+
+static inline void snd_hdsp_9652_disable_mixer (hdsp_t *hdsp)
+{
+        hdsp->control2_register &= ~HDSP_9652_ENABLE_MIXER;
+        hdsp_write (hdsp, HDSP_control2Reg, hdsp->control2_register);
+}
+
+static inline int snd_hdsp_enable_io (hdsp_t *hdsp)
 {
         int i;
@@ -3923 +4002 @@
 static inline void snd_hdsp_initialize_channels(hdsp_t *hdsp)
 {
-        if (hdsp->io_type == Digiface) {
+        switch (hdsp->io_type) {
+        case Digiface:
                 hdsp->card_name = "RME Hammerfall DSP + Digiface";
                 hdsp->ss_channels = DIGIFACE_SS_CHANNELS;
                 hdsp->ds_channels = DIGIFACE_DS_CHANNELS;
-        } else {
+                break;
+
+        case H9652:
+                hdsp->card_name = "RME Hammerfall HDSP 9652";
+                hdsp->ss_channels = H9652_SS_CHANNELS;
+                hdsp->ds_channels = H9652_DS_CHANNELS;
+                break;
+
+        case Multiface:
                 hdsp->card_name = "RME Hammerfall DSP + Multiface";
                 hdsp->ss_channels = MULTIFACE_SS_CHANNELS;
                 hdsp->ds_channels = MULTIFACE_DS_CHANNELS;
+
+        default:
+                /* should never get here */
+                break;
         }
 }
@@ -3938 +4030 @@
         snd_hdsp_flush_midi_input (hdsp, 0);
         snd_hdsp_flush_midi_input (hdsp, 1);
-
-#ifdef SNDRV_BIG_ENDIAN
-        hdsp_write(hdsp, HDSP_jtagReg, HDSP_BIGENDIAN_MODE);
-#endif
 }
 
@@ -4002 +4090 @@
         int err;
         int i;
+        int is_9652 = 0;
 
         hdsp->irq = -1;
@@ -4028 +4117 @@
         strcpy(card->driver, "H-DSP");
         strcpy(card->mixername, "Xilinx FPGA");
-        
+
         switch (hdsp->firmware_rev & 0xff) {
         case 0xa:
@@ -4034 +4123 @@
                 hdsp->card_name = "RME Hammerfall DSP";
                 break;
+
         case 0x64:
         case 0x65:
         case 0x68:
                 hdsp->card_name = "RME HDSP 9652";
-                break;
+                is_9652 = 1;
+                break;
+
         default:
                 return -ENODEV;
         }
 
-        if ((err = pci_enable_device(pci)) < 0)
+        if ((err = pci_enable_device(pci)) < 0) {
                 return err;
+        }
 
         pci_set_master(hdsp->pci);
@@ -4072 +4165 @@
         }
         
-        if (hdsp_is_9652(hdsp)) {
-                
-                if ((err = snd_hdsp_initialize_input_enable(hdsp)) != 0) {
-                        return err;
-                }
-
-                hdsp->io_type = Digiface;               
-        
-                hdsp->ss_channels = DIGIFACE_SS_CHANNELS;
-                hdsp->ds_channels = DIGIFACE_DS_CHANNELS;
-        
-                snd_hdsp_initialize_midi_flush(hdsp);
-        
+        if (!is_9652 && hdsp_check_for_iobox (hdsp)) {
+                /* no iobox connected, we defer initialization */
+                snd_printk("card initialization pending : waiting for firmware\n");
                 if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0) {
                         return err;
                 }
-
-        } else {
-        
-                if (hdsp_check_for_iobox (hdsp)) {
-                        /* no iobox connected, we defer initialization */
-                        snd_printk("card initialization pending : waiting for firmware\n");
-                        if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0) {
-                                return err;
-                        }
-                        return 0;
-                }
-
-                if ((err = snd_hdsp_initialize_input_enable(hdsp)) != 0) {
-                        return err;
-                }
-                
-                if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
-                        snd_printk("card initialization pending : waiting for firmware\n");
-                        if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0) {
-                                return err;
-                        }
                 return 0;
-                } 
-                
-                snd_printk("Firmware already loaded, initializing card.\n");
-
-                if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version1) {
-                        hdsp->io_type = Multiface;
-                } else {
-                        hdsp->io_type = Digiface;
-                }
-                
+        }
+        
+        if ((err = snd_hdsp_enable_io(hdsp)) != 0) {
+                return err;
+        }
+        
+        if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
+                snd_printk("card initialization pending : waiting for firmware\n");
                 if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0) {
                         return err;
                 }
-                
-                snd_hdsp_initialize_channels(hdsp);
-                
-                snd_hdsp_initialize_midi_flush(hdsp);
-                
-        }
-        
+                return 0;
+        } 
+        
+        snd_printk("Firmware already loaded, initializing card.\n");
+        
+        if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version1) {
+                hdsp->io_type = Multiface;
+        } else {
+                hdsp->io_type = Digiface;
+        }
+
+        if (is_9652) {
+                hdsp->io_type = H9652;
+                snd_hdsp_9652_enable_mixer (hdsp);
+        }
+
+        if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0) {
+                return err;
+        }
+        
+        snd_hdsp_initialize_channels(hdsp);
+        snd_hdsp_initialize_midi_flush(hdsp);
+
         hdsp->state |= HDSP_FirmwareLoaded;     
-        
+
         if ((err = snd_hdsp_create_alsa_devices(card, hdsp)) < 0) {
                 return err;
         }
-        
+
         return 0;       
 }
@@ -4202 +4278 @@
         sprintf(card->longname, "%s at 0x%lx, irq %d", hdsp->card_name, 
                 hdsp->port, hdsp->irq);
-        
+
         if ((err = snd_card_register(card)) < 0) {
                 snd_card_free(card);

GPL/branches/alsa-resync1/alsa-kernel/pci/rme9652/makefile.os2

@@ -13 +13 @@
 #
 #===================================================================
-FILE1    = hammerfall_mem.obj rme9652.obj hdsp.obj
+FILE1    = rme9652.obj hdsp.obj
 FILE2    = 
 FILE3    = 

GPL/branches/alsa-resync1/alsa-kernel/pci/rme9652/rme9652.c

@@ -310 +310 @@
 
 #ifdef RME9652_PREALLOCATE_MEMORY
-extern void *snd_hammerfall_get_buffer(struct pci_dev *, dma_addr_t *dmaaddr);
-extern void snd_hammerfall_free_buffer(struct pci_dev *, void *ptr);
+static void *snd_hammerfall_get_buffer(struct pci_dev *pci, size_t size, dma_addr_t *addrp, int capture)
+{
+        struct snd_dma_device pdev;
+        struct snd_dma_buffer dmbuf;
+
+        snd_dma_device_pci(&pdev, pci, capture);
+        dmbuf.bytes = 0;
+        if (! snd_dma_get_reserved(&pdev, &dmbuf)) {
+                if (snd_dma_alloc_pages(&pdev, size, &dmbuf) < 0)
+                        return NULL;
+                snd_dma_set_reserved(&pdev, &dmbuf);
+        }
+        *addrp = dmbuf.addr;
+        return dmbuf.area;
+}
+
+static void snd_hammerfall_free_buffer(struct pci_dev *pci, size_t size, void *ptr, dma_addr_t addr, int capture)
+{
+        struct snd_dma_device dev;
+        snd_dma_device_pci(&dev, pci, capture);
+        snd_dma_free_reserved(&dev);
+}
+
+#else
+static void *snd_hammerfall_get_buffer(struct pci_dev *pci, size_t size, dma_addr_t *addrp, int capture)
+{
+        return snd_malloc_pci_pages(pci, size, addrp);
+}
+
+static void snd_hammerfall_free_buffer(struct pci_dev *pci, size_t size, void *ptr, dma_addr_t addr, int capture)
+{
+        snd_free_pci_pages(pci, size, ptr, addr);
+}
 #endif
+
 
 static struct pci_device_id snd_rme9652_ids[] __devinitdata = {
@@ -1810 +1842 @@
 {
         if (rme9652->capture_buffer_unaligned) {
-#ifndef RME9652_PREALLOCATE_MEMORY
-                snd_free_pci_pages(rme9652->pci,
-                                   RME9652_DMA_AREA_BYTES,
-                                   rme9652->capture_buffer_unaligned,
-                                   rme9652->capture_buffer_addr);
-#else
-                snd_hammerfall_free_buffer(rme9652->pci, rme9652->capture_buffer_unaligned);
-#endif
+                snd_hammerfall_free_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES,
+                                           rme9652->capture_buffer_unaligned,
+                                           rme9652->capture_buffer_addr, 1);
         }
 
         if (rme9652->playback_buffer_unaligned) {
-#ifndef RME9652_PREALLOCATE_MEMORY
-                snd_free_pci_pages(rme9652->pci,
-                                   RME9652_DMA_AREA_BYTES,
-                                   rme9652->playback_buffer_unaligned,
-                                   rme9652->playback_buffer_addr);
-#else
-                snd_hammerfall_free_buffer(rme9652->pci, rme9652->playback_buffer_unaligned);
-#endif
+                snd_hammerfall_free_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES,
+                                           rme9652->playback_buffer_unaligned,
+                                           rme9652->playback_buffer_addr, 0);
         }
 }
@@ -1855 +1877 @@
         unsigned long pb_bus, cb_bus;
 
-#ifndef RME9652_PREALLOCATE_MEMORY
-        cb = snd_malloc_pci_pages(rme9652->pci, RME9652_DMA_AREA_BYTES, &cb_addr);
-        pb = snd_malloc_pci_pages(rme9652->pci, RME9652_DMA_AREA_BYTES, &pb_addr);
-#else
-        cb = snd_hammerfall_get_buffer(rme9652->pci, &cb_addr);
-        pb = snd_hammerfall_get_buffer(rme9652->pci, &pb_addr);
-#endif
+        cb = snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES, &cb_addr, 1);
+        pb = snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES, &pb_addr, 0);
 
         if (cb == 0 || pb == 0) {
                 if (cb) {
-#ifdef RME9652_PREALLOCATE_MEMORY
-                        snd_hammerfall_free_buffer(rme9652->pci, cb);
-#else
-                        snd_free_pci_pages(rme9652->pci, RME9652_DMA_AREA_BYTES, cb, cb_addr);
-#endif
+                        snd_hammerfall_free_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES, cb, cb_addr, 1);
                 }
                 if (pb) {
-#ifdef RME9652_PREALLOCATE_MEMORY
-                        snd_hammerfall_free_buffer(rme9652->pci, pb);
-#else
-                        snd_free_pci_pages(rme9652->pci, RME9652_DMA_AREA_BYTES, pb, pb_addr);
-#endif
+                        snd_hammerfall_free_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES, pb, pb_addr, 0);
                 }
 

GPL/branches/alsa-resync1/alsa-kernel/pci/sonicvibes.c

@@ -260 +260 @@
         snd_kcontrol_t *master_volume;
 
-#if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE)
+#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
         struct gameport gameport;
 #endif
@@ -1194 +1194 @@
 static int snd_sonicvibes_free(sonicvibes_t *sonic)
 {
-#if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE)
+#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
         if (sonic->gameport.io)
                 gameport_unregister_port(&sonic->gameport);
@@ -1498 +1498 @@
                 return err;
         }
-#if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE)
+#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
         sonic->gameport.io = sonic->game_port;
         gameport_register_port(&sonic->gameport);

GPL/branches/alsa-resync1/alsa-kernel/pci/ymfpci/ymfpci_main.c

@@ -2316 +2316 @@
     init_waitqueue_head(&chip->interrupt_sleep);
     atomic_set(&chip->interrupt_sleep_count, 0);
+#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
+        init_MUTEX(&chip->joystick_mutex);
+#endif
     chip->card = card;
     chip->pci = pci;