Merge tag 'hda-switcheroo' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound

Pull VGA-switcheroo audio client support for HD-audio from Takashi Iwai.

This depended on the recent drm pull.

* tag 'hda-switcheroo' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound:
  ALSA: hda - unlock on error in azx_interrupt()
  ALSA: hda - Support VGA-switcheroo
  ALSA: hda - Export snd_hda_lock_devices()
  ALSA: hda - Check the dead HDMI audio controller by vga-switcheroo

3 files changed, 316 insertions, 67 deletions

diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index eb09a3348325..41ca803a1fff 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -2239,24 +2239,50 @@ void snd_hda_ctls_clear(struct hda_codec *codec)
 /* pseudo device locking
  * toggle card->shutdown to allow/disallow the device access (as a hack)
  */
-static int hda_lock_devices(struct snd_card *card)
+int snd_hda_lock_devices(struct hda_bus *bus)
 {
+        struct snd_card *card = bus->card;
+        struct hda_codec *codec;
+
         spin_lock(&card->files_lock);
-        if (card->shutdown) {
-                spin_unlock(&card->files_lock);
-                return -EINVAL;
-        }
+        if (card->shutdown)
+                goto err_unlock;
         card->shutdown = 1;
+        if (!list_empty(&card->ctl_files))
+                goto err_clear;
+
+        list_for_each_entry(codec, &bus->codec_list, list) {
+                int pcm;
+                for (pcm = 0; pcm < codec->num_pcms; pcm++) {
+                        struct hda_pcm *cpcm = &codec->pcm_info[pcm];
+                        if (!cpcm->pcm)
+                                continue;
+                        if (cpcm->pcm->streams[0].substream_opened ||
+                            cpcm->pcm->streams[1].substream_opened)
+                                goto err_clear;
+                }
+        }
         spin_unlock(&card->files_lock);
         return 0;
+
+ err_clear:
+        card->shutdown = 0;
+ err_unlock:
+        spin_unlock(&card->files_lock);
+        return -EINVAL;
 }
+EXPORT_SYMBOL_HDA(snd_hda_lock_devices);
 
-static void hda_unlock_devices(struct snd_card *card)
+void snd_hda_unlock_devices(struct hda_bus *bus)
 {
+        struct snd_card *card = bus->card;
+
+        card = bus->card;
         spin_lock(&card->files_lock);
         card->shutdown = 0;
         spin_unlock(&card->files_lock);
 }
+EXPORT_SYMBOL_HDA(snd_hda_unlock_devices);
 
 /**
  * snd_hda_codec_reset - Clear all objects assigned to the codec
@@ -2270,26 +2296,12 @@ static void hda_unlock_devices(struct snd_card *card)
  */
 int snd_hda_codec_reset(struct hda_codec *codec)
 {
-        struct snd_card *card = codec->bus->card;
-        int i, pcm;
+        struct hda_bus *bus = codec->bus;
+        struct snd_card *card = bus->card;
+        int i;
 
-        if (hda_lock_devices(card) < 0)
-                return -EBUSY;
-        /* check whether the codec isn't used by any mixer or PCM streams */
-        if (!list_empty(&card->ctl_files)) {
-                hda_unlock_devices(card);
+        if (snd_hda_lock_devices(bus) < 0)
                 return -EBUSY;
-        }
-        for (pcm = 0; pcm < codec->num_pcms; pcm++) {
-                struct hda_pcm *cpcm = &codec->pcm_info[pcm];
-                if (!cpcm->pcm)
-                        continue;
-                if (cpcm->pcm->streams[0].substream_opened ||
-                    cpcm->pcm->streams[1].substream_opened) {
-                        hda_unlock_devices(card);
-                        return -EBUSY;
-                }
-        }
 
         /* OK, let it free */
 
@@ -2298,7 +2310,7 @@ int snd_hda_codec_reset(struct hda_codec *codec)
         codec->power_on = 0;
         codec->power_transition = 0;
         codec->power_jiffies = jiffies;
-        flush_workqueue(codec->bus->workq);
+        flush_workqueue(bus->workq);
 #endif
         snd_hda_ctls_clear(codec);
         /* relase PCMs */
@@ -2306,7 +2318,7 @@ int snd_hda_codec_reset(struct hda_codec *codec)
                 if (codec->pcm_info[i].pcm) {
                         snd_device_free(card, codec->pcm_info[i].pcm);
                         clear_bit(codec->pcm_info[i].device,
-                                  codec->bus->pcm_dev_bits);
+                                  bus->pcm_dev_bits);
                 }
         }
         if (codec->patch_ops.free)
