2 files changed, 95 insertions, 35 deletions

diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index 7ba8db5d4c42..bc882f8f163c 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -312,6 +312,9 @@ struct azx_dev {
         unsigned int period_bytes; /* size of the period in bytes */
         unsigned int frags;     /* number for period in the play buffer */
         unsigned int fifo_size; /* FIFO size */
+        unsigned int start_flag: 1;     /* stream full start flag */
+        unsigned long start_jiffies;    /* start + minimum jiffies */
+        unsigned long min_jiffies;      /* minimum jiffies before position is valid */
 
         void __iomem *sd_addr;  /* stream descriptor pointer */
 
@@ -330,7 +333,6 @@ struct azx_dev {
         unsigned int opened :1;
         unsigned int running :1;
         unsigned int irq_pending :1;
-        unsigned int irq_ignore :1;
         /*
          * For VIA:
          *  A flag to ensure DMA position is 0
@@ -975,7 +977,7 @@ static irqreturn_t azx_interrupt(int irq, void *dev_id)
         struct azx *chip = dev_id;
         struct azx_dev *azx_dev;
         u32 status;
-        int i;
+        int i, ok;
 
         spin_lock(&chip->reg_lock);
 
@@ -991,18 +993,14 @@ static irqreturn_t azx_interrupt(int irq, void *dev_id)
                         azx_sd_writeb(azx_dev, SD_STS, SD_INT_MASK);
                         if (!azx_dev->substream || !azx_dev->running)
                                 continue;
-                        /* ignore the first dummy IRQ (due to pos_adj) */
-                        if (azx_dev->irq_ignore) {
-                                azx_dev->irq_ignore = 0;
-                                continue;
-                        }
                         /* check whether this IRQ is really acceptable */
-                        if (azx_position_ok(chip, azx_dev)) {
+                        ok = azx_position_ok(chip, azx_dev);
+                        if (ok == 1) {
                                 azx_dev->irq_pending = 0;
                                 spin_unlock(&chip->reg_lock);
                                 snd_pcm_period_elapsed(azx_dev->substream);
                                 spin_lock(&chip->reg_lock);
-                        } else if (chip->bus && chip->bus->workq) {
+                        } else if (ok == 0 && chip->bus && chip->bus->workq) {
                                 /* bogus IRQ, process it later */
                                 azx_dev->irq_pending = 1;
                                 queue_work(chip->bus->workq,
@@ -1088,7 +1086,6 @@ static int azx_setup_periods(struct azx *chip,
         bdl = (u32 *)azx_dev->bdl.area;
         ofs = 0;
         azx_dev->frags = 0;
-        azx_dev->irq_ignore = 0;
         pos_adj = bdl_pos_adj[chip->dev_index];
         if (pos_adj > 0) {
                 struct snd_pcm_runtime *runtime = substream->runtime;
@@ -1109,7 +1106,6 @@ static int azx_setup_periods(struct azx *chip,
                                          &bdl, ofs, pos_adj, 1);
                         if (ofs < 0)
                                 goto error;
-                        azx_dev->irq_ignore = 1;
                 }
         } else
                 pos_adj = 0;
@@ -1155,6 +1151,9 @@ static void azx_stream_reset(struct azx *chip, struct azx_dev *azx_dev)
         while (((val = azx_sd_readb(azx_dev, SD_CTL)) & SD_CTL_STREAM_RESET) &&
                --timeout)
                 ;
+
+        /* reset first position - may not be synced with hw at this time */
+        *azx_dev->posbuf = 0;
 }
 
 /*
@@ -1409,7 +1408,6 @@ static int azx_pcm_open(struct snd_pcm_substream *substream)
         snd_pcm_set_sync(substream);
         mutex_unlock(&chip->open_mutex);
 
-        azx_stream_reset(chip, azx_dev);
         return 0;
 }
 
@@ -1474,6 +1472,7 @@ static int azx_pcm_prepare(struct snd_pcm_substream *substream)
         unsigned int bufsize, period_bytes, format_val;
         int err;
 
+        azx_stream_reset(chip, azx_dev);
         format_val = snd_hda_calc_stream_format(runtime->rate,
                                                 runtime->channels,
                                                 runtime->format,
@@ -1502,6 +1501,8 @@ static int azx_pcm_prepare(struct snd_pcm_substream *substream)
                         return err;
         }
 
+        azx_dev->min_jiffies = (runtime->period_size * HZ) /
+                                                (runtime->rate * 2);
         azx_setup_controller(chip, azx_dev);
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
                 azx_dev->fifo_size = azx_sd_readw(azx_dev, SD_FIFOSIZE) + 1;
@@ -1518,13 +1519,14 @@ static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
         struct azx *chip = apcm->chip;
         struct azx_dev *azx_dev;
         struct snd_pcm_substream *s;
-        int start, nsync = 0, sbits = 0;
+        int rstart = 0, start, nsync = 0, sbits = 0;
         int nwait, timeout;
 
         switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                rstart = 1;
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
         case SNDRV_PCM_TRIGGER_RESUME:
-        case SNDRV_PCM_TRIGGER_START:
                 start = 1;
                 break;
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
@@ -1554,6 +1556,10 @@ static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
                 if (s->pcm->card != substream->pcm->card)
                         continue;
                 azx_dev = get_azx_dev(s);
+                if (rstart) {
+                        azx_dev->start_flag = 1;
+                        azx_dev->start_jiffies = jiffies + azx_dev->min_jiffies;
+                }
                 if (start)
                         azx_stream_start(chip, azx_dev);
                 else
@@ -1703,6 +1709,11 @@ static int azx_position_ok(struct azx *chip, struct azx_dev *azx_dev)
 {
         unsigned int pos;
 
+        if (azx_dev->start_flag &&
+            time_before_eq(jiffies, azx_dev->start_jiffies))
+                return -1;      /* bogus (too early) interrupt */
+        azx_dev->start_flag = 0;
+
         pos = azx_get_position(chip, azx_dev);
         if (chip->position_fix == POS_FIX_AUTO) {
                 if (!pos) {
diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c
index 57648810eaf1..5dced5b79387 100644
--- a/sound/pci/intel8x0.c
+++ b/sound/pci/intel8x0.c
@@ -355,6 +355,9 @@ struct ichdev {
         unsigned int fragsize1;
         unsigned int position;
         unsigned int pos_shift;
+        unsigned int last_pos;
+        unsigned long last_pos_jiffies;
+        unsigned int jiffy_to_bytes;
         int frags;
         int lvi;
         int lvi_frag;
@@ -838,7 +841,10 @@ static int snd_intel8x0_pcm_trigger(struct snd_pcm_substream *substream, int cmd
                 ichdev->suspended = 0;
                 /* fallthru */
         case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
                 val = ICH_IOCE | ICH_STARTBM;
+                ichdev->last_pos = ichdev->position;
+                ichdev->last_pos_jiffies = jiffies;
                 break;
         case SNDRV_PCM_TRIGGER_SUSPEND:
                 ichdev->suspended = 1;
@@ -849,9 +855,6 @@ static int snd_intel8x0_pcm_trigger(struct snd_pcm_substream *substream, int cmd
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
                 val = ICH_IOCE;
                 break;
-        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                val = ICH_IOCE | ICH_STARTBM;
-                break;
         default:
                 return -EINVAL;
         }
@@ -1045,6 +1048,7 @@ static int snd_intel8x0_pcm_prepare(struct snd_pcm_substream *substream)
                         ichdev->pos_shift = (runtime->sample_bits > 16) ? 2 : 1;
         }
         snd_intel8x0_setup_periods(chip, ichdev);
+        ichdev->jiffy_to_bytes = (runtime->rate * 4 * ichdev->pos_shift) / HZ;
         return 0;
 }
 
@@ -1053,7 +1057,7 @@ static snd_pcm_uframes_t snd_intel8x0_pcm_pointer(struct snd_pcm_substream *subs
         struct intel8x0 *chip = snd_pcm_substream_chip(substream);
         struct ichdev *ichdev = get_ichdev(substream);
         size_t ptr1, ptr;
-        int civ, timeout = 100;
+        int civ, timeout = 10;
         unsigned int position;
 
         spin_lock(&chip->reg_lock);
@@ -1069,9 +1073,19 @@ static snd_pcm_uframes_t snd_intel8x0_pcm_pointer(struct snd_pcm_substream *subs
                     ptr1 == igetword(chip, ichdev->reg_offset + ichdev->roff_picb))
                         break;
         } while (timeout--);
-        ptr1 <<= ichdev->pos_shift;
-        ptr = ichdev->fragsize1 - ptr1;
-        ptr += position;
+        if (ptr1 != 0) {
+                ptr1 <<= ichdev->pos_shift;
+                ptr = ichdev->fragsize1 - ptr1;
+                ptr += position;
+                ichdev->last_pos = ptr;
+                ichdev->last_pos_jiffies = jiffies;
+        } else {
+                ptr1 = jiffies - ichdev->last_pos_jiffies;
+                if (ptr1)
+                        ptr1 -= 1;
+                ptr = ichdev->last_pos + ptr1 * ichdev->jiffy_to_bytes;
+                ptr %= ichdev->size;
+        }
         spin_unlock(&chip->reg_lock);
         if (ptr >= ichdev->size)
                 return 0;
@@ -2661,12 +2675,14 @@ static void __devinit intel8x0_measure_ac97_clock(struct intel8x0 *chip)
         struct snd_pcm_substream *subs;
         struct ichdev *ichdev;
         unsigned long port;
-        unsigned long pos, t;
-        struct timeval start_time, stop_time;
+        unsigned long pos, pos1, t;
+        int civ, timeout = 1000, attempt = 1;
+        struct timespec start_time, stop_time;
 
         if (chip->ac97_bus->clock != 48000)
                 return; /* specified in module option */
 
+      __again:
         subs = chip->pcm[0]->streams[0].substream;
         if (! subs || subs->dma_buffer.bytes < INTEL8X0_TESTBUF_SIZE) {
                 snd_printk(KERN_WARNING "no playback buffer allocated - aborting measure ac97 clock\n");
@@ -2674,7 +2690,7 @@ static void __devinit intel8x0_measure_ac97_clock(struct intel8x0 *chip)
         }
         ichdev = &chip->ichd[ICHD_PCMOUT];
         ichdev->physbuf = subs->dma_buffer.addr;
-        ichdev->size = chip->ichd[ICHD_PCMOUT].fragsize = INTEL8X0_TESTBUF_SIZE;
+        ichdev->size = ichdev->fragsize = INTEL8X0_TESTBUF_SIZE;
         ichdev->substream = NULL; /* don't process interrupts */
 
         /* set rate */
@@ -2693,16 +2709,31 @@ static void __devinit intel8x0_measure_ac97_clock(struct intel8x0 *chip)
                 iputbyte(chip, port + ICH_REG_OFF_CR, ICH_IOCE);
                 iputdword(chip, ICHREG(ALI_DMACR), 1 << ichdev->ali_slot);
         }
-        do_gettimeofday(&start_time);
+        do_posix_clock_monotonic_gettime(&start_time);
         spin_unlock_irq(&chip->reg_lock);
         msleep(50);
         spin_lock_irq(&chip->reg_lock);
         /* check the position */
-        pos = ichdev->fragsize1;
-        pos -= igetword(chip, ichdev->reg_offset + ichdev->roff_picb) << ichdev->pos_shift;
-        pos += ichdev->position;
+        do {
+                civ = igetbyte(chip, ichdev->reg_offset + ICH_REG_OFF_CIV);
+                pos1 = igetword(chip, ichdev->reg_offset + ichdev->roff_picb);
+                if (pos1 == 0) {
+                        udelay(10);
+                        continue;
+                }
+                if (civ == igetbyte(chip, ichdev->reg_offset + ICH_REG_OFF_CIV) &&
+                    pos1 == igetword(chip, ichdev->reg_offset + ichdev->roff_picb))
+                        break;
+        } while (timeout--);
+        if (pos1 == 0) {        /* oops, this value is not reliable */
+                pos = 0;
+        } else {
+                pos = ichdev->fragsize1;
+                pos -= pos1 << ichdev->pos_shift;
+                pos += ichdev->position;
+        }
         chip->in_measurement = 0;
-        do_gettimeofday(&stop_time);
+        do_posix_clock_monotonic_gettime(&stop_time);
         /* stop */
         if (chip->device_type == DEVICE_ALI) {
                 iputdword(chip, ICHREG(ALI_DMACR), 1 << (ichdev->ali_slot + 16));
@@ -2717,19 +2748,37 @@ static void __devinit intel8x0_measure_ac97_clock(struct intel8x0 *chip)
         iputbyte(chip, port + ICH_REG_OFF_CR, ICH_RESETREGS);
         spin_unlock_irq(&chip->reg_lock);
 
+        if (pos == 0) {
+                snd_printk(KERN_ERR "intel8x0: measure - unreliable DMA position..\n");
+              __retry:
+                if (attempt < 2) {
+                        attempt++;
+                        goto __again;
+                }
+                return;
+        }
+
+        pos /= 4;
         t = stop_time.tv_sec - start_time.tv_sec;
         t *= 1000000;
-        t += stop_time.tv_usec - start_time.tv_usec;
-        printk(KERN_INFO "%s: measured %lu usecs\n", __func__, t);
+        t += (stop_time.tv_nsec - start_time.tv_nsec) / 1000;
+        printk(KERN_INFO "%s: measured %lu usecs (%lu samples)\n", __func__, t, pos);
         if (t == 0) {
-                snd_printk(KERN_ERR "?? calculation error..\n");
-                return;
+                snd_printk(KERN_ERR "intel8x0: ?? calculation error..\n");
+                goto __retry;
         }
-        pos = (pos / 4) * 1000;
+        pos *= 1000;
         pos = (pos / t) * 1000 + ((pos % t) * 1000) / t;
-        if (pos < 40000 || pos >= 60000) 
+        if (pos < 40000 || pos >= 60000) {
                 /* abnormal value. hw problem? */
                 printk(KERN_INFO "intel8x0: measured clock %ld rejected\n", pos);
+                goto __retry;
+        } else if (pos > 40500 && pos < 41500)
+                /* first exception - 41000Hz reference clock */
+                chip->ac97_bus->clock = 41000;
+        else if (pos > 43600 && pos < 44600)
+                /* second exception - 44100HZ reference clock */
+                chip->ac97_bus->clock = 44100;
         else if (pos < 47500 || pos > 48500)
                 /* not 48000Hz, tuning the clock.. */
                 chip->ac97_bus->clock = (chip->ac97_bus->clock * 48000) / pos;