Changeset 377

Show
Ignore:
Timestamp:
09/26/08 22:47:57 (2 months ago)
Author:
rjerant
Message:

Remove Temp Hack and fix interrupt period not getting setup correctly

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

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//******************************************************************************