1 files changed, 122 insertions, 63 deletions

diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index 6517f589d01d..cec68152dcb1 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -60,10 +60,14 @@ static int bdl_pos_adj[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = -1};
 static int probe_mask[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = -1};
 static int probe_only[SNDRV_CARDS];
 static int single_cmd;
-static int enable_msi;
+static int enable_msi = -1;
 #ifdef CONFIG_SND_HDA_PATCH_LOADER
 static char *patch[SNDRV_CARDS];
 #endif
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+static int beep_mode[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] =
+                                        CONFIG_SND_HDA_INPUT_BEEP_MODE};
+#endif
 
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for Intel HD audio interface.");
@@ -91,6 +95,11 @@ MODULE_PARM_DESC(enable_msi, "Enable Message Signaled Interrupt (MSI)");
 module_param_array(patch, charp, NULL, 0444);
 MODULE_PARM_DESC(patch, "Patch file for Intel HD audio interface.");
 #endif
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+module_param_array(beep_mode, int, NULL, 0444);
+MODULE_PARM_DESC(beep_mode, "Select HDA Beep registration mode "
+                            "(0=off, 1=on, 2=mute switch on/off) (default=1).");
+#endif
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
 static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT;
@@ -116,6 +125,7 @@ MODULE_SUPPORTED_DEVICE("{{Intel, ICH6},"
                          "{Intel, ICH9},"
                          "{Intel, ICH10},"
                          "{Intel, PCH},"
+                         "{Intel, CPT},"
                          "{Intel, SCH},"
                          "{ATI, SB450},"
                          "{ATI, SB600},"
@@ -250,8 +260,6 @@ enum { SDI0, SDI1, SDI2, SDI3, SDO0, SDO1, SDO2, SDO3 };
 #define AZX_MAX_FRAG            32
 /* max buffer size - no h/w limit, you can increase as you like */
 #define AZX_MAX_BUF_SIZE        (1024*1024*1024)
-/* max number of PCM devics per card */
-#define AZX_MAX_PCMS            8
 
 /* RIRB int mask: overrun[2], response[0] */
 #define RIRB_INT_RESPONSE       0x01
@@ -259,7 +267,8 @@ enum { SDI0, SDI1, SDI2, SDI3, SDO0, SDO1, SDO2, SDO3 };
 #define RIRB_INT_MASK           0x05
 
 /* STATESTS int mask: S3,SD2,SD1,SD0 */
-#define AZX_MAX_CODECS          4
+#define AZX_MAX_CODECS          8
+#define AZX_DEFAULT_CODECS      4
 #define STATESTS_INT_MASK       ((1 << AZX_MAX_CODECS) - 1)
 
 /* SD_CTL bits */
@@ -347,6 +356,7 @@ struct azx_dev {
                                          */
         unsigned char stream_tag;       /* assigned stream */
         unsigned char index;            /* stream index */
+        int device;                     /* last device number assigned to */
 
         unsigned int opened :1;
         unsigned int running :1;
@@ -398,12 +408,13 @@ struct azx {
         struct azx_dev *azx_dev;
 
         /* PCM */
-        struct snd_pcm *pcm[AZX_MAX_PCMS];
+        struct snd_pcm *pcm[HDA_MAX_PCMS];
 
         /* HD codec */
         unsigned short codec_mask;
         int  codec_probe_mask; /* copied from probe_mask option */
         struct hda_bus *bus;
+        unsigned int beep_mode;
 
         /* CORB/RIRB */
         struct azx_rb corb;
@@ -415,6 +426,7 @@ struct azx {
 
         /* flags */
         int position_fix;
+        int poll_count;
         unsigned int running :1;
         unsigned int initialized :1;
         unsigned int single_cmd :1;
@@ -437,6 +449,7 @@ struct azx {
 /* driver types */
 enum {
         AZX_DRIVER_ICH,
+        AZX_DRIVER_PCH,
         AZX_DRIVER_SCH,
         AZX_DRIVER_ATI,
         AZX_DRIVER_ATIHDMI,
@@ -451,6 +464,7 @@ enum {
 
 static char *driver_short_names[] __devinitdata = {
         [AZX_DRIVER_ICH] = "HDA Intel",
+        [AZX_DRIVER_PCH] = "HDA Intel PCH",
         [AZX_DRIVER_SCH] = "HDA Intel MID",
         [AZX_DRIVER_ATI] = "HDA ATI SB",
         [AZX_DRIVER_ATIHDMI] = "HDA ATI HDMI",
@@ -495,7 +509,7 @@ static char *driver_short_names[] __devinitdata = {
 #define get_azx_dev(substream) (substream->runtime->private_data)
 
 static int azx_acquire_irq(struct azx *chip, int do_disconnect);
-
+static int azx_send_cmd(struct hda_bus *bus, unsigned int val);
 /*
  * Interface for HD codec
  */
@@ -653,11 +667,12 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus,
 {
         struct azx *chip = bus->private_data;
         unsigned long timeout;
+        int do_poll = 0;
 
  again:
         timeout = jiffies + msecs_to_jiffies(1000);
         for (;;) {
-                if (chip->polling_mode) {
+                if (chip->polling_mode || do_poll) {
                         spin_lock_irq(&chip->reg_lock);
                         azx_update_rirb(chip);
                         spin_unlock_irq(&chip->reg_lock);
@@ -665,6 +680,9 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus,
                 if (!chip->rirb.cmds[addr]) {
                         smp_rmb();
                         bus->rirb_error = 0;
+
+                        if (!do_poll)
+                                chip->poll_count = 0;
                         return chip->rirb.res[addr]; /* the last value */
                 }
                 if (time_after(jiffies, timeout))
@@ -677,6 +695,24 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus,
                 }
         }
 
+        if (!chip->polling_mode && chip->poll_count < 2) {
+                snd_printdd(SFX "azx_get_response timeout, "
+                           "polling the codec once: last cmd=0x%08x\n",
+                           chip->last_cmd[addr]);
+                do_poll = 1;
+                chip->poll_count++;
+                goto again;
+        }
+
+
+        if (!chip->polling_mode) {
+                snd_printk(KERN_WARNING SFX "azx_get_response timeout, "
+                           "switching to polling mode: last cmd=0x%08x\n",
+                           chip->last_cmd[addr]);
+                chip->polling_mode = 1;
+                goto again;
+        }
+
         if (chip->msi) {
                 snd_printk(KERN_WARNING SFX "No response from codec, "
                            "disabling MSI: last cmd=0x%08x\n",
@@ -692,14 +728,6 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus,
                 goto again;
         }
 
-        if (!chip->polling_mode) {
-                snd_printk(KERN_WARNING SFX "azx_get_response timeout, "
-                           "switching to polling mode: last cmd=0x%08x\n",
-                           chip->last_cmd[addr]);
-                chip->polling_mode = 1;
-                goto again;
-        }
-
         if (chip->probing) {
                 /* If this critical timeout happens during the codec probing
                  * phase, this is likely an access to a non-existing codec
@@ -942,8 +970,8 @@ static void azx_stream_start(struct azx *chip, struct azx_dev *azx_dev)
         azx_dev->insufficient = 1;
 
         /* enable SIE */
-        azx_writeb(chip, INTCTL,
-                   azx_readb(chip, INTCTL) | (1 << azx_dev->index));
+        azx_writel(chip, INTCTL,
+                   azx_readl(chip, INTCTL) | (1 << azx_dev->index));
         /* set DMA start and interrupt mask */
         azx_sd_writeb(azx_dev, SD_CTL, azx_sd_readb(azx_dev, SD_CTL) |
                       SD_CTL_DMA_START | SD_INT_MASK);
@@ -962,8 +990,8 @@ static void azx_stream_stop(struct azx *chip, struct azx_dev *azx_dev)
 {
         azx_stream_clear(chip, azx_dev);
         /* disable SIE */
-        azx_writeb(chip, INTCTL,
-                   azx_readb(chip, INTCTL) & ~(1 << azx_dev->index));
+        azx_writel(chip, INTCTL,
+                   azx_readl(chip, INTCTL) & ~(1 << azx_dev->index));
 }
 
 
@@ -1039,6 +1067,7 @@ static void azx_init_pci(struct azx *chip)
                                 0x01, NVIDIA_HDA_ENABLE_COHBIT);
                 break;
         case AZX_DRIVER_SCH:
+        case AZX_DRIVER_PCH:
                 pci_read_config_word(chip->pci, INTEL_SCH_HDA_DEVC, &snoop);
                 if (snoop & INTEL_SCH_HDA_DEVC_NOSNOOP) {
                         pci_write_config_word(chip->pci, INTEL_SCH_HDA_DEVC,
@@ -1324,7 +1353,7 @@ static void azx_bus_reset(struct hda_bus *bus)
         if (chip->initialized) {
                 int i;
 
-                for (i = 0; i < AZX_MAX_PCMS; i++)
+                for (i = 0; i < HDA_MAX_PCMS; i++)
                         snd_pcm_suspend_all(chip->pcm[i]);
                 snd_hda_suspend(chip->bus);
                 snd_hda_resume(chip->bus);
@@ -1339,6 +1368,7 @@ static void azx_bus_reset(struct hda_bus *bus)
 
 /* number of codec slots for each chipset: 0 = default slots (i.e. 4) */
 static unsigned int azx_max_codecs[AZX_NUM_DRIVERS] __devinitdata = {
+        [AZX_DRIVER_NVIDIA] = 8,
         [AZX_DRIVER_TERA] = 1,
 };
 
@@ -1371,7 +1401,7 @@ static int __devinit azx_codec_create(struct azx *chip, const char *model)
         codecs = 0;
         max_slots = azx_max_codecs[chip->driver_type];
         if (!max_slots)
-                max_slots = AZX_MAX_CODECS;
+                max_slots = AZX_DEFAULT_CODECS;
 
         /* First try to probe all given codec slots */
         for (c = 0; c < max_slots; c++) {
@@ -1386,7 +1416,7 @@ static int __devinit azx_codec_create(struct azx *chip, const char *model)
                                 chip->codec_mask &= ~(1 << c);
                                 /* More badly, accessing to a non-existing
                                  * codec often screws up the controller chip,
-                                 * and distrubs the further communications.
+                                 * and disturbs the further communications.
                                  * Thus if an error occurs during probing,
                                  * better to reset the controller chip to
                                  * get back to the sanity state.
@@ -1404,6 +1434,7 @@ static int __devinit azx_codec_create(struct azx *chip, const char *model)
                         err = snd_hda_codec_new(chip->bus, c, &codec);
                         if (err < 0)
                                 continue;
+                        codec->beep_mode = chip->beep_mode;
                         codecs++;
                 }
         }
@@ -1430,10 +1461,13 @@ static int __devinit azx_codec_configure(struct azx *chip)
  */
 
 /* assign a stream for the PCM */
-static inline struct azx_dev *azx_assign_device(struct azx *chip, int stream)
+static inline struct azx_dev *
+azx_assign_device(struct azx *chip, struct snd_pcm_substream *substream)
 {
         int dev, i, nums;
-        if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
+        struct azx_dev *res = NULL;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                 dev = chip->playback_index_offset;
                 nums = chip->playback_streams;
         } else {
@@ -1442,10 +1476,15 @@ static inline struct azx_dev *azx_assign_device(struct azx *chip, int stream)
         }
         for (i = 0; i < nums; i++, dev++)
                 if (!chip->azx_dev[dev].opened) {
-                        chip->azx_dev[dev].opened = 1;
-                        return &chip->azx_dev[dev];
+                        res = &chip->azx_dev[dev];
+                        if (res->device == substream->pcm->device)
+                                break;
                 }
-        return NULL;
+        if (res) {
+                res->opened = 1;
+                res->device = substream->pcm->device;
+        }
+        return res;
 }
 
 /* release the assigned stream */
@@ -1494,7 +1533,7 @@ static int azx_pcm_open(struct snd_pcm_substream *substream)
         int err;
 
         mutex_lock(&chip->open_mutex);
-        azx_dev = azx_assign_device(chip, substream->stream);
+        azx_dev = azx_assign_device(chip, substream);
         if (azx_dev == NULL) {
                 mutex_unlock(&chip->open_mutex);
                 return -EBUSY;
@@ -1858,6 +1897,9 @@ static int azx_position_ok(struct azx *chip, struct azx_dev *azx_dev)
 
         if (!bdl_pos_adj[chip->dev_index])
                 return 1; /* no delayed ack */
+        if (WARN_ONCE(!azx_dev->period_bytes,
+                      "hda-intel: zero azx_dev->period_bytes"))
+                return 0; /* this shouldn't happen! */
         if (pos % azx_dev->period_bytes > azx_dev->period_bytes / 2)
                 return 0; /* NG - it's below the period boundary */
         return 1; /* OK, it's fine */
@@ -1945,7 +1987,7 @@ azx_attach_pcm_stream(struct hda_bus *bus, struct hda_codec *codec,
         int pcm_dev = cpcm->device;
         int s, err;
 
-        if (pcm_dev >= AZX_MAX_PCMS) {
+        if (pcm_dev >= HDA_MAX_PCMS) {
                 snd_printk(KERN_ERR SFX "Invalid PCM device number %d\n",
                            pcm_dev);
                 return -EINVAL;
@@ -2023,7 +2065,7 @@ static int azx_acquire_irq(struct azx *chip, int do_disconnect)
 {
         if (request_irq(chip->pci->irq, azx_interrupt,
                         chip->msi ? 0 : IRQF_SHARED,
-                        "HDA Intel", chip)) {
+                        "hda_intel", chip)) {
                 printk(KERN_ERR "hda-intel: unable to grab IRQ %d, "
                        "disabling device\n", chip->pci->irq);
                 if (do_disconnect)
@@ -2071,7 +2113,8 @@ static void azx_power_notify(struct hda_bus *bus)
         }
         if (power_on)
                 azx_init_chip(chip);
-        else if (chip->running && power_save_controller)
+        else if (chip->running && power_save_controller &&
+                 !bus->power_keep_link_on)
                 azx_stop_chip(chip);
 }
 #endif /* CONFIG_SND_HDA_POWER_SAVE */
@@ -2100,7 +2143,7 @@ static int azx_suspend(struct pci_dev *pci, pm_message_t state)
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
         azx_clear_irq_pending(chip);
-        for (i = 0; i < AZX_MAX_PCMS; i++)
+        for (i = 0; i < HDA_MAX_PCMS; i++)
                 snd_pcm_suspend_all(chip->pcm[i]);
         if (chip->initialized)
                 snd_hda_suspend(chip->bus);
@@ -2154,6 +2197,7 @@ static int azx_resume(struct pci_dev *pci)
 static int azx_halt(struct notifier_block *nb, unsigned long event, void *buf)
 {
         struct azx *chip = container_of(nb, struct azx, reboot_notifier);
+        snd_hda_bus_reboot_notify(chip->bus);
         azx_stop_chip(chip);
         return NOTIFY_OK;
 }
@@ -2221,7 +2265,16 @@ static int azx_dev_free(struct snd_device *device)
 static struct snd_pci_quirk position_fix_list[] __devinitdata = {
         SND_PCI_QUIRK(0x1028, 0x01cc, "Dell D820", POS_FIX_LPIB),
         SND_PCI_QUIRK(0x1028, 0x01de, "Dell Precision 390", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1028, 0x01f6, "Dell Latitude 131L", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x103c, 0x306d, "HP dv3", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1106, 0x3288, "ASUS M2V-MX SE", POS_FIX_LPIB),
         SND_PCI_QUIRK(0x1043, 0x813d, "ASUS P5AD2", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1458, 0xa022, "ga-ma770-ud3", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1462, 0x1002, "MSI Wind U115", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1565, 0x820f, "Biostar Microtech", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1565, 0x8218, "Biostar Microtech", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x8086, 0x2503, "DG965OT AAD63733-203", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x8086, 0xd601, "eMachines T5212", POS_FIX_LPIB),
         {}
 };
 
@@ -2304,11 +2357,14 @@ static void __devinit check_probe_mask(struct azx *chip, int dev)
 }
 
 /*
- * white-list for enable_msi
+ * white/black-list for enable_msi
  */
-static struct snd_pci_quirk msi_white_list[] __devinitdata = {
-        SND_PCI_QUIRK(0x103c, 0x30f7, "HP Pavilion dv4t-1300", 1),
-        SND_PCI_QUIRK(0x103c, 0x3607, "HP Compa CQ40", 1),
+static struct snd_pci_quirk msi_black_list[] __devinitdata = {
+        SND_PCI_QUIRK(0x1043, 0x81f2, "ASUS", 0), /* Athlon64 X2 + nvidia */
+        SND_PCI_QUIRK(0x1043, 0x81f6, "ASUS", 0), /* nvidia */
+        SND_PCI_QUIRK(0x1043, 0x822d, "ASUS", 0), /* Athlon64 X2 + nvidia MCP55 */
+        SND_PCI_QUIRK(0x1849, 0x0888, "ASRock", 0), /* Athlon64 X2 + nvidia */
+        SND_PCI_QUIRK(0xa0a0, 0x0575, "Aopen MZ915-M", 0), /* ICH6 */
         {}
 };
 
@@ -2316,15 +2372,24 @@ static void __devinit check_msi(struct azx *chip)
 {
         const struct snd_pci_quirk *q;
 
-        chip->msi = enable_msi;
-        if (chip->msi)
+        if (enable_msi >= 0) {
+                chip->msi = !!enable_msi;
                 return;
-        q = snd_pci_quirk_lookup(chip->pci, msi_white_list);
+        }
+        chip->msi = 1;  /* enable MSI as default */
+        q = snd_pci_quirk_lookup(chip->pci, msi_black_list);
         if (q) {
                 printk(KERN_INFO
                        "hda_intel: msi for device %04x:%04x set to %d\n",
                        q->subvendor, q->subdevice, q->value);
                 chip->msi = q->value;
+                return;
+        }
+
+        /* NVidia chipsets seem to cause troubles with MSI */
+        if (chip->driver_type == AZX_DRIVER_NVIDIA) {
+                printk(KERN_INFO "hda_intel: Disable MSI for Nvidia chipset\n");
+                chip->msi = 0;
         }
 }
 
@@ -2374,6 +2439,7 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
         if (bdl_pos_adj[dev] < 0) {
                 switch (chip->driver_type) {
                 case AZX_DRIVER_ICH:
+                case AZX_DRIVER_PCH:
                         bdl_pos_adj[dev] = 1;
                         break;
                 default:
@@ -2436,6 +2502,11 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
                 }
         }
 
+        /* disable 64bit DMA address for Teradici */
+        /* it does not work with device 6549:1200 subsys e4a2:040b */
+        if (chip->driver_type == AZX_DRIVER_TERA)
+                gcap &= ~ICH6_GCAP_64OK;
+
         /* allow 64bit DMA address if supported by H/W */
         if ((gcap & ICH6_GCAP_64OK) && !pci_set_dma_mask(pci, DMA_BIT_MASK(64)))
                 pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(64));
@@ -2578,6 +2649,10 @@ static int __devinit azx_probe(struct pci_dev *pci,
                 goto out_free;
         card->private_data = chip;
 
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+        chip->beep_mode = beep_mode[dev];
+#endif
+
         /* create codec instances */
         err = azx_codec_create(chip, model[dev]);
         if (err < 0)
@@ -2630,7 +2705,7 @@ static void __devexit azx_remove(struct pci_dev *pci)
 }
 
 /* PCI IDs */
-static struct pci_device_id azx_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(azx_ids) = {
         /* ICH 6..10 */
         { PCI_DEVICE(0x8086, 0x2668), .driver_data = AZX_DRIVER_ICH },
         { PCI_DEVICE(0x8086, 0x27d8), .driver_data = AZX_DRIVER_ICH },
@@ -2643,6 +2718,9 @@ static struct pci_device_id azx_ids[] = {
         { PCI_DEVICE(0x8086, 0x3a6e), .driver_data = AZX_DRIVER_ICH },
         /* PCH */
         { PCI_DEVICE(0x8086, 0x3b56), .driver_data = AZX_DRIVER_ICH },
+        { PCI_DEVICE(0x8086, 0x3b57), .driver_data = AZX_DRIVER_ICH },
+        /* CPT */
+        { PCI_DEVICE(0x8086, 0x1c20), .driver_data = AZX_DRIVER_PCH },
         /* SCH */
         { PCI_DEVICE(0x8086, 0x811b), .driver_data = AZX_DRIVER_SCH },
         /* ATI SB 450/600 */
@@ -2670,29 +2748,10 @@ static struct pci_device_id azx_ids[] = {
         /* ULI M5461 */
         { PCI_DEVICE(0x10b9, 0x5461), .driver_data = AZX_DRIVER_ULI },
         /* NVIDIA MCP */
-        { PCI_DEVICE(0x10de, 0x026c), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0371), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x03e4), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x03f0), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x044a), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x044b), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x055c), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x055d), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0590), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0774), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0775), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0776), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0777), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x07fc), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x07fd), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0ac0), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0ac1), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0ac2), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0ac3), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0d94), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0d95), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0d96), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0d97), .driver_data = AZX_DRIVER_NVIDIA },
+        { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID),
+          .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
+          .class_mask = 0xffffff,
+          .driver_data = AZX_DRIVER_NVIDIA },
         /* Teradici */
         { PCI_DEVICE(0x6549, 0x1200), .driver_data = AZX_DRIVER_TERA },
         /* Creative X-Fi (CA0110-IBG) */