@@ -2331,7 +2343,7 @@ int snd_hda_codec_reset(struct hda_codec *codec)
         codec->owner = NULL;
 
         /* allow device access again */
-        hda_unlock_devices(card);
+        snd_hda_unlock_devices(bus);
         return 0;
 }
 
diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h
index 54b52819fb47..4fc3960c8591 100644
--- a/sound/pci/hda/hda_codec.h
+++ b/sound/pci/hda/hda_codec.h
@@ -1023,6 +1023,9 @@ void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
                                     unsigned int power_state,
                                     bool eapd_workaround);
 
+int snd_hda_lock_devices(struct hda_bus *bus);
+void snd_hda_unlock_devices(struct hda_bus *bus);
+
 /*
  * power management
  */
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index 4ab8102f87ea..2b6392be451c 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -53,6 +53,8 @@
 #endif
 #include <sound/core.h>
 #include <sound/initval.h>
+#include <linux/vgaarb.h>
+#include <linux/vga_switcheroo.h>
 #include "hda_codec.h"
 
 
@@ -175,6 +177,13 @@ MODULE_DESCRIPTION("Intel HDA driver");
 #define SFX     "hda-intel: "
 #endif
 
+#if defined(CONFIG_PM) && defined(CONFIG_VGA_SWITCHEROO)
+#ifdef CONFIG_SND_HDA_CODEC_HDMI
+#define SUPPORT_VGA_SWITCHEROO
+#endif
+#endif
+
+
 /*
  * registers
  */
