1 files changed, 88 insertions, 28 deletions

diff --git a/sound/pci/cmipci.c b/sound/pci/cmipci.c
index 1fa5f004e858..135f30860753 100644
--- a/sound/pci/cmipci.c
+++ b/sound/pci/cmipci.c
@@ -20,7 +20,6 @@
 /* Does not work. Warning may block system in capture mode */
 /* #define USE_VAR48KRATE */
 
-#include <sound/driver.h>
 #include <asm/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
@@ -150,6 +149,8 @@ MODULE_PARM_DESC(joystick_port, "Joystick port address.");
 #define CM_CH0_SRATE_176K       0x00000200
 #define CM_CH0_SRATE_96K        0x00000200      /* model 055? */
 #define CM_CH0_SRATE_88K        0x00000100
+#define CM_CH0_SRATE_128K       0x00000300
+#define CM_CH0_SRATE_MASK       0x00000300
 
 #define CM_SPDIF_INVERSE2       0x00000080      /* model 055? */
 #define CM_DBLSPDS              0x00000040      /* double SPDIF sample rate 88.2/96 */
@@ -473,6 +474,7 @@ struct cmipci {
         unsigned int can_ac3_sw: 1;
         unsigned int can_ac3_hw: 1;
         unsigned int can_multi_ch: 1;
+        unsigned int can_96k: 1;        /* samplerate above 48k */
         unsigned int do_soft_ac3: 1;
 
         unsigned int spdif_playback_avail: 1;   /* spdif ready? */
@@ -603,8 +605,6 @@ static unsigned int snd_cmipci_rate_freq(unsigned int rate)
 {
         unsigned int i;
 
-        if (rate > 48000)
-                rate /= 2;
         for (i = 0; i < ARRAY_SIZE(rates); i++) {
                 if (rates[i] == rate)
                         return i;
@@ -782,7 +782,7 @@ static int set_dac_channels(struct cmipci *cm, struct cmipci_pcm *rec, int chann
 static int snd_cmipci_pcm_prepare(struct cmipci *cm, struct cmipci_pcm *rec,
                                  struct snd_pcm_substream *substream)
 {
-        unsigned int reg, freq, val;
+        unsigned int reg, freq, freq_ext, val;
         unsigned int period_size;
         struct snd_pcm_runtime *runtime = substream->runtime;
 
@@ -830,7 +830,17 @@ static int snd_cmipci_pcm_prepare(struct cmipci *cm, struct cmipci_pcm *rec,
         //snd_printd("cmipci: functrl0 = %08x\n", cm->ctrl);
 
         /* set sample rate */
-        freq = snd_cmipci_rate_freq(runtime->rate);
+        freq = 0;
+        freq_ext = 0;
+        if (runtime->rate > 48000)
+                switch (runtime->rate) {
+                case 88200:  freq_ext = CM_CH0_SRATE_88K; break;
+                case 96000:  freq_ext = CM_CH0_SRATE_96K; break;
+                case 128000: freq_ext = CM_CH0_SRATE_128K; break;
+                default:     snd_BUG(); break;
+                }
+        else
+                freq = snd_cmipci_rate_freq(runtime->rate);
         val = snd_cmipci_read(cm, CM_REG_FUNCTRL1);
         if (rec->ch) {
                 val &= ~CM_DSFC_MASK;
@@ -851,19 +861,20 @@ static int snd_cmipci_pcm_prepare(struct cmipci *cm, struct cmipci_pcm *rec,
                 val &= ~CM_CH0FMT_MASK;
                 val |= rec->fmt << CM_CH0FMT_SHIFT;
         }
-        if (cm->chip_version == 68) {
-                if (runtime->rate == 88200)
-                        val |= CM_CH0_SRATE_88K << (rec->ch * 2);
-                else
-                        val &= ~(CM_CH0_SRATE_88K << (rec->ch * 2));
-                if (runtime->rate == 96000)
-                        val |= CM_CH0_SRATE_96K << (rec->ch * 2);
-                else
-                        val &= ~(CM_CH0_SRATE_96K << (rec->ch * 2));
+        if (cm->can_96k) {
+                val &= ~(CM_CH0_SRATE_MASK << (rec->ch * 2));
+                val |= freq_ext << (rec->ch * 2);
         }
         snd_cmipci_write(cm, CM_REG_CHFORMAT, val);
         //snd_printd("cmipci: chformat = %08x\n", val);
 
+        if (!rec->is_dac && cm->chip_version) {
+                if (runtime->rate > 44100)
+                        snd_cmipci_set_bit(cm, CM_REG_EXT_MISC, CM_ADC48K44K);
+                else
+                        snd_cmipci_clear_bit(cm, CM_REG_EXT_MISC, CM_ADC48K44K);
+        }
+
         rec->running = 0;
         spin_unlock_irq(&cm->reg_lock);
 
@@ -1280,7 +1291,7 @@ static int snd_cmipci_playback_prepare(struct snd_pcm_substream *substream)
         int rate = substream->runtime->rate;
         int err, do_spdif, do_ac3 = 0;
 
-        do_spdif = (rate >= 44100 &&
+        do_spdif = (rate >= 44100 && rate <= 96000 &&
                     substream->runtime->format == SNDRV_PCM_FORMAT_S16_LE &&
                     substream->runtime->channels == 2);
         if (do_spdif && cm->can_ac3_hw) 
@@ -1336,10 +1347,8 @@ static void snd_cmipci_silence_hack(struct cmipci *cm, struct cmipci_pcm *rec)
                 val = snd_cmipci_read(cm, CM_REG_CHFORMAT);
                 val &= ~(CM_CH0FMT_MASK << (rec->ch * 2));
                 val |= (3 << CM_CH0FMT_SHIFT) << (rec->ch * 2);
-                if (cm->chip_version == 68) {
-                        val &= ~(CM_CH0_SRATE_88K << (rec->ch * 2));
-                        val &= ~(CM_CH0_SRATE_96K << (rec->ch * 2));
-                }
+                if (cm->can_96k)
+                        val &= ~(CM_CH0_SRATE_MASK << (rec->ch * 2));
                 snd_cmipci_write(cm, CM_REG_CHFORMAT, val);
         
                 /* start stream (we don't need interrupts) */
@@ -1391,6 +1400,17 @@ static int snd_cmipci_capture_spdif_prepare(struct snd_pcm_substream *substream)
 
         spin_lock_irq(&cm->reg_lock);
         snd_cmipci_set_bit(cm, CM_REG_FUNCTRL1, CM_CAPTURE_SPDF);
+        if (cm->can_96k) {
+                if (substream->runtime->rate > 48000)
+                        snd_cmipci_set_bit(cm, CM_REG_CHFORMAT, CM_DBLSPDS);
+                else
+                        snd_cmipci_clear_bit(cm, CM_REG_CHFORMAT, CM_DBLSPDS);
+        }
+        if (snd_pcm_format_width(substream->runtime->format) > 16)
+                snd_cmipci_set_bit(cm, CM_REG_MISC_CTRL, CM_SPD32SEL);
+        else
+                snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_SPD32SEL);
+
         spin_unlock_irq(&cm->reg_lock);
 
         return snd_cmipci_pcm_prepare(cm, &cm->channel[CM_CH_CAPT], substream);
@@ -1402,6 +1422,7 @@ static int snd_cmipci_capture_spdif_hw_free(struct snd_pcm_substream *subs)
 
         spin_lock_irq(&cm->reg_lock);
         snd_cmipci_clear_bit(cm, CM_REG_FUNCTRL1, CM_CAPTURE_SPDF);
+        snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_SPD32SEL);
         spin_unlock_irq(&cm->reg_lock);
 
         return snd_cmipci_hw_free(subs);
@@ -1553,7 +1574,8 @@ static struct snd_pcm_hardware snd_cmipci_capture_spdif =
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                  SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_PAUSE |
                                  SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID),
-        .formats =              SNDRV_PCM_FMTBIT_S16_LE,
+        .formats =              SNDRV_PCM_FMTBIT_S16_LE |
+                                SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE,
         .rates =                SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
         .rate_min =             44100,
         .rate_max =             48000,
@@ -1567,6 +1589,14 @@ static struct snd_pcm_hardware snd_cmipci_capture_spdif =
         .fifo_size =            0,
 };
 
+static unsigned int rate_constraints[] = { 5512, 8000, 11025, 16000, 22050,
+                        32000, 44100, 48000, 88200, 96000, 128000 };
+static struct snd_pcm_hw_constraint_list hw_constraints_rates = {
+                .count = ARRAY_SIZE(rate_constraints),
+                .list = rate_constraints,
+                .mask = 0,
+};
+
 /*
  * check device open/close
  */
@@ -1636,6 +1666,13 @@ static int snd_cmipci_playback_open(struct snd_pcm_substream *substream)
                 runtime->hw.rates |= SNDRV_PCM_RATE_88200 |
                                      SNDRV_PCM_RATE_96000;
                 runtime->hw.rate_max = 96000;
+        } else if (cm->chip_version == 55) {
+                err = snd_pcm_hw_constraint_list(runtime, 0,
+                        SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates);
+                if (err < 0)
+                        return err;
+                runtime->hw.rates |= SNDRV_PCM_RATE_KNOT;
+                runtime->hw.rate_max = 128000;
         }
         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 0x10000);
         cm->dig_pcm_status = cm->dig_status;
@@ -1654,6 +1691,13 @@ static int snd_cmipci_capture_open(struct snd_pcm_substream *substream)
         if (cm->chip_version == 68) {   // 8768 only supports 44k/48k recording
                 runtime->hw.rate_min = 41000;
                 runtime->hw.rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000;
+        } else if (cm->chip_version == 55) {
+                err = snd_pcm_hw_constraint_list(runtime, 0,
+                        SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates);
+                if (err < 0)
+                        return err;
+                runtime->hw.rates |= SNDRV_PCM_RATE_KNOT;
+                runtime->hw.rate_max = 128000;
         }
         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 0x10000);
         return 0;
@@ -1685,6 +1729,13 @@ static int snd_cmipci_playback2_open(struct snd_pcm_substream *substream)
                 runtime->hw.rates |= SNDRV_PCM_RATE_88200 |
                                      SNDRV_PCM_RATE_96000;
                 runtime->hw.rate_max = 96000;
+        } else if (cm->chip_version == 55) {
+                err = snd_pcm_hw_constraint_list(runtime, 0,
+                        SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates);
+                if (err < 0)
+                        return err;
+                runtime->hw.rates |= SNDRV_PCM_RATE_KNOT;
+                runtime->hw.rate_max = 128000;
         }
         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 0x10000);
         return 0;
