Changeset 594


Ignore:
Timestamp:
Apr 3, 2017, 3:18:42 PM (8 years ago)
Author:
David Azarewicz
Message:

Code cleanup.
Hack for tick.

Location:
GPL/branches/uniaud32-2.1.x
Files:
28 edited

Legend:

Unmodified
Added
Removed
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/core/info.c

    r569 r594  
    8181static void snd_info_disconnect(struct snd_info_entry *entry);
    8282
    83 
     83#ifdef NOT_USED
    8484/* resize the proc r/w buffer */
    8585static int resize_info_buffer(struct snd_info_buffer *buffer,
     
    106106        return 0;
    107107}
     108#endif
    108109
    109110#ifndef TARGET_OS2
     
    171172}
    172173
     174#ifdef NOT_USED
    173175static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig)
    174176{
     
    557559        .release =              snd_info_entry_release,
    558560};
     561#endif
    559562
    560563int __init snd_info_init(void)
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/core/init.c

    r573 r594  
    657657#endif
    658658
     659#ifdef NOT_USED
    659660static struct device_attribute card_id_attrs =
    660661        __ATTR(id, S_IRUGO | S_IWUSR, card_id_show_attr, card_id_store_attr);
    661662
    662 #ifdef NOT_USED
    663663static ssize_t
    664664card_number_show_attr(struct device *dev,
     
    668668        return snprintf(buf, PAGE_SIZE, "%i\n", card ? card->number : -1);
    669669}
    670 #endif
    671670
    672671static struct device_attribute card_number_attrs =
    673672        __ATTR(number, S_IRUGO, card_number_show_attr, NULL);
     673#endif
    674674
    675675/**
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/core/pcm.c

    r569 r594  
    231231#define ACCESS(v) [SNDRV_PCM_ACCESS_##v] = #v
    232232#define START(v) [SNDRV_PCM_START_##v] = #v
    233 #define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v 
     233#define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v
    234234
    235235static char *snd_pcm_stream_names[] = {
     
    11841184int pcm_instances(int card_id)
    11851185{
    1186     int idx;
     1186    //int idx;
    11871187    int pcms = 0;
    11881188    struct snd_pcm *pcm;
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/core/pcm_lib.c

    r592 r594  
    4646        snd_pcm_uframes_t frames, ofs, transfer;
    4747
     48  /* DAZ: This is a hack to prevent extra noise after every sound.
     49   * runtime->boundary is always *much* bigger than runtime->silence_size
     50   * so the ring buffer never gets filled with silence. This hack forces
     51   * the ring buffer to always get filled with silence.
     52   * I am guessing that the OS2 code is not providing a big enough buffer
     53   * of silence.
     54   */
     55  #ifndef TARGET_OS2
    4856        if (runtime->silence_size < runtime->boundary) {
    4957                snd_pcm_sframes_t noise_dist, n;
     
    6775                        frames = runtime->silence_size;
    6876        } else {
     77        #endif
    6978                if (new_hw_ptr == ULONG_MAX) {  /* initialization */
    7079                        snd_pcm_sframes_t avail = snd_pcm_playback_hw_avail(runtime);
     
    8998                }
    9099                frames = runtime->buffer_size - runtime->silence_filled;
    91         }
     100  #ifndef TARGET_OS2           
     101        }
     102        #endif
    92103        if (snd_BUG_ON(frames > runtime->buffer_size))
    93104                return;
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/core/pcm_native.c

    r569 r594  
    892892        snd_pcm_trigger_tstamp(substream);
    893893        runtime->hw_ptr_jiffies = jiffies;
    894         runtime->hw_ptr_buffer_jiffies = (runtime->buffer_size * HZ) / 
     894        runtime->hw_ptr_buffer_jiffies = (runtime->buffer_size * HZ) /
    895895                                                            runtime->rate;
    896896        runtime->status->state = state;
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/core/sgbuf.c

    r519 r594  
    109109{
    110110        struct snd_sg_buf *sgbuf;
    111         unsigned int i, pages, chunk, maxpages;
    112         struct snd_dma_buffer tmpb;
     111        unsigned int pages;
     112//      unsigned int i, chunk, maxpages;
     113//      struct snd_dma_buffer tmpb;
    113114#ifdef TARGET_OS2
    114115        void *ptr;
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/core/sound_oss.c

    r499 r594  
    114114        int cidx = SNDRV_MINOR_OSS_CARD(minor);
    115115        int track2 = -1;
    116         int register1 = -1, register2 = -1;
    117         struct device *carddev = snd_card_get_device_link(card);
     116//      int register1 = -1, register2 = -1;
     117//      struct device *carddev = snd_card_get_device_link(card);
    118118
    119119        if (card && card->number >= 8)
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/core/timer.c

    r573 r594  
    4444#endif
    4545
    46 static int timer_limit = DEFAULT_TIMER_LIMIT;
     46//static int timer_limit = DEFAULT_TIMER_LIMIT;
    4747static int timer_tstamp_monotonic = 1;
    4848MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>");
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/pci/ac97/ac97_codec.c

    r569 r594  
    603603}
    604604
     605#ifdef NOT_USED
    605606static const struct snd_kcontrol_new snd_ac97_controls_master_mono[2] = {
    606607AC97_SINGLE("Master Mono Playback Switch", AC97_MASTER_MONO, 15, 1, 1),
    607608AC97_SINGLE("Master Mono Playback Volume", AC97_MASTER_MONO, 0, 31, 1)
    608609};
     610#endif
    609611
    610612static const struct snd_kcontrol_new snd_ac97_controls_tone[2] = {
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/pci/ali5451/ali5451.c

    r499 r594  
    6161
    6262/* just for backward compatibility */
    63 static int enable;
     63//static int enable;
    6464module_param(enable, bool, 0444);
    6565
     
    302302                                             unsigned int port)
    303303{
    304         return (unsigned int)inl(ALI_REG(codec, port)); 
     304        return (unsigned int)inl(ALI_REG(codec, port));
    305305}
    306306
     
    815815        bVal = inb(ALI_REG(codec, ALI_SPDIF_CTRL));
    816816        outb(bVal & ALI_SPDIF_OUT_CH_STATUS, ALI_REG(codec, ALI_SPDIF_CTRL));
    817    
     817
    818818        wVal = inw(ALI_REG(codec, ALI_GLOBAL_CONTROL));
    819819        wVal |= ALI_SPDIF_OUT_SEL_PCM;
     
    10761076                else if (rate == 48000)
    10771077                        delta = 0x1000;
    1078                 else 
     1078                else
    10791079                        delta = (((rate << 12) + rate) / 48000) & 0x0000ffff;
    10801080        }
     
    11071107static int snd_ali_trigger(struct snd_pcm_substream *substream,
    11081108                               int cmd)
    1109                                    
     1109                               
    11101110{
    11111111        struct snd_ali *codec = snd_pcm_substream_chip(substream);
     
    12591259        Delta = snd_ali_convert_rate(runtime->rate, 0);
    12601260
    1261         if (pvoice->number == ALI_SPDIF_IN_CHANNEL || 
     1261        if (pvoice->number == ALI_SPDIF_IN_CHANNEL ||
    12621262            pvoice->number == ALI_PCM_IN_CHANNEL)
    12631263                snd_ali_disable_special_channel(codec, pvoice->number);
     
    12771277
    12781278        /* set target ESO for channel */
    1279         pvoice->eso = runtime->buffer_size; 
     1279        pvoice->eso = runtime->buffer_size;
    12801280
    12811281        snd_ali_printk("playback_prepare: eso=%xh count=%xh\n",
     
    13501350
    13511351        Delta = (pvoice->number == ALI_MODEM_IN_CHANNEL ||
    1352                  pvoice->number == ALI_MODEM_OUT_CHANNEL) ? 
     1352                 pvoice->number == ALI_MODEM_OUT_CHANNEL) ?
    13531353                0x1000 : snd_ali_convert_rate(runtime->rate, pvoice->mode);
    13541354
     
    13801380
    13811381        /* set target ESO for channel  */
    1382         pvoice->eso = runtime->buffer_size; 
     1382        pvoice->eso = runtime->buffer_size;
    13831383
    13841384        /* set interrupt count size  */
     
    18091809                }
    18101810                break;
    1811         case 1: 
     1811        case 1:
    18121812                change = (codec->spdif_mask & 0x04) ? 1 : 0;
    18131813                change = change ^ spdif_enable;
     
    19291929        for (i = 0; i < ALI_CHANNELS; i++) {
    19301930                outb(i, ALI_REG(chip, ALI_GC_CIR));
    1931                 for (j = 0; j < ALI_CHANNEL_REGS; j++) 
     1931                for (j = 0; j < ALI_CHANNEL_REGS; j++)
    19321932                        im->channel_regs[i][j] = inl(ALI_REG(chip, j*4 + 0xe0));
    19331933        }
     
    19691969        for (i = 0; i < ALI_CHANNELS; i++) {
    19701970                outb(i, ALI_REG(chip, ALI_GC_CIR));
    1971                 for (j = 0; j < ALI_CHANNEL_REGS; j++) 
     1971                for (j = 0; j < ALI_CHANNEL_REGS; j++)
    19721972                        outl(im->channel_regs[i][j], ALI_REG(chip, j*4 + 0xe0));
    19731973        }
     
    23182318        .resume = ali_resume,
    23192319#endif
    2320 };                               
     2320};
    23212321
    23222322static int __init alsa_card_ali_init(void)
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/pci/atiixp.c

    r519 r594  
    6161
    6262/* just for backward compatibility */
    63 static int enable;
     63//static int enable;
    6464module_param(enable, bool, 0444);
    6565
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/pci/hda/hda_codec.c

    r569 r594  
    639639        struct hda_codec_preset_list *tbl;
    640640        const struct hda_codec_preset *preset;
    641         int mod_requested = 0;
     641        //int mod_requested = 0;
    642642
    643643        if (is_generic_config(codec))
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/pci/hda/hda_proc.c

    r569 r594  
    493493#endif
    494494
    495         int sup = snd_hda_param_read(codec, nid, AC_PAR_POWER_STATE);
     495        //int sup = snd_hda_param_read(codec, nid, AC_PAR_POWER_STATE);
    496496        int pwr = snd_hda_codec_read(codec, nid, 0,
    497497                                     AC_VERB_GET_POWER_STATE, 0);
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/pci/hda/patch_sigmatel.c

    r569 r594  
    48504850{
    48514851        struct sigmatel_spec *spec = codec->spec;
    4852         const struct dmi_device *dev = NULL;
     4852        //const struct dmi_device *dev = NULL;
    48534853
    48544854        if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) {
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/pci/intel8x0.c

    r569 r594  
    9797
    9898/* just for backward compatibility */
    99 static int enable;
     99//static int enable;
    100100module_param(enable, bool, 0444);
    101 static int joystick;
     101//static int joystick;
    102102module_param(joystick, int, 0444);
    103103
     
    31643164};
    31653165
     3166#ifdef NOT_USED
    31663167static struct snd_pci_quirk spdif_aclink_defaults[] __devinitdata = {
    31673168        SND_PCI_QUIRK(0x147b, 0x1c1a, "ASUS KN8", 1),
    31683169        {0} /* end */
    31693170};
     3171#endif
    31703172
    31713173/* look up white/black list for SPDIF over ac-link */
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/pci/nm256/nm256.c

    r499 r594  
    1 /* 
     1/*
    22 * Driver for NeoMagic 256AV and 256ZX chipsets.
    33 * Copyright (c) 2000 by Takashi Iwai <tiwai@suse.de>
     
    2424 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
    2525 */
    26  
     26
    2727#include <asm/io.h>
    2828#include <linux/delay.h>
     
    8787
    8888/* just for backward compatibility */
    89 static int enable;
     89//static int enable;
    9090module_param(enable, bool, 0444);
    9191
     
    401401};
    402402static struct snd_pcm_hw_constraint_list constraints_rates = {
    403         .count = ARRAY_SIZE(samplerates), 
     403        .count = ARRAY_SIZE(samplerates),
    404404        .list = samplerates,
    405405        .mask = 0,
     
    957957
    958958
    959 /* 
    960  * Initialize the hardware. 
     959/*
     960 * Initialize the hardware.
    961961 */
    962962static void
     
    998998}
    999999
    1000 /* 
    1001  * Handle a potential interrupt for the device referred to by DEV_ID. 
     1000/*
     1001 * Handle a potential interrupt for the device referred to by DEV_ID.
    10021002 *
    10031003 * I don't like the cut-n-paste job here either between the two routines,
     
    11481148        testb = chip->mixer_status_mask;
    11491149
    1150         /* 
    1151          * Loop around waiting for the mixer to become ready. 
     1150        /*
     1151         * Loop around waiting for the mixer to become ready.
    11521152         */
    11531153        while (timeout-- > 0) {
     
    11591159}
    11601160
    1161 /* 
     1161/*
    11621162 * Initial register values to be written to the AC97 mixer.
    11631163 * While most of these are identical to the reset values, we do this
     
    11881188        { AC97_REC_GAIN,        0x0B0B },
    11891189        { AC97_GENERAL_PURPOSE, 0x0000 },
    1190         { AC97_3D_CONTROL,      0x8000 }, 
     1190        { AC97_3D_CONTROL,      0x8000 },
    11911191        { AC97_VENDOR_ID1,      0x8384 },
    11921192        { AC97_VENDOR_ID2,      0x7609 },
     
    12181218}
    12191219
    1220 /* 
     1220/*
    12211221 */
    12221222static void
     
    13311331}
    13321332
    1333 /* 
     1333/*
    13341334 * See if the signature left by the NM256 BIOS is intact; if so, we use
    13351335 * the associated address as the end of our audio buffer in the video
     
    14991499        chip->streams[SNDRV_PCM_STREAM_CAPTURE].bufsize = capture_bufsize * 1024;
    15001500
    1501         /* 
     1501        /*
    15021502         * The NM256 has two memory ports.  The first port is nothing
    15031503         * more than a chunk of video RAM, which is used as the I/O ring
  • GPL/branches/uniaud32-2.1.x/alsa-kernel/pci/via82xx.c

    r569 r594  
    4444 *
    4545 * Sep. 26, 2005        Karsten Wiese <annabellesgarden@yahoo.de>
    46  *      - Optimize position calculation for the 823x chips. 
     46 *      - Optimize position calculation for the 823x chips.
    4747 */
    4848
     
    111111
    112112/* just for backward compatibility */
    113 static int enable;
     113//static int enable;
    114114module_param(enable, bool, 0444);
    115115
     
    513513        return inl(VIAREG(chip, AC97));
    514514}
    515  
     515
    516516static inline void snd_via82xx_codec_xwrite(struct via82xx *chip, unsigned int val)
    517517{
    518518        outl(val, VIAREG(chip, AC97));
    519519}
    520  
     520
    521521static int snd_via82xx_codec_ready(struct via82xx *chip, int secondary)
    522522{
     
    533533        return -EIO;
    534534}
    535  
     535
    536536static int snd_via82xx_codec_valid(struct via82xx *chip, int secondary)
    537537{
     
    550550        return -EIO;
    551551}
    552  
     552
    553553static void snd_via82xx_codec_wait(struct snd_ac97 *ac97)
    554554{
     
    648648                        /*
    649649                         * Update hwptr_done based on 'period elapsed'
    650                          * interrupts. We'll use it, when the chip returns 0 
     650                         * interrupts. We'll use it, when the chip returns 0
    651651                         * for OFFSET_CURR_COUNT.
    652652                         */
     
    697697                        /*
    698698                         * Update hwptr_done based on 'period elapsed'
    699                          * interrupts. We'll use it, when the chip returns 0 
     699                         * interrupts. We'll use it, when the chip returns 0
    700700                         * for OFFSET_CURR_COUNT.
    701701                         */
     
    877877                status = inb(VIADEV_REG(viadev, OFFSET_STATUS));
    878878
    879         /* An apparent bug in the 8251 is worked around by sending a 
     879        /* An apparent bug in the 8251 is worked around by sending a
    880880         * REG_CTRL_START. */
    881881        if (chip->revision == VIA_REV_8251 && (status & VIA_REG_STAT_EOL))
     
    908908                                }
    909909                }
    910         }                          
     910        }                       
    911911unlock:
    912912        viadev->lastpos = res;
  • GPL/branches/uniaud32-2.1.x/drv32/dispatch.c

    r588 r594  
    105105    //printk("StratIOCtl 0x%x\n", rp->Function);
    106106    #endif
    107     //    printk("cmd: %x, len: %i, pack: %x\n",rp->Function, rp->ioctl.usParmLen, rp->ParmPacket);
     107    //    printk("cmd: %x, len: %i, pack: %x\n",rp->ioctl.bFunction, rp->ioctl.usParmLen, rp->ioctl.pvParm);
    108108    // work with Parm Packet
    109109    if ((rp->ioctl.usParmLen != 0 ||
     
    183183    case IOCTL_OSS32_ATTACH:
    184184        {
     185          dprintf(("OSS32_ATTACH\n"));
    185186            card_id = (ULONG) *linParm;
    186187            // Check if audio init was successful
     
    193194    case IOCTL_OSS32_VERSION:
    194195        {
     196          dprintf(("OSS32_VERSION\n"));
    195197            if (rp->ioctl.usDataLen < sizeof(ULONG))
    196198            {
     
    206208    case IOCTL_OSS32_GET_PCM_NUM:
    207209        {
     210          dprintf(("GET_PCM_NUM\n"));
    208211            if (rp->ioctl.usDataLen < sizeof(ULONG))
    209212            {
     
    219222
    220223    case IOCTL_OSS32_CARDS_NUM:
     224        dprintf(("OSS32_CARDS_NUM\n"));
    221225        if (rp->ioctl.usDataLen < sizeof(ULONG))
    222226        {
     
    231235    case IOCTL_OSS32_PCM_CAPS:
    232236        {
     237          dprintf(("OSS32_PCM_CAPS\n"));
    233238            if (rp->ioctl.usDataLen < sizeof(ULONG))
    234239            {
     
    244249    case IOCTL_OSS32_CARD_INFO:
    245250        {
     251          dprintf(("OSS32_CARD_INFO\n"));
    246252            if (rp->ioctl.usDataLen < sizeof(ULONG))
    247253            {
     
    257263    case IOCTL_OSS32_GET_POWER_STATE:
    258264        {
     265          dprintf(("OSS32_GET_POWER_STATE\n"));
    259266            if (rp->ioctl.usDataLen < sizeof(ULONG))
    260267            {
     
    270277    case IOCTL_OSS32_SET_POWER_STATE:
    271278        {
     279          dprintf(("OSS32_SET_POWER_STATE\n"));
    272280            if (rp->ioctl.usDataLen < sizeof(ULONG))
    273281            {
     
    283291    case IOCTL_OSS32_GET_CNTRLS_NUM:
    284292        {
     293          dprintf(("OSS32_GET_CNTRLS_NUM\n"));
    285294            if (rp->ioctl.usDataLen < sizeof(ULONG))
    286295            {
     
    298307    case IOCTL_OSS32_GET_CNTRLS:
    299308        {
     309          dprintf(("OSS32_GET_CNTRLS\n"));
    300310            if (rp->ioctl.usDataLen < sizeof(ULONG))
    301311            {
     
    311321    case IOCTL_OSS32_CNTRL_INFO:
    312322        {
     323          dprintf(("OSS32_CNTRL_INFO\n"));
    313324
    314325            if (rp->ioctl.usDataLen < sizeof(ULONG))
     
    336347    case IOCTL_OSS32_CNTRL_GET:
    337348        {
     349          dprintf(("OSS32_CNTRL_GET\n"));
    338350            if (rp->ioctl.usDataLen < sizeof(ULONG))
    339351            {
     
    360372    case IOCTL_OSS32_CNTRL_PUT:
    361373        {
     374          dprintf(("OSS32_CNTRL_PUT\n"));
    362375
    363376            if (rp->ioctl.usDataLen < sizeof(ULONG)) {
     
    383396    case IOCTL_OSS32_SET_PCM:
    384397        {
     398          dprintf(("OSS32_SET_PCM\n"));
    385399
    386400            if (rp->ioctl.usParmLen < sizeof(ULONG))
     
    399413    case IOCTL_OSS32_CNTRL_WAIT:
    400414        {
     415          dprintf(("OSS32_CNTRL_WAIT\n"));
    401416            if (rp->ioctl.usDataLen < sizeof(ULONG))
    402417            {
     
    414429            pData = (ULONG *)linData;
    415430            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
     431
     432          dprintf(("OSS32_PCM_OPEN\n"));
    416433            // close all pcms from uniaud16 first
    417434            pcm->ret = OSS32_WaveOpen(pcm->deviceid, pcm->streamtype, pData,  pcm->pcm, rp->ioctl.usSysFileNum);
     
    422439        {
    423440            ULONG alsa_id = *((ULONG *)linParm);
     441
     442          dprintf(("OSS32_PCM_CLOSE\n"));
    424443            OSS32_WaveClose(alsa_id);
    425444        }
     
    429448            char *pData1 = (char *)linData;
    430449            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
     450
     451          dprintf(("OSS32_PCM_READ\n"));
    431452            pcm->ret = UniaudIoctlPCMRead(pcm->deviceid, pData1, pcm->size);
    432453        }
     
    436457            char *pData1 = (char *)linData;
    437458            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
     459
     460          dprintf(("OSS32_PCM_WRITE\n"));
    438461            pcm->ret = UniaudIoctlPCMWrite(pcm->deviceid, pData1, pcm->size);
    439462        }
     
    442465        {
    443466            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
     467
     468          dprintf(("OSS32_PCM_PAUSE\n"));
    444469            pcm->ret = UniaudIoctlPCMResume(pcm->deviceid, 0);
    445470        }
     
    448473        {
    449474            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
     475
     476          dprintf(("OSS32_PCM_RESUME\n"));
    450477            pcm->ret = UniaudIoctlPCMResume(pcm->deviceid, 1);
    451478        }
     
    454481        {
    455482            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
     483
     484          dprintf(("OSS32_PCM_START\n"));
    456485            pcm->ret = UniaudIoctlPCMStart(pcm->deviceid);
    457486        }
     
    460489        {
    461490            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
     491
     492          dprintf(("OSS32_PCM_DROP\n"));
    462493            pcm->ret = UniaudIoctlPCMDrop(pcm->deviceid);
    463494        }
     
    469500            void *pData1 = (void *)linData;
    470501            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
     502
     503          dprintf(("OSS32_PCM_STATUS\n"));
    471504            pcm->ret = UniaudIoctlPCMStatus(pcm->deviceid, pData1);
    472505        }
     
    476509            void *pData1 = (void *)linData;
    477510            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
     511
     512          dprintf(("OSS32_PCM_REFINEHWPARAMS\n"));
    478513            pcm->ret = UniaudIoctlHWRefine(pcm->deviceid, pData1);
    479514        }
     
    483518            void *pData1 = (void *)linData;
    484519            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
     520
     521          dprintf(("OSS32_PCM_SETHWPARAMS\n"));
    485522            pcm->ret = UniaudIoctlHWParamSet(pcm->deviceid, pData1);
    486523        }
     
    490527            void *pData1 = (void *)linData;
    491528            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
     529
     530          dprintf(("OSS32_PCM_SETSWPARAMS\n"));
    492531            pcm->ret = UniaudIoctlSWParamSet(pcm->deviceid, pData1);
    493532        }
     
    496535        {
    497536            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
     537
     538          dprintf(("OSS32_PCM_PREPARE\n"));
    498539            pcm->ret = UniaudIoctlPCMPrepare(pcm->deviceid);
    499540        }
     
    503544        {
    504545            int unlock  = (int)*linParm;
     546
     547          dprintf(("OSS32_PCM_CLOSE_ALL\n"));
    505548            if (unlock)
    506549                unlock_all = 1;
     
    510553        break;
    511554    case IOCTL_OSS32_PCM_CLOSE_16:
     555          dprintf(("OSS32_PCM_CLOSE_16\n"));
    512556        OSS32_CloseUNI16();
    513557        break;
     
    515559        {
    516560            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
     561
     562          dprintf(("OSS32_PCM_WAIT_INT\n"));
    517563            pcm->ret =  WaitForPCMInterrupt((void*)pcm->deviceid, pcm->streamtype);
    518564        }
  • GPL/branches/uniaud32-2.1.x/drv32/parse.c

    r593 r594  
    240240        if(*pszOption == '2') {
    241241            MAGIC_COMM_PORT = 0x2f8;
     242        }
     243        if(*pszOption == '4') {
     244            MAGIC_COMM_PORT = 0x4000;
    242245        }
    243246        break;
  • GPL/branches/uniaud32-2.1.x/include/dbgos2.h

    r550 r594  
    5555#define dprintf2(a)     if(DebugLevel > 1) printk a
    5656#define dprintf3(a)     if(DebugLevel > 2) printk a
    57 #define DebugInt3()     ; //_asm int 3
     57#define DebugInt3()     
    5858//#define DebInt3()     _asm int 3;
    5959#else
  • GPL/branches/uniaud32-2.1.x/include/linux/types.h

    r588 r594  
    22#define _LINUX_TYPES_H
    33
    4 #pragma off (unreferenced)
     4//#pragma off (unreferenced)
    55
    66#include <linux/posix_types.h>
  • GPL/branches/uniaud32-2.1.x/lib32/fminstrload.c

    r519 r594  
    103103
    104104    if(pHandle == NULL || pHandle->magic != MAGIC_MIDI_ALSA32) {
    105         DebugInt3();
     105        //DebugInt3();
    106106        return OSSERR_INVALID_STREAMID;
    107107    }
  • GPL/branches/uniaud32-2.1.x/lib32/ioctl.c

    r550 r594  
    226226        WAVE_CAPS *wc;
    227227        int i;
    228         int sel_pcm = -1;
     228        //int sel_pcm = -1;
    229229        int max_ch = 0;
    230230
     
    439439{
    440440        mixerhandle *pHandle = NULL;
    441         int              ret, i, j;
     441        int ret;
     442        //int i, j;
    442443
    443444        if(alsa_fops == NULL) {
     
    492493{
    493494        mixerhandle *pHandle = NULL;
    494         int              ret, i, j;
     495        int              ret;
     496        //int i, j;
    495497
    496498        if(alsa_fops == NULL) {
     
    545547{
    546548        mixerhandle *pHandle = NULL;
    547         int              ret, i, j;
     549        int              ret;
     550        //int i, j;
    548551
    549552        //dprintf(("GetUniaudCardInfo"));
     
    600603{
    601604        mixerhandle *pHandle = NULL;
    602         int              ret, i, j, sz;
     605        int              ret, sz;
     606        //int i, j;
    603607
    604608        //dprintf(("GetUniaudControlNum"));
     
    667671{
    668672        mixerhandle *pHandle = NULL;
    669         int              ret, i, j, sz;
     673        int              ret, sz;
     674        //int i, j;
    670675
    671676        //dprintf(("GetUniaudControls"));
     
    756761int GetUniaudControlInfo(ULONG deviceid, ULONG id, void *info)
    757762{
    758         struct snd_ctl_elem_value *pElem = NULL;
     763        //struct snd_ctl_elem_value *pElem = NULL;
    759764        struct snd_ctl_elem_info  *pElemInfo = NULL;
    760765        mixerhandle *pHandle = NULL;
    761         int              ret, i, j, sz;
     766        int              ret, sz;
     767        //int i, j;
    762768
    763769        //dprintf(("GetUniaudControlInfo"));
     
    820826        //struct snd_ctl_elem_info  *pElemInfo = NULL;
    821827        mixerhandle *pHandle = NULL;
    822         int              ret, i, j, sz;
     828        int              ret, sz;
     829        //int i, j;
    823830
    824831        if(alsa_fops == NULL) {
     
    878885        //struct snd_ctl_elem_info  *pElemInfo = NULL;
    879886        mixerhandle *pHandle = NULL;
    880         int              ret, i, j, sz;
     887        int              ret, sz;
     888        //int i, j;
    881889
    882890        if(alsa_fops == NULL) {
  • GPL/branches/uniaud32-2.1.x/lib32/misc.c

    r569 r594  
    205205}
    206206//******************************************************************************
    207 static struct notifier_block *reboot_notify_list = NULL;
     207//static struct notifier_block *reboot_notify_list = NULL;
    208208// No need to implement this right now. The ESS Maestro 3 driver uses it
    209209// to call pci_unregister_driver, which is always called from the shutdown
  • GPL/branches/uniaud32-2.1.x/lib32/sound.c

    r536 r594  
    329329        ULONG                            format_mask;
    330330        struct snd_mask                   *mask;
    331         int max_ch;
     331        //int max_ch;
    332332
    333333        dprintf(("OSS32_QueryDevCaps"));
     
    773773        ULONG                           periodbytes, minperiodbytes, maxperiodbytes;
    774774        BOOL                            fTryAgain = FALSE;
    775         ULONG ulMinRate, ulMaxRate;
     775        //ULONG ulMinRate, ulMaxRate;
    776776
    777777        if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
     
    10631063        soundhandle        *pHandle = (soundhandle *)streamid;
    10641064        struct snd_pcm_status    status;
    1065         int                             iRet, align, iRet1;
     1065        int                             iRet;
     1066        //int align, iRet1;
    10661067        LONG                            ulTransferred;
    1067         ULONG                           ulPosition, ulI, ulJ, ulSize;
    1068         char                            *buf;
     1068        //ULONG                         ulPosition, ulI, ulJ;
     1069        ULONG ulSize;
     1070        //char                          *buf;
    10691071
    10701072//        return OSSERR_SUCCESS;
     
    11091111                        return OSSERR_BUFFER_FULL;
    11101112                }
     1113               
     1114                //dprintf(("WaveAddBuffer: ReqSize=%x Size=%x", ulReqSize, ulSize));
    11111115
    11121116                //rprintf(("AddBuffer: state=%x avail=%x ReqSize=%x", status.state, status.avail, ulReqSize));
  • GPL/branches/uniaud32-2.1.x/lib32/soundmidi.c

    r519 r594  
    287287{
    288288    midihandle  *pHandle = (midihandle *)streamid;
    289     int          ret;
     289    //int          ret;
    290290    LONG         transferred;
    291291    struct snd_seq_event fmevent;
  • GPL/branches/uniaud32-2.1.x/lib32/soundmixer.c

    r531 r594  
    346346{
    347347        mixerhandle *pHandle = (mixerhandle *)streamid;
    348         int              ret;
     348        //int            ret;
    349349
    350350        if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
     
    364364        struct snd_ctl_elem_value *pElem = NULL;
    365365        struct snd_ctl_elem_info  *pElemInfo;
    366         int                               ret, idx, lVol, rVol = 0, idxMute, cnt;
     366        int                               ret, idx, lVol, rVol = 0, idxMute;
     367        //int cnt;
    367368
    368369        //dprintf(("OSS32_MixSetVolume line=%d\n", line));
     
    718719{
    719720        mixerhandle *pHandle = (mixerhandle *)streamid;
    720         int              ret;
     721        //int            ret;
    721722
    722723        if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
     
    813814{
    814815        mixerhandle *pHandle = NULL;
    815         int              ret, i, j;
     816        int              ret;
     817        //int i, j;
    816818
    817819        if(alsa_fops == NULL)
     
    870872{
    871873        mixerhandle *pHandle = NULL;
    872         int              ret, i, j;
     874        int              ret;
     875        //int i, j;
    873876
    874877        if(alsa_fops == NULL) {
  • GPL/branches/uniaud32-2.1.x/tools/header.mif

    r593 r594  
    4545
    4646!if "$(DEBUG)" == "1"
    47 CFLAGS = -dDEBUG -bt=os2v2 -e60 -hc -5r -omlinear -s -w4 -ze -zdp -zl -zq -nt=CODE32 -zff -zgf -ei
     47CFLAGS = -dDEBUG -bt=os2v2 -hc -5r -omlinear -s -wx -ze -zdp -zl -zq -nt=CODE32 -zff -zgf -ei
    4848CPPFLAGS= -xd
    4949ASFLAGS = -D:DEBUG -Mb -Li -Sv:M510
    5050!else
    51 CFLAGS = -bt=os2v2 -e60 -5r -omlinear -s -w4 -ze -zdp -zl -zq -nt=CODE32 -zff -zgf -ei
     51CFLAGS = -bt=os2v2 -5r -omlinear -s -wx -ze -zdp -zl -zq -nt=CODE32 -zff -zgf -ei
    5252CPPFLAGS= -xd
    5353ASFLAGS = -Mb -Li -Sv:M510
Note: See TracChangeset for help on using the changeset viewer.