Ignore:
Timestamp:
Jul 20, 2010, 5:52:49 PM (15 years ago)
Author:
David Azarewicz
Message:

Changes to PCI bus scan, malloc, cleanup all warnings, misc other changes

File:
1 edited

Legend:

Unmodified
Added
Removed
  • GPL/branches/uniaud32-2.1.x/lib32/sound.c

    r516 r519  
    281281           }
    282282        } else {
    283            printk("HDA audio detected - don't support 5512 - 32000 Hz audio sample rates\n");
     283           dprintf(("HDA audio detected - don't support 5512 - 32000 Hz audio sample rates\n"));
    284284        }
    285285        if(fuRates & SNDRV_PCM_RATE_44100) {
     
    331331        int max_ch;
    332332
    333 #ifdef DEBUG
    334333        dprintf(("OSS32_QueryDevCaps"));
    335 #endif
    336334//        max_ch = GetMaxChannels(deviceid, OSS32_CAPS_WAVE_PLAYBACK);
    337335
     
    340338        if(pcminfo == NULL) {
    341339                DebugInt3();
    342                 printk("OSS32_QueryDevCaps: out of memory\n");
     340                rprintf(("OSS32_QueryDevCaps: out of memory\n"));
    343341                return OSSERR_OUT_OF_MEMORY;
    344342        }
    345343        params = (struct snd_pcm_hw_params *)(pcminfo+1);
    346344
    347         printk("Number of cards: %i",nrCardsDetected);
    348         printk("dev id: %i",deviceid);
     345        dprintf(("Number of cards=%i dev id=%i", nrCardsDetected, deviceid));
    349346        pDevCaps->nrDevices  = 1;//nrCardsDetected;
    350347//        pDevCaps->nrDevices  = nrCardsDetected;
     
    359356                if(ret != OSSERR_SUCCESS)
    360357                {
    361                         printk("OSS32_QueryDevCaps: wave open error %i\n", ret);
     358                        rprintf(("OSS32_QueryDevCaps: wave open error %i\n", ret));
    362359                        DebugInt3();
    363360                        goto fail;
     
    365362                pHandle = (soundhandle *)streamid;
    366363                if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
    367                         printk("OSS32_QueryDevCaps: invalid stream id \n");
     364                        rprintf(("OSS32_QueryDevCaps: invalid stream id \n"));
    368365                        ret = OSSERR_INVALID_STREAMID;
    369366                        goto fail;
     
    374371                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_INFO, (ULONG)pcminfo);
    375372                if(ret != 0) {
    376                         printk("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_INFO error %i\n", ret);
     373                        rprintf(("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_INFO error %i\n", ret));
    377374                        ret = UNIXToOSSError(ret);
    378375                        goto fail;
     
    384381                        else strncpy(pDevCaps->szDeviceName, pcminfo->id, sizeof(pDevCaps->szDeviceName));
    385382                }
    386                 printk("Device name: %s", pDevCaps->szDeviceName);
     383                dprintf(("Device name: %s", pDevCaps->szDeviceName));
    387384                pWaveCaps->nrStreams = pcminfo->subdevices_count;
    388385
     
    391388                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
    392389                if(ret != 0) {
    393                         printk("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_HW_REFINE error %i\n", ret);
     390                        rprintf(("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_HW_REFINE error %i\n", ret));
    394391                        ret = UNIXToOSSError(ret);
    395392                        goto fail;
     
    468465        if(OSS32_MixQueryName(deviceid, &pDevCaps->szMixerName, sizeof(pDevCaps->szMixerName)) != OSSERR_SUCCESS) {
    469466                DebugInt3();
    470                 printk("OSS32_QueryDevCaps: OSS32_MixQueryName error\n");
     467                rprintf(("OSS32_QueryDevCaps: OSS32_MixQueryName error\n"));
    471468                goto fail;
    472469        }
    473         printk("OSS32_QueryDevCaps: devname: [%s]\n", pDevCaps->szDeviceName);
     470        dprintf(("OSS32_QueryDevCaps: devname: [%s]\n", pDevCaps->szDeviceName));
    474471        kfree(pcminfo);
    475472        streamid = 0;
     
    479476
    480477fail:
    481         printk("OSS32_QueryDevCaps failed\n");
     478        rprintf(("OSS32_QueryDevCaps failed\n"));
    482479        DebugInt3();
    483480        if(streamid)   OSS32_WaveClose(streamid);
     
    497494        else
    498495        {
    499                 printk("ERROR: invalid stream id pointer passed\n");
     496                rprintf(("ERROR: invalid stream id pointer\n"));
    500497                return OSSERR_OUT_OF_MEMORY;
    501498        }
     
    503500        if(alsa_fops == NULL) {
    504501                DebugInt3();
    505 #ifdef DEBUG
    506                 dprintf(("OSS32_WaveOpen: no devices"));
    507 #endif
    508                 printk("OSS32_WaveOpen: no devices\n");
     502                rprintf(("OSS32_WaveOpen: no devices"));
    509503
    510504                return OSSERR_NO_DEVICE_AVAILABLE;
    511505        }
    512506
    513 //        printk("dev id: %i\n",deviceid);
     507        //dprintf(("dev id: %i\n",deviceid));
    514508
    515509        pHandle = kmalloc(sizeof(soundhandle), GFP_KERNEL);
    516510        if(pHandle == NULL) {
    517511                DebugInt3();
    518                 printk("OSS32_WaveOpen: out of memory\n");
     512                rprintf(("OSS32_WaveOpen: out of memory\n"));
    519513                return OSSERR_OUT_OF_MEMORY;
    520514        }
     
    540534                DebugInt3();
    541535                kfree(pHandle);
    542                 printk("OSS32_WaveOpen: invalid parameter\n");
     536                rprintf(("OSS32_WaveOpen: invalid parameter\n"));
    543537                return OSSERR_INVALID_PARAMETER;
    544538        }
    545539
    546540        ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
    547         printk("OSS32_WaveOpen. ret: %i\n", ret);
     541        //dprintf(("OSS32_WaveOpen. ret: %i\n", ret));
    548542        /* check if PCM already opened (stupid uniaud16.sys doesnt closes it) */
    549543        if (ret == -16)
     
    564558                                                kfree(opened_handles[i].handle);   //free handle data
    565559                                                ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
    566                                                 printk("OSS32_WaveOpen. Reopen ret: %i\n", ret);
     560                                                dprintf(("OSS32_WaveOpen. Reopen ret: %i\n", ret));
    567561                                        }
    568562                                        else
     
    592586                kfree(pHandle);
    593587                DebugInt3();
    594                 printk("OSS32_WaveOpen: open error: %i\n",ret);
     588                rprintf(("OSS32_WaveOpen: open error: %i\n",ret));
    595589                return UNIXToOSSError(ret);
    596590        }
     
    599593                *pStreamId = (ULONG)pHandle;
    600594        // filling opened handles table
    601         printk("OSS32_WaveOpen. streamid %X\n",(ULONG)pHandle);
     595        dprintf(("OSS32_WaveOpen. streamid %X\n",(ULONG)pHandle));
    602596        return OSSERR_SUCCESS;
    603597}
     
    612606        if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
    613607                DebugInt3();
    614                 printk("OSS32_WaveClose. invalid streamid %X\n",(ULONG)pHandle);
     608                rprintf(("OSS32_WaveClose. invalid streamid %X\n",(ULONG)pHandle));
    615609                return OSSERR_INVALID_STREAMID;
    616610        }
     
    623617                if (opened_handles[i].handle == pHandle)
    624618                {
    625                         printk("Found phandle for closing: %x reuse flag: %i\n", pHandle, opened_handles[i].reuse);
     619                        dprintf(("Found phandle for closing: %x reuse flag: %i\n", pHandle, opened_handles[i].reuse));
    626620                        if (!opened_handles[i].reuse)
    627621                        {
     
    643637        {
    644638                //all already closed
    645                 printk("phandle %x not found\n", pHandle);
     639                dprintf(("phandle %x not found\n", pHandle));
    646640//                return OSSERR_SUCCESS;
    647641        }
     
    649643
    650644        if(ret) {
    651                 printk("Error closing wave. rc = %i\n", ret);
     645                dprintf(("Error closing wave. rc = %i\n", ret));
    652646                DebugInt3();
    653647                return UNIXToOSSError(ret);
    654648        }
    655         printk("OSS32_WaveClose. streamid %X\n",(ULONG)pHandle);
     649        dprintf(("OSS32_WaveClose. streamid %X\n", (ULONG)pHandle));
    656650        return OSSERR_SUCCESS;
    657651}
     
    663657        int                     ret;
    664658
    665 #ifdef DEBUG
    666659        dprintf(("OSS32_WavePrepare"));
    667 #endif
    668660
    669661        if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
    670662                DebugInt3();
    671 //#ifdef DEBUG
    672                 printk("vladest: OSS32_WavePrepare: invalid streamID\n");
    673 //#endif
     663                rprintf(("vladest: OSS32_WavePrepare: invalid streamID\n"));
    674664
    675665                  return OSSERR_INVALID_STREAMID;
     
    680670        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
    681671        if (ret)
    682                 printk("Wave prepare ret = %i, streamid %X\n",ret,(ULONG)pHandle);
     672                rprintf(("Wave prepare ret = %i, streamid %X\n",ret,(ULONG)pHandle));
    683673
    684674        return UNIXToOSSError(ret);;
     
    699689        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_START, 0);
    700690        if (ret)
    701                 printk("Wave start ret = %i, streamid %X\n",ret,(ULONG)pHandle);
     691                rprintf(("Wave start ret = %i, streamid %X\n",ret,(ULONG)pHandle));
    702692
    703693        return UNIXToOSSError(ret);;
     
    719709        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
    720710        if (ret)
    721                 printk("Wave stop ret = %i. streamid %X\n",ret,(ULONG)pHandle);
     711                rprintf(("Wave stop ret = %i. streamid %X\n",ret,(ULONG)pHandle));
    722712
    723713        return UNIXToOSSError(ret);;
     
    739729        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 0);
    740730        if (ret)
    741                 printk("Wave pause ret = %i, streamid %X\n",ret,(ULONG)pHandle);
     731                rprintf(("Wave pause ret = %i, streamid %X\n",ret,(ULONG)pHandle));
    742732
    743733        return UNIXToOSSError(ret);;
     
    759749        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 1);
    760750        if (ret)
    761                 printk("Wave resume ret = %i, streamid %X\n",ret,(ULONG)pHandle);
     751                rprintf(("Wave resume ret = %i, streamid %X\n",ret,(ULONG)pHandle));
    762752
    763753        return UNIXToOSSError(ret);;
     
    801791        }
    802792        if ((int)pHwParams->ulNumChannels <= 0) {
    803                 printk("OSS32_WaveSetHwParams error. Invalid number of channels: %i\n", pHwParams->ulNumChannels);
     793                rprintf(("OSS32_WaveSetHwParams error. Invalid number of channels: %i\n", pHwParams->ulNumChannels));
    804794                DebugInt3();
    805795                return OSSERR_INVALID_PARAMETER;
     
    840830        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
    841831        if(ret != 0) {
    842                 dprintf(("invalid format %lx\n", OSSToALSADataType[pHwParams->ulDataType]));
     832                rprintf(("invalid format %lx\n", OSSToALSADataType[pHwParams->ulDataType]));
    843833                return UNIXToOSSError(ret);
    844834        }
     
    847837        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
    848838        if(ret != 0) {
    849                 dprintf(("invalid number of sample bits %d\n", pHwParams->ulBitsPerSample));
     839                rprintf(("invalid number of sample bits %d\n", pHwParams->ulBitsPerSample));
    850840                return UNIXToOSSError(ret);
    851841        }
     
    854844        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
    855845        if(ret != 0) {
    856                 dprintf(("invalid number of frame bits %d\n", pHwParams->ulBitsPerSample*pHwParams->ulNumChannels));
     846                rprintf(("invalid number of frame bits %d\n", pHwParams->ulBitsPerSample*pHwParams->ulNumChannels));
    857847                return UNIXToOSSError(ret);
    858848        }
     
    871861        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
    872862        if(ret != 0) {
    873                 dprintf(("32_WSetHwPms (first pass) error %d bps:%d fmt: %d ch: %d sr: %d\n",
     863                rprintf(("32_WSetHwPms (first pass) error %d bps:%d fmt: %d ch: %d sr: %d\n",
    874864                                  ret,
    875865                                  pHwParams->ulBitsPerSample,
     
    947937        }
    948938        else {
    949                 dprintf(("32_WSHwPrms error. Invalid periodsize (=0). closing file\n"));
     939                rprintf(("32_WSHwPrms error. Invalid periodsize (=0). closing file\n"));
    950940                DebugInt3();
    951941                return OSSERR_INVALID_PARAMETER;
     
    964954        //so we make sure it's an even number.
    965955        if(nrperiods == 1) {
    966                 dprintf(("32_WSHwPrms error. Invalid Num periods(=1). closing file\n"));
     956                rprintf(("32_WSHwPrms error. Invalid Num periods(=1). closing file\n"));
    967957                DebugInt3();
    968958                return OSSERR_INVALID_PARAMETER;
     
    1006996                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
    1007997                fTryAgain = TRUE;
    1008                 dprintf((" Error -77 from first IOCTL HW Parms"));
     998                rprintf((" Error -77 from first IOCTL HW Parms"));
    1009999                goto tryagain;
    10101000        }
     
    10241014                        }
    10251015                }
    1026                 dprintf(("Error %ld second time.. Bailing", ret));
     1016                rprintf(("Error %ld second time.. Bailing", ret));
    10271017                return UNIXToOSSError(ret);
    10281018        }
     
    10561046                   (status.state != SNDRV_PCM_STATE_RUNNING) &&
    10571047                   (status.state != SNDRV_PCM_STATE_DRAINING))) {
    1058                 dprintf(("Device is not in proper state: %lx. Calling prepare\n", status.state));
     1048                rprintf(("Device is not in proper state: %lx. Calling prepare\n", status.state));
    10591049                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
    10601050        }
     
    11491139                while (ulSize && ulJ && iRet)
    11501140                {
    1151                         for (i=0; i < 1000; i++)
     1141                        for (ulI=0; ulI < 1000; ulI++)
    11521142                        {
    11531143                                iRet1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
     
    11571147                                        rprintf(("Internal Error: Xrun\n"));
    11581148                                }
    1159                                 if (i > 998) {
     1149                                if (ulI > 998) {
    11601150                                        // printk("timeout stat %x avail:%d hw:%d app:%d\n",status.state,samples_to_bytes(status.avail),samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr));
    11611151                                        iRet1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
Note: See TracChangeset for help on using the changeset viewer.