@@ -1704,7 +1755,7 @@ static int snd_cmipci_playback_spdif_open(struct snd_pcm_substream *substream)
                         runtime->hw.formats |= SNDRV_PCM_FMTBIT_S32_LE;
                         snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
                 }
-                if (cm->chip_version == 68) {
+                if (cm->can_96k) {
                         runtime->hw.rates |= SNDRV_PCM_RATE_88200 |
                                              SNDRV_PCM_RATE_96000;
                         runtime->hw.rate_max = 96000;
@@ -1726,6 +1777,11 @@ static int snd_cmipci_capture_spdif_open(struct snd_pcm_substream *substream)
         if ((err = open_device_check(cm, CM_OPEN_SPDIF_CAPTURE, substream)) < 0) /* use channel B */
                 return err;
         runtime->hw = snd_cmipci_capture_spdif;
+        if (cm->can_96k && !(cm->chip_version == 68)) {
+                runtime->hw.rates |= SNDRV_PCM_RATE_88200 |
+                                     SNDRV_PCM_RATE_96000;
+                runtime->hw.rate_max = 96000;
+        }
         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 0x40000);
         return 0;
 }
@@ -2594,10 +2650,8 @@ static struct snd_kcontrol_new snd_cmipci_extra_mixer_switches[] __devinitdata =
 };
 
 /* card control switches */
