Changeset 377


Ignore:
Timestamp:
Sep 26, 2008, 10:47:57 PM (17 years ago)
Author:
rjerant
Message:

Remove Temp Hack and fix interrupt period not getting setup correctly

Location:
GPL/branches/uniaud32-2.0
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/hda_intel.c

    r376 r377  
    581581        struct azx *chip = codec->bus->private_data;
    582582        unsigned long timeout;
    583 #ifdef TARGET_OS2
    584         int count=0;
    585 #endif
    586583
    587584 again:
    … …  
    599596                if (time_after(jiffies, timeout))
    600597                        break;
    601 #ifdef TARGET_OS2
    602                 if (count >= 5000) /* Hack on OS/2 to stop infinite loop as jiffies don't increment */
    603                         break;
    604 #endif
    605598                if (codec->bus->needs_damn_long_delay)
    606599                        msleep(2); /* temporary workaround */
    607600                else {
    608601                        udelay(10);
    609 #ifdef TARGET_OS2
    610                         count=count+1;
    611 #endif
    612602                        cond_resched();
    613603                }

  • GPL/branches/uniaud32-2.0/lib32/sound.c

    r363 r377  
    765765    struct snd_pcm_hw_params params;
    766766    struct snd_pcm_sw_params swparams;
    767 
    768     int                 ret, nrperiods, minnrperiods, maxnrperiods, samplesize;
     767    struct snd_pcm_status    status;
     768
     769    int                 ret, nrperiods, minnrperiods, maxnrperiods, samplesize,i;
    769770    ULONG               bufsize, periodsize, minperiodsize, maxperiodsize;
    770771    ULONG               periodbytes, minperiodbytes, maxperiodbytes;
    771772    BOOL                fTryAgain = FALSE;
    772 
     773    ULONG ulMinRate, ulMaxRate;
     774         
    773775    if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
     776
    774777          DebugInt3();
    775778          return OSSERR_INVALID_STREAMID;
    776779    }
    777780    if(pHwParams == NULL) {
     781
    778782          DebugInt3();
    779783          return OSSERR_INVALID_PARAMETER;
    780784    }
    781785    if(pHwParams->ulDataType >= OSS32_PCM_MAX_FORMATS) {
     786
    782787          DebugInt3();
    783788          return OSSERR_INVALID_PARAMETER;
    784789    }
    785 
    786     //set operation to non-blocking
     790    if ((int)pHwParams->ulNumChannels <= 0) {
     791        printk("OSS32_WaveSetHwParams error. Invalid number of channels: %i\n", pHwParams->ulNumChannels);
     792        DebugInt3();
     793        return OSSERR_INVALID_PARAMETER;
     794    }
     795tryagain:
     796        //set operation to non-blocking
    787797    pHandle->file.f_flags = O_NONBLOCK;
    788798
    … …  
    793803    periodbytes = pHwParams->ulPeriodSize;
    794804    periodsize  = bytes_to_samples(periodbytes);
     805    // checking number of channels
     806
     807    dprintf(("channels: %ld, period size: %lx",pHwParams->ulNumChannels, periodbytes));
     808
     809    _snd_pcm_hw_params_any(&params);
     810    do {
     811        _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
     812                              SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
     813        _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
     814                              pHwParams->ulNumChannels, 0);
     815        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
     816        if (ret == 0) break;
     817        pHwParams->ulNumChannels--;
     818    } while(ret < 0 && pHwParams->ulNumChannels > 1);
     819
     820    dprintf(("channels selected: %d",pHwParams->ulNumChannels));
    795821
    796822    //get all hardware parameters
    797823    _snd_pcm_hw_params_any(&params);
    798     _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
    799                           SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
     824    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
     825                           SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
     826    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
     827                           OSSToALSADataType[pHwParams->ulDataType], 0);
     828    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
     829    if(ret != 0) {
     830        dprintf(("invalid format %lx\n", OSSToALSADataType[pHwParams->ulDataType]));
     831        return UNIXToOSSError(ret);
     832    }
     833    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
     834                          pHwParams->ulBitsPerSample, 0);
     835    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
     836    if(ret != 0) {
     837        dprintf(("invalid number of sample bits %d\n", pHwParams->ulBitsPerSample));
     838        return UNIXToOSSError(ret);
     839    }
     840    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
     841                          pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
     842    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
     843    if(ret != 0) {
     844        dprintf(("invalid number of frame bits %d\n", pHwParams->ulBitsPerSample*pHwParams->ulNumChannels));
     845        return UNIXToOSSError(ret);
     846    }
     847
     848    //_snd_pcm_hw_params_any(&params);
    800849    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
    801850                          pHwParams->ulBitsPerSample, 0);
    … …  
    810859    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
    811860    if(ret != 0) {
     861        dprintf(("32_WSetHwPms (first pass) error %d bps:%d fmt: %d ch: %d sr: %d\n",
     862                  ret,
     863                  pHwParams->ulBitsPerSample,
     864                  OSSToALSADataType[pHwParams->ulDataType],
     865                  pHwParams->ulNumChannels,
     866                  pHwParams->ulSampleRate));
     867        //printk("OSS32_WaveSetHwParams invalid sample rate %i\n", pHwParams->ulSampleRate);
     868        //        printk("will set to nearest\n");
     869        _snd_pcm_hw_params_any(&params);
     870        for (i=0; i<(sizeof(rates)/sizeof(unsigned))-1;i++)
     871        {
     872            if (pHwParams->ulSampleRate >= rates[i] &&
     873                pHwParams->ulSampleRate <= rates[i+1])
     874            {
     875                pHwParams->ulSampleRate = rates[i];
     876                _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
     877                                      pHwParams->ulSampleRate, 0);
     878                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
     879                if(ret == 0)
     880                {
     881                    _snd_pcm_hw_params_any(&params);
     882                    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
     883                                          pHwParams->ulBitsPerSample, 0);
     884                    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
     885                                          pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
     886                    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
     887                                          OSSToALSADataType[pHwParams->ulDataType], 0);
     888                    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
     889                                          pHwParams->ulNumChannels, 0);
     890                    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
     891                                          pHwParams->ulSampleRate, 0);
     892                    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
     893                    goto __next;
     894                }
     895            }
     896        }
    812897        DebugInt3();
    813898        return UNIXToOSSError(ret);
    814899    }
     900   __next:
    815901
    816902    //check period size against lower and upper boundaries
    … …  
    849935    }
    850936    else {
     937        dprintf(("32_WSHwPrms error. Invalid periodsize (=0). closing file\n"));
    851938        DebugInt3();
    852939        return OSSERR_INVALID_PARAMETER;
    … …  
    865952    //so we make sure it's an even number.
    866953    if(nrperiods == 1) {
     954        dprintf(("32_WSHwPrms error. Invalid Num periods(=1). closing file\n"));
    867955        DebugInt3();
    868956        return OSSERR_INVALID_PARAMETER;
    … …  
    872960    //initialize parameter block & set sample rate, nr of channels and sample format, nr of periods,
    873961    //period size and buffer size
    874 tryagain:
     962
    875963    _snd_pcm_hw_params_any(&params);
    876964    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
    877                           SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
    878 #if 0
     965                           SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
    879966    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
    880967                          pHwParams->ulBitsPerSample, 0);
    881968    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
    882                           pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
    883 #endif
     969                           pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
    884970    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
    885                           OSSToALSADataType[pHwParams->ulDataType], 0);
    886 
     971                           OSSToALSADataType[pHwParams->ulDataType], 0);
    887972    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
    888973                           pHwParams->ulNumChannels, 0);
    889974    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
    890                           pHwParams->ulSampleRate, 0);
    891 #if 0
     975                           pHwParams->ulSampleRate, 0);
    892976    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
    893                           periodsize, 0);
     977                           periodsize, 0);
    894978    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
    895                           periodbytes, 0);
     979                           periodbytes, 0);
    896980    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIODS,
    897                           nrperiods, 0);
     981                           nrperiods, 0);
    898982    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
    899                           periodsize*nrperiods, 0);
     983                           periodsize*nrperiods, 0);
    900984    _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
    901                           periodbytes*nrperiods, 0);
    902 #endif
    903     dprintf(("Hardware parameters: sample rate %d, data type %d, channels %d, period size %d, periods %d",
    904              pHwParams->ulSampleRate, pHwParams->ulDataType, pHwParams->ulNumChannels, periodsize, nrperiods));
     985                           periodbytes*nrperiods, 0);
     986
     987
     988    dprintf(("HWP: SR rate %ld, BPS %ld, CH %ld, PRSZ %lx, periods %lx",
     989             pHwParams->ulSampleRate, pHwParams->ulBitsPerSample, pHwParams->ulNumChannels, periodsize, nrperiods));
    905990
    906991    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)__Stack32ToFlat(&params));
     992    if (ret == -77 && fTryAgain == FALSE)
     993    {
     994        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
     995        fTryAgain = TRUE;
     996        dprintf((" Error -77 from first IOCTL HW Parms"));
     997        goto tryagain;
     998    }
     999
    9071000    if(ret) {
    9081001        if(fTryAgain == FALSE) {
    … …  
    9131006                periodsize  = maxperiodsize;
    9141007                periodbytes = samples_to_bytes(periodsize);
     1008                dprintf((" Peroid size error IOCTL HW Parms"));
    9151009                fTryAgain = TRUE;
    9161010                goto tryagain;
    9171011            }
    9181012        }
     1013        dprintf(("Error second time.. Bailing"));
    9191014        return UNIXToOSSError(ret);
    9201015    }
    … …  
    9401035        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)__Stack32ToFlat(&swparams));
    9411036    }
     1037
     1038    total = 0;
     1039    per_bytes = periodbytes;
     1040    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
     1041    if ( ((status.state != SNDRV_PCM_STATE_PREPARED) &&
     1042           (status.state != SNDRV_PCM_STATE_SETUP) &&
     1043           (status.state != SNDRV_PCM_STATE_RUNNING) &&
     1044           (status.state != SNDRV_PCM_STATE_DRAINING))) {
     1045        dprintf(("Device is not in proper state: %lx. Calling prepare\n", status.state));
     1046        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
     1047    }
    9421048    return UNIXToOSSError(ret);
    9431049}
     1050
    9441051
    9451052//******************************************************************************
Note: See TracChangeset for help on using the changeset viewer.