@@ -472,6 +481,12 @@ struct azx {
         unsigned int probing :1; /* codec probing phase */
         unsigned int snoop:1;
         unsigned int align_buffer_size:1;
+        unsigned int region_requested:1;
+
+        /* VGA-switcheroo setup */
+        unsigned int use_vga_switcheroo:1;
+        unsigned int init_failed:1; /* delayed init failed */
+        unsigned int disabled:1; /* disabled by VGA-switcher */
 
         /* for debugging */
         unsigned int last_cmd[AZX_MAX_CODECS];
@@ -538,7 +553,20 @@ enum {
 #define AZX_DCAPS_PRESET_CTHDA \
         (AZX_DCAPS_NO_MSI | AZX_DCAPS_POSFIX_LPIB | AZX_DCAPS_4K_BDLE_BOUNDARY)
 
-static char *driver_short_names[] __devinitdata = {
+/*
+ * VGA-switcher support
+ */
+#ifdef SUPPORT_VGA_SWITCHEROO
+#define DELAYED_INIT_MARK
+#define DELAYED_INITDATA_MARK
+#define use_vga_switcheroo(chip)        ((chip)->use_vga_switcheroo)
+#else
+#define DELAYED_INIT_MARK       __devinit
+#define DELAYED_INITDATA_MARK   __devinitdata
+#define use_vga_switcheroo(chip)        0
+#endif
+
+static char *driver_short_names[] DELAYED_INITDATA_MARK = {
         [AZX_DRIVER_ICH] = "HDA Intel",
         [AZX_DRIVER_PCH] = "HDA Intel PCH",
         [AZX_DRIVER_SCH] = "HDA Intel MID",
@@ -959,6 +987,8 @@ static int azx_send_cmd(struct hda_bus *bus, unsigned int val)
 {
         struct azx *chip = bus->private_data;
 
+        if (chip->disabled)
+                return 0;
         chip->last_cmd[azx_command_addr(val)] = val;
         if (chip->single_cmd)
                 return azx_single_send_cmd(bus, val);
@@ -971,6 +1001,8 @@ static unsigned int azx_get_response(struct hda_bus *bus,
                                      unsigned int addr)
 {
         struct azx *chip = bus->private_data;
+        if (chip->disabled)
+                return 0;
         if (chip->single_cmd)
                 return azx_single_get_response(bus, addr);
         else
@@ -1236,6 +1268,11 @@ static irqreturn_t azx_interrupt(int irq, void *dev_id)
 
         spin_lock(&chip->reg_lock);
 
+        if (chip->disabled) {
+                spin_unlock(&chip->reg_lock);
+                return IRQ_NONE;
+        }
+
         status = azx_readl(chip, INTSTS);
         if (status == 0) {
                 spin_unlock(&chip->reg_lock);
@@ -1521,12 +1558,12 @@ 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 = {
+static unsigned int azx_max_codecs[AZX_NUM_DRIVERS] DELAYED_INITDATA_MARK = {
         [AZX_DRIVER_NVIDIA] = 8,
         [AZX_DRIVER_TERA] = 1,
 };
 
-static int __devinit azx_codec_create(struct azx *chip, const char *model)
+static int DELAYED_INIT_MARK azx_codec_create(struct azx *chip, const char *model)
 {
         struct hda_bus_template bus_temp;
         int c, codecs, err;
@@ -2444,6 +2481,105 @@ static void azx_notifier_unregister(struct azx *chip)
                 unregister_reboot_notifier(&chip->reboot_notifier);
 }
 
+static int DELAYED_INIT_MARK azx_first_init(struct azx *chip);
+static int DELAYED_INIT_MARK azx_probe_continue(struct azx *chip);
+
+static struct pci_dev __devinit *get_bound_vga(struct pci_dev *pci);
+
+#ifdef SUPPORT_VGA_SWITCHEROO
+static void azx_vs_set_state(struct pci_dev *pci,
+                             enum vga_switcheroo_state state)
+{
+        struct snd_card *card = pci_get_drvdata(pci);
+        struct azx *chip = card->private_data;
+        bool disabled;
+
+        if (chip->init_failed)
+                return;
+
+        disabled = (state == VGA_SWITCHEROO_OFF);
+        if (chip->disabled == disabled)
+                return;
+
+        if (!chip->bus) {
+                chip->disabled = disabled;
+                if (!disabled) {
+                        snd_printk(KERN_INFO SFX
+                                   "%s: Start delayed initialization\n",
+                                   pci_name(chip->pci));
+                        if (azx_first_init(chip) < 0 ||
+                            azx_probe_continue(chip) < 0) {
+                                snd_printk(KERN_ERR SFX
+                                           "%s: initialization error\n",
+                                           pci_name(chip->pci));
+                                chip->init_failed = true;
+                        }
+                }
+        } else {
+                snd_printk(KERN_INFO SFX
+                           "%s %s via VGA-switcheroo\n",
+                           disabled ? "Disabling" : "Enabling",
+                           pci_name(chip->pci));
+                if (disabled) {
+                        azx_suspend(pci, PMSG_FREEZE);
+                        chip->disabled = true;
+                        snd_hda_lock_devices(chip->bus);
+                } else {
+                        snd_hda_unlock_devices(chip->bus);
+                        chip->disabled = false;
+                        azx_resume(pci);
+                }
+        }
+}
+
+static bool azx_vs_can_switch(struct pci_dev *pci)
+{
+        struct snd_card *card = pci_get_drvdata(pci);
+        struct azx *chip = card->private_data;
+
+        if (chip->init_failed)
+                return false;
+        if (chip->disabled || !chip->bus)
+                return true;
+        if (snd_hda_lock_devices(chip->bus))
+                return false;
+        snd_hda_unlock_devices(chip->bus);
+        return true;
+}
+
+static void __devinit init_vga_switcheroo(struct azx *chip)
+{
+        struct pci_dev *p = get_bound_vga(chip->pci);
+        if (p) {
+                snd_printk(KERN_INFO SFX
+                           "%s: Handle VGA-switcheroo audio client\n",
+                           pci_name(chip->pci));
+                chip->use_vga_switcheroo = 1;
+                pci_dev_put(p);
+        }
+}
+
+static const struct vga_switcheroo_client_ops azx_vs_ops = {
+        .set_gpu_state = azx_vs_set_state,
+        .can_switch = azx_vs_can_switch,
+};
+
+static int __devinit register_vga_switcheroo(struct azx *chip)
+{
+        if (!chip->use_vga_switcheroo)
+                return 0;
+        /* FIXME: currently only handling DIS controller
+         * is there any machine with two switchable HDMI audio controllers?
+         */
+        return vga_switcheroo_register_audio_client(chip->pci, &azx_vs_ops,
+                                                    VGA_SWITCHEROO_DIS,
+                                                    chip->bus != NULL);
+}
+#else
+#define init_vga_switcheroo(chip)               /* NOP */
+#define register_vga_switcheroo(chip)           0
+#endif /* SUPPORT_VGA_SWITCHER */
+
 /*
  * destructor
  */
@@ -2453,6 +2589,12 @@ static int azx_free(struct azx *chip)
 
         azx_notifier_unregister(chip);
 
+        if (use_vga_switcheroo(chip)) {
+                if (chip->disabled && chip->bus)
+                        snd_hda_unlock_devices(chip->bus);
+                vga_switcheroo_unregister_client(chip->pci);
+        }
+
         if (chip->initialized) {
                 azx_clear_irq_pending(chip);
                 for (i = 0; i < chip->num_streams; i++)
@@ -2482,7 +2624,8 @@ static int azx_free(struct azx *chip)
                 mark_pages_wc(chip, &chip->posbuf, false);
                 snd_dma_free_pages(&chip->posbuf);
         }
-        pci_release_regions(chip->pci);
+        if (chip->region_requested)
+                pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
         kfree(chip->azx_dev);
         kfree(chip);
@@ -2496,6 +2639,45 @@ static int azx_dev_free(struct snd_device *device)
 }
 
 /*
+ * Check of disabled HDMI controller by vga-switcheroo
+ */
+static struct pci_dev __devinit *get_bound_vga(struct pci_dev *pci)
+{
+        struct pci_dev *p;
+
+        /* check only discrete GPU */
+        switch (pci->vendor) {
+        case PCI_VENDOR_ID_ATI:
+        case PCI_VENDOR_ID_AMD:
+        case PCI_VENDOR_ID_NVIDIA:
+                if (pci->devfn == 1) {
+                        p = pci_get_domain_bus_and_slot(pci_domain_nr(pci->bus),
+                                                        pci->bus->number, 0);
+                        if (p) {
+                                if ((p->class >> 8) == PCI_CLASS_DISPLAY_VGA)
+                                        return p;
+                                pci_dev_put(p);
+                        }
+                }
+                break;
+        }
+        return NULL;
+}
+
+static bool __devinit check_hdmi_disabled(struct pci_dev *pci)
+{
+        bool vga_inactive = false;
+        struct pci_dev *p = get_bound_vga(pci);
+
+        if (p) {
+                if (vga_default_device() && p != vga_default_device())
+                        vga_inactive = true;
+                pci_dev_put(p);
+        }
+        return vga_inactive;
+}
+
+/*
  * white/black-listing for position_fix
  */
 static struct snd_pci_quirk position_fix_list[] __devinitdata = {
@@ -2672,12 +2854,11 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
                                 int dev, unsigned int driver_caps,
                                 struct azx **rchip)
 {
-        struct azx *chip;
-        int i, err;
-        unsigned short gcap;
         static struct snd_device_ops ops = {
                 .dev_free = azx_dev_free,
         };
+        struct azx *chip;
+        int err;
 
         *rchip = NULL;
 
@@ -2703,6 +2884,7 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
         chip->dev_index = dev;
         INIT_WORK(&chip->irq_pending_work, azx_irq_pending_work);
         INIT_LIST_HEAD(&chip->pcm_list);
+        init_vga_switcheroo(chip);
 
         chip->position_fix[0] = chip->position_fix[1] =
                 check_position_fix(chip, position_fix[dev]);
@@ -2730,6 +2912,53 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
                 }
         }
 
+        if (check_hdmi_disabled(pci)) {
+                snd_printk(KERN_INFO SFX "VGA controller for %s is disabled\n",
+                           pci_name(pci));
+                if (use_vga_switcheroo(chip)) {
+                        snd_printk(KERN_INFO SFX "Delaying initialization\n");
+                        chip->disabled = true;
+                        goto ok;
+                }
+                kfree(chip);
+                pci_disable_device(pci);
+                return -ENXIO;
+        }
+
+        err = azx_first_init(chip);
+        if (err < 0) {
+                azx_free(chip);
+                return err;
+        }
+
+ ok:
+        err = register_vga_switcheroo(chip);
+        if (err < 0) {
+                snd_printk(KERN_ERR SFX
+                           "Error registering VGA-switcheroo client\n");
+                azx_free(chip);
+                return err;
+        }
+
+        err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
+        if (err < 0) {
+                snd_printk(KERN_ERR SFX "Error creating device [card]!\n");
+                azx_free(chip);
+                return err;
+        }
+
+        *rchip = chip;
+        return 0;
+}
+
+static int DELAYED_INIT_MARK azx_first_init(struct azx *chip)
+{
+        int dev = chip->dev_index;
+        struct pci_dev *pci = chip->pci;
+        struct snd_card *card = chip->card;
+        int i, err;
+        unsigned short gcap;
+
 #if BITS_PER_LONG != 64
         /* Fix up base address on ULI M5461 */
         if (chip->driver_type == AZX_DRIVER_ULI) {
@@ -2741,28 +2970,23 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
 #endif
 
         err = pci_request_regions(pci, "ICH HD audio");
-        if (err < 0) {
-                kfree(chip);
-                pci_disable_device(pci);
+        if (err < 0)
                 return err;
-        }
+        chip->region_requested = 1;
 
         chip->addr = pci_resource_start(pci, 0);
         chip->remap_addr = pci_ioremap_bar(pci, 0);
         if (chip->remap_addr == NULL) {
                 snd_printk(KERN_ERR SFX "ioremap error\n");
-                err = -ENXIO;
-                goto errout;
+                return -ENXIO;
         }
 
         if (chip->msi)
                 if (pci_enable_msi(pci) < 0)
                         chip->msi = 0;
 
-        if (azx_acquire_irq(chip, 0) < 0) {
-                err = -EBUSY;
-                goto errout;
-        }
+        if (azx_acquire_irq(chip, 0) < 0)
+                return -EBUSY;
 
         pci_set_master(pci);
         synchronize_irq(chip->irq);
@@ -2841,7 +3065,7 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
                                 GFP_KERNEL);
         if (!chip->azx_dev) {
                 snd_printk(KERN_ERR SFX "cannot malloc azx_dev\n");
-                goto errout;
+                return -ENOMEM;
         }
 
         for (i = 0; i < chip->num_streams; i++) {
@@ -2851,7 +3075,7 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
                                           BDL_SIZE, &chip->azx_dev[i].bdl);
                 if (err < 0) {
                         snd_printk(KERN_ERR SFX "cannot allocate BDL\n");
-                        goto errout;
+                        return -ENOMEM;
                 }
                 mark_pages_wc(chip, &chip->azx_dev[i].bdl, true);
         }
@@ -2861,13 +3085,13 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
                                   chip->num_streams * 8, &chip->posbuf);
         if (err < 0) {
                 snd_printk(KERN_ERR SFX "cannot allocate posbuf\n");
-                goto errout;
+                return -ENOMEM;
         }
         mark_pages_wc(chip, &chip->posbuf, true);
         /* allocate CORB/RIRB */
         err = azx_alloc_cmd_io(chip);
         if (err < 0)
-                goto errout;
+                return err;
 
         /* initialize streams */
         azx_init_stream(chip);
@@ -2879,14 +3103,7 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
         /* codec detection */
         if (!chip->codec_mask) {
                 snd_printk(KERN_ERR SFX "no codecs found!\n");
-                err = -ENODEV;
-                goto errout;
-        }
-
-        err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
-        if (err <0) {
-                snd_printk(KERN_ERR SFX "Error creating device [card]!\n");
-                goto errout;
+                return -ENODEV;
         }
 
         strcpy(card->driver, "HDA-Intel");
@@ -2896,12 +3113,7 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
                  "%s at 0x%lx irq %i",
                  card->shortname, chip->addr, chip->irq);
 
-        *rchip = chip;
         return 0;
-
- errout:
-        azx_free(chip);
-        return err;
 }
 
 static void power_down_all_codecs(struct azx *chip)
@@ -2946,6 +3158,27 @@ static int __devinit azx_probe(struct pci_dev *pci,
                 goto out_free;
         card->private_data = chip;
 
+        if (!chip->disabled) {
+                err = azx_probe_continue(chip);
+                if (err < 0)
+                        goto out_free;
+        }
+
+        pci_set_drvdata(pci, card);
+
+        dev++;
+        return 0;
+
+out_free:
+        snd_card_free(card);
+        return err;
+}
+
+static int DELAYED_INIT_MARK azx_probe_continue(struct azx *chip)
+{
+        int dev = chip->dev_index;
+        int err;
+
 #ifdef CONFIG_SND_HDA_INPUT_BEEP
         chip->beep_mode = beep_mode[dev];
 #endif
@@ -2979,25 +3212,26 @@ static int __devinit azx_probe(struct pci_dev *pci,
         if (err < 0)
                 goto out_free;
 
-        err = snd_card_register(card);
+        err = snd_card_register(chip->card);
         if (err < 0)
                 goto out_free;
 
-        pci_set_drvdata(pci, card);
         chip->running = 1;
         power_down_all_codecs(chip);
         azx_notifier_register(chip);
 
-        dev++;
-        return err;
+        return 0;
+
 out_free:
-        snd_card_free(card);
+        chip->init_failed = 1;
         return err;
 }
 
 static void __devexit azx_remove(struct pci_dev *pci)
 {
-        snd_card_free(pci_get_drvdata(pci));
+        struct snd_card *card = pci_get_drvdata(pci);
+        if (card)
+                snd_card_free(card);
         pci_set_drvdata(pci, NULL);
 }