-static struct snd_kcontrol_new snd_cmipci_control_switches[] __devinitdata = {
-        // DEFINE_CARD_SWITCH("Joystick", joystick), /* now module option */
-        DEFINE_CARD_SWITCH("Modem", modem),
-};
+static struct snd_kcontrol_new snd_cmipci_modem_switch __devinitdata =
+DEFINE_CARD_SWITCH("Modem", modem);
 
 
 static int __devinit snd_cmipci_mixer_new(struct cmipci *cm, int pcm_spdif_device)
@@ -2678,9 +2732,13 @@ static int __devinit snd_cmipci_mixer_new(struct cmipci *cm, int pcm_spdif_devic
         }
 
         /* card switches */
-        sw = snd_cmipci_control_switches;
-        for (idx = 0; idx < ARRAY_SIZE(snd_cmipci_control_switches); idx++, sw++) {
-                err = snd_ctl_add(cm->card, snd_ctl_new1(sw, cm));
+        /*
+         * newer chips don't have the register bits to force modem link
+         * detection; the bit that was FLINKON now mutes CH1
+         */
+        if (cm->chip_version < 39) {
+                err = snd_ctl_add(cm->card,
+                                  snd_ctl_new1(&snd_cmipci_modem_switch, cm));
                 if (err < 0)
                         return err;
         }
@@ -2785,9 +2843,11 @@ static void __devinit query_chip(struct cmipci *cm)
                 } else if (detect & CM_CHIP_8768) {
                         cm->chip_version = 68;
                         cm->max_channels = 8;
+                        cm->can_96k = 1;
                 } else {
                         cm->chip_version = 55;
                         cm->max_channels = 6;
+                        cm->can_96k = 1;
                 }
                 cm->can_ac3_hw = 1;
                 cm->can_multi_ch = 1;