Changeset 587


Ignore:
Timestamp:
Jun 9, 2016, 10:38:13 PM (9 years ago)
Author:
David Azarewicz
Message:

Rearrange directory structure
rework makefiles
cleanup files

Location:
GPL/trunk
Files:
99 added
141 deleted
50 edited

Legend:

Unmodified
Added
Removed

  • GPL/trunk/!clean.cmd

    r86 r587  
    1 @echo off
    2 SET KEE=0
    3 wmake -ms -f makefile.os2 DEBUG=1 clean
    4 SET KEE=1
    5 wmake -ms -f makefile.os2 DEBUG=1 clean
    6 SET KEE=
     1wmake clean
    72

  • GPL/trunk/alsa-kernel/core/control.c

    r528 r587  
    2929#include <sound/info.h>
    3030#include <sound/control.h>
     31#ifdef TARGET_OS2
    3132#include <proto.h>
     33#endif
    3234
    3335/* max number of user-defined controls */
    … …  
    196198        if (snd_BUG_ON(!control || !control->count))
    197199                return NULL;
    198 
    199200        kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL);
    200 
    201201        if (kctl == NULL) {
    202202                snd_printk(KERN_ERR "Cannot allocate control instance\n");

  • GPL/trunk/alsa-kernel/core/info.c

    r479 r587  
    649649        if (!strcmp(card->id, card->proc_root->name))
    650650                return 0;
     651               
    651652#ifndef TARGET_OS2
    652653        p = proc_symlink(card->id, snd_proc_root, card->proc_root->name);

  • GPL/trunk/alsa-kernel/core/init.c

    r479 r587  
    6060static int module_slot_match(struct module *module, int idx)
    6161{
     62        int match = 1;
    6263#ifndef TARGET_OS2
    6364#ifdef MODULE
    6465        const char *s1, *s2;
    6566
    66         int match = 1;
    6767        if (!module || !module->name || !slots[idx])
    6868                return 0;
     69               
    6970        s1 = module->name;
    7071        s2 = slots[idx];
    … …  
    8889                        break;
    8990        }
    90 
    9191#endif /* MODULE */
    92 #else
    93         int match = 1;
    9492#endif
    9593        return match;

  • GPL/trunk/alsa-kernel/core/isadma.c

    r305 r587  
    3939 * Programs an ISA DMA transfer for the given buffer.
    4040 */
    41  
    4241void snd_dma_program(unsigned long dma,
    4342                     unsigned long addr, unsigned int size,

  • GPL/trunk/alsa-kernel/core/misc.c

    r464 r587  
    128128EXPORT_SYMBOL(snd_pci_quirk_lookup);
    129129#endif
    130 
    131 //#include "misc.inc"

  • GPL/trunk/alsa-kernel/core/pcm_compat.c

    r479 r587  
    2222
    2323#include <linux/compat.h>
    24 #include <proto.h>
    2524
    2625static int snd_pcm_ioctl_delay_compat(struct snd_pcm_substream *substream,

  • GPL/trunk/alsa-kernel/core/pcm_lib.c

    r549 r587  
    230230#define hw_ptr_error(substream, fmt, ...) ;
    231231#endif
     232
    232233static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
    233234{

  • GPL/trunk/alsa-kernel/core/pcm_misc.c

    r399 r587  
    1919 *
    2020 */
    21  
     21
    2222#include <linux/time.h>
    2323#include <sound/core.h>
    … …  
    446446                        break;
    447447                }
    448 
    449448        }
    450449        return 0;

  • GPL/trunk/alsa-kernel/core/sgbuf.c

    r518 r587  
    2222#include <sound/core.h>
    2323#endif
    24 #include <sound/config.h>
     24#include <config.h>
    2525#include <linux/slab.h>
    2626#include <linux/mm.h>

  • GPL/trunk/alsa-kernel/core/sound_oss.c

    r479 r587  
    2020 */
    2121#ifdef TARGET_OS2
    22 #include <sound/config.h>
     22#include <config.h>
    2323#endif
    2424

  • GPL/trunk/alsa-kernel/drivers/dummy.c

    r410 r587  
    2626#include <linux/time.h>
    2727#include <linux/wait.h>
    28 #include <linux/moduleparam.h>
     28#include <linux/hrtimer.h>
     29#include <linux/math64.h>
     30#include <linux/module.h>
    2931#include <sound/core.h>
    3032#include <sound/control.h>
    … …  
    3234#include <sound/pcm.h>
    3335#include <sound/rawmidi.h>
     36#include <sound/info.h>
    3437#include <sound/initval.h>
    3538
    … …  
    4043
    4144#define MAX_PCM_DEVICES         4
    42 #define MAX_PCM_SUBSTREAMS      16
     45#define MAX_PCM_SUBSTREAMS      128
    4346#define MAX_MIDI_DEVICES        2
    4447
    45 #if 0 /* emu10k1 emulation */
    46 #define MAX_BUFFER_SIZE         (128 * 1024)
     48/* defaults */
     49#define MAX_BUFFER_SIZE         (64*1024)
     50#define MIN_PERIOD_SIZE         64
     51#define MAX_PERIOD_SIZE         MAX_BUFFER_SIZE
     52#define USE_FORMATS             (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE)
     53#define USE_RATE                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000
     54#define USE_RATE_MIN            5500
     55#define USE_RATE_MAX            48000
     56#define USE_CHANNELS_MIN        1
     57#define USE_CHANNELS_MAX        2
     58#define USE_PERIODS_MIN         1
     59#define USE_PERIODS_MAX         1024
     60
     61static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
     62static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
     63static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0};
     64static char *model[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = NULL};
     65static int pcm_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
     66static int pcm_substreams[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 8};
     67//static int midi_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
     68#ifdef CONFIG_HIGH_RES_TIMERS
     69static bool hrtimer = 1;
     70#endif
     71static bool fake_buffer = 1;
     72
     73module_param_array(index, int, NULL, 0444);
     74MODULE_PARM_DESC(index, "Index value for dummy soundcard.");
     75module_param_array(id, charp, NULL, 0444);
     76MODULE_PARM_DESC(id, "ID string for dummy soundcard.");
     77module_param_array(enable, bool, NULL, 0444);
     78MODULE_PARM_DESC(enable, "Enable this dummy soundcard.");
     79module_param_array(model, charp, NULL, 0444);
     80MODULE_PARM_DESC(model, "Soundcard model.");
     81module_param_array(pcm_devs, int, NULL, 0444);
     82MODULE_PARM_DESC(pcm_devs, "PCM devices # (0-4) for dummy driver.");
     83module_param_array(pcm_substreams, int, NULL, 0444);
     84MODULE_PARM_DESC(pcm_substreams, "PCM substreams # (1-128) for dummy driver.");
     85//module_param_array(midi_devs, int, NULL, 0444);
     86//MODULE_PARM_DESC(midi_devs, "MIDI devices # (0-2) for dummy driver.");
     87module_param(fake_buffer, bool, 0444);
     88MODULE_PARM_DESC(fake_buffer, "Fake buffer allocations.");
     89#ifdef CONFIG_HIGH_RES_TIMERS
     90module_param(hrtimer, bool, 0644);
     91MODULE_PARM_DESC(hrtimer, "Use hrtimer as the timer source.");
     92#endif
     93
     94static struct platform_device *devices[SNDRV_CARDS];
     95
     96#define MIXER_ADDR_MASTER       0
     97#define MIXER_ADDR_LINE         1
     98#define MIXER_ADDR_MIC          2
     99#define MIXER_ADDR_SYNTH        3
     100#define MIXER_ADDR_CD           4
     101#define MIXER_ADDR_LAST         4
     102
     103struct dummy_timer_ops {
     104        int (*create)(struct snd_pcm_substream *);
     105        void (*free)(struct snd_pcm_substream *);
     106        int (*prepare)(struct snd_pcm_substream *);
     107        int (*start)(struct snd_pcm_substream *);
     108        int (*stop)(struct snd_pcm_substream *);
     109        snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *);
     110};
     111
     112struct dummy_model {
     113        const char *name;
     114        int (*playback_constraints)(struct snd_pcm_runtime *runtime);
     115        int (*capture_constraints)(struct snd_pcm_runtime *runtime);
     116        u64 formats;
     117        size_t buffer_bytes_max;
     118        size_t period_bytes_min;
     119        size_t period_bytes_max;
     120        unsigned int periods_min;
     121        unsigned int periods_max;
     122        unsigned int rates;
     123        unsigned int rate_min;
     124        unsigned int rate_max;
     125        unsigned int channels_min;
     126        unsigned int channels_max;
     127};
     128
     129struct snd_dummy {
     130        struct snd_card *card;
     131        struct dummy_model *model;
     132        struct snd_pcm *pcm;
     133        struct snd_pcm_hardware pcm_hw;
     134        spinlock_t mixer_lock;
     135        int mixer_volume[MIXER_ADDR_LAST+1][2];
     136        int capture_source[MIXER_ADDR_LAST+1][2];
     137        const struct dummy_timer_ops *timer_ops;
     138};
     139
     140/*
     141 * card models
     142 */
     143
    47144static int emu10k1_playback_constraints(struct snd_pcm_runtime *runtime)
    48145{
    … …  
    56153        return 0;
    57154}
    58 #define add_playback_constraints emu10k1_playback_constraints
    59 #endif
    60 
    61 #if 0 /* RME9652 emulation */
    62 #define MAX_BUFFER_SIZE         (26 * 64 * 1024)
    63 #define USE_FORMATS             SNDRV_PCM_FMTBIT_S32_LE
    64 #define USE_CHANNELS_MIN        26
    65 #define USE_CHANNELS_MAX        26
    66 #define USE_PERIODS_MIN         2
    67 #define USE_PERIODS_MAX         2
    68 #endif
    69 
    70 #if 0 /* ICE1712 emulation */
    71 #define MAX_BUFFER_SIZE         (256 * 1024)
    72 #define USE_FORMATS             SNDRV_PCM_FMTBIT_S32_LE
    73 #define USE_CHANNELS_MIN        10
    74 #define USE_CHANNELS_MAX        10
    75 #define USE_PERIODS_MIN         1
    76 #define USE_PERIODS_MAX         1024
    77 #endif
    78 
    79 #if 0 /* UDA1341 emulation */
    80 #define MAX_BUFFER_SIZE         (16380)
    81 #define USE_FORMATS             SNDRV_PCM_FMTBIT_S16_LE
    82 #define USE_CHANNELS_MIN        2
    83 #define USE_CHANNELS_MAX        2
    84 #define USE_PERIODS_MIN         2
    85 #define USE_PERIODS_MAX         255
    86 #endif
    87 
    88 #if 0 /* simple AC97 bridge (intel8x0) with 48kHz AC97 only codec */
    89 #define USE_FORMATS             SNDRV_PCM_FMTBIT_S16_LE
    90 #define USE_CHANNELS_MIN        2
    91 #define USE_CHANNELS_MAX        2
    92 #define USE_RATE                SNDRV_PCM_RATE_48000
    93 #define USE_RATE_MIN            48000
    94 #define USE_RATE_MAX            48000
    95 #endif
    96 
    97 #if 0 /* CA0106 */
    98 #define USE_FORMATS             SNDRV_PCM_FMTBIT_S16_LE
    99 #define USE_CHANNELS_MIN        2
    100 #define USE_CHANNELS_MAX        2
    101 #define USE_RATE                (SNDRV_PCM_RATE_48000|SNDRV_PCM_RATE_96000|SNDRV_PCM_RATE_192000)
    102 #define USE_RATE_MIN            48000
    103 #define USE_RATE_MAX            192000
    104 #define MAX_BUFFER_SIZE         ((65536-64)*8)
    105 #define MAX_PERIOD_SIZE         (65536-64)
    106 #define USE_PERIODS_MIN         2
    107 #define USE_PERIODS_MAX         8
    108 #endif
    109 
    110 
    111 /* defaults */
    112 #ifndef MAX_BUFFER_SIZE
    113 #define MAX_BUFFER_SIZE         (64*1024)
    114 #endif
    115 #ifndef MAX_PERIOD_SIZE
    116 #define MAX_PERIOD_SIZE         MAX_BUFFER_SIZE
    117 #endif
    118 #ifndef USE_FORMATS
    119 #define USE_FORMATS             (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE)
    120 #endif
    121 #ifndef USE_RATE
    122 #define USE_RATE                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000
    123 #define USE_RATE_MIN            5500
    124 #define USE_RATE_MAX            48000
    125 #endif
    126 #ifndef USE_CHANNELS_MIN
    127 #define USE_CHANNELS_MIN        1
    128 #endif
    129 #ifndef USE_CHANNELS_MAX
    130 #define USE_CHANNELS_MAX        2
    131 #endif
    132 #ifndef USE_PERIODS_MIN
    133 #define USE_PERIODS_MIN         1
    134 #endif
    135 #ifndef USE_PERIODS_MAX
    136 #define USE_PERIODS_MAX         1024
    137 #endif
    138 #ifndef add_playback_constraints
    139 #define add_playback_constraints(x) 0
    140 #endif
    141 #ifndef add_capture_constraints
    142 #define add_capture_constraints(x) 0
    143 #endif
    144 
    145 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
    146 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
    147 static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0};
    148 static int pcm_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
    149 static int pcm_substreams[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 8};
    150 //static int midi_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
    151 
    152 module_param_array(index, int, NULL, 0444);
    153 MODULE_PARM_DESC(index, "Index value for dummy soundcard.");
    154 module_param_array(id, charp, NULL, 0444);
    155 MODULE_PARM_DESC(id, "ID string for dummy soundcard.");
    156 module_param_array(enable, bool, NULL, 0444);
    157 MODULE_PARM_DESC(enable, "Enable this dummy soundcard.");
    158 module_param_array(pcm_devs, int, NULL, 0444);
    159 MODULE_PARM_DESC(pcm_devs, "PCM devices # (0-4) for dummy driver.");
    160 module_param_array(pcm_substreams, int, NULL, 0444);
    161 MODULE_PARM_DESC(pcm_substreams, "PCM substreams # (1-16) for dummy driver.");
    162 module_param_array(midi_devs, int, NULL, 0444);
    163 MODULE_PARM_DESC(midi_devs, "MIDI devices # (0-2) for dummy driver.");
    164 
    165 static struct platform_device *devices[SNDRV_CARDS];
    166 
    167 #define MIXER_ADDR_MASTER       0
    168 #define MIXER_ADDR_LINE         1
    169 #define MIXER_ADDR_MIC          2
    170 #define MIXER_ADDR_SYNTH        3
    171 #define MIXER_ADDR_CD           4
    172 #define MIXER_ADDR_LAST         4
    173 
    174 struct snd_dummy {
    175         struct snd_card *card;
    176         struct snd_pcm *pcm;
    177         spinlock_t mixer_lock;
    178         int mixer_volume[MIXER_ADDR_LAST+1][2];
    179         int capture_source[MIXER_ADDR_LAST+1][2];
    180 };
    181 
    182 struct snd_dummy_pcm {
    183         struct snd_dummy *dummy;
     155
     156struct dummy_model model_emu10k1 = {
     157        .name = "emu10k1",
     158        .playback_constraints = emu10k1_playback_constraints,
     159        .buffer_bytes_max = 128 * 1024,
     160};
     161
     162struct dummy_model model_rme9652 = {
     163        .name = "rme9652",
     164        .buffer_bytes_max = 26 * 64 * 1024,
     165        .formats = SNDRV_PCM_FMTBIT_S32_LE,
     166        .channels_min = 26,
     167        .channels_max = 26,
     168        .periods_min = 2,
     169        .periods_max = 2,
     170};
     171
     172struct dummy_model model_ice1712 = {
     173        .name = "ice1712",
     174        .buffer_bytes_max = 256 * 1024,
     175        .formats = SNDRV_PCM_FMTBIT_S32_LE,
     176        .channels_min = 10,
     177        .channels_max = 10,
     178        .periods_min = 1,
     179        .periods_max = 1024,
     180};
     181
     182struct dummy_model model_uda1341 = {
     183        .name = "uda1341",
     184        .buffer_bytes_max = 16380,
     185        .formats = SNDRV_PCM_FMTBIT_S16_LE,
     186        .channels_min = 2,
     187        .channels_max = 2,
     188        .periods_min = 2,
     189        .periods_max = 255,
     190};
     191
     192struct dummy_model model_ac97 = {
     193        .name = "ac97",
     194        .formats = SNDRV_PCM_FMTBIT_S16_LE,
     195        .channels_min = 2,
     196        .channels_max = 2,
     197        .rates = SNDRV_PCM_RATE_48000,
     198        .rate_min = 48000,
     199        .rate_max = 48000,
     200};
     201
     202struct dummy_model model_ca0106 = {
     203        .name = "ca0106",
     204        .formats = SNDRV_PCM_FMTBIT_S16_LE,
     205        .buffer_bytes_max = ((65536-64)*8),
     206        .period_bytes_max = (65536-64),
     207        .periods_min = 2,
     208        .periods_max = 8,
     209        .channels_min = 2,
     210        .channels_max = 2,
     211        .rates = SNDRV_PCM_RATE_48000|SNDRV_PCM_RATE_96000|SNDRV_PCM_RATE_192000,
     212        .rate_min = 48000,
     213        .rate_max = 192000,
     214};
     215
     216struct dummy_model *dummy_models[] = {
     217        &model_emu10k1,
     218        &model_rme9652,
     219        &model_ice1712,
     220        &model_uda1341,
     221        &model_ac97,
     222        &model_ca0106,
     223        NULL
     224};
     225
     226/*
     227 * system timer interface
     228 */
     229
     230struct dummy_systimer_pcm {
    184231        spinlock_t lock;
    185232        struct timer_list timer;
    186         unsigned int pcm_buffer_size;
    187         unsigned int pcm_period_size;
    188         unsigned int pcm_bps;           /* bytes per second */
    189         unsigned int pcm_hz;            /* HZ */
    190         unsigned int pcm_irq_pos;       /* IRQ position */
    191         unsigned int pcm_buf_pos;       /* position in buffer */
     233        unsigned long base_time;
     234        unsigned int frac_pos;  /* fractional sample position (based HZ) */
     235        unsigned int frac_period_rest;
     236        unsigned int frac_buffer_size;  /* buffer_size * HZ */
     237        unsigned int frac_period_size;  /* period_size * HZ */
     238        unsigned int rate;
     239        int elapsed;
    192240        struct snd_pcm_substream *substream;
    193241};
    194242
    195 
    196 static inline void snd_card_dummy_pcm_timer_start(struct snd_dummy_pcm *dpcm)
    197 {
    198         dpcm->timer.expires = 1 + jiffies;
     243static void dummy_systimer_rearm(struct dummy_systimer_pcm *dpcm)
     244{
     245        dpcm->timer.expires = jiffies +
     246                (dpcm->frac_period_rest + dpcm->rate - 1) / dpcm->rate;
    199247        add_timer(&dpcm->timer);
    200248}
    201249
    202 static inline void snd_card_dummy_pcm_timer_stop(struct snd_dummy_pcm *dpcm)
    203 {
     250static void dummy_systimer_update(struct dummy_systimer_pcm *dpcm)
     251{
     252        unsigned long delta;
     253
     254        delta = jiffies - dpcm->base_time;
     255        if (!delta)
     256                return;
     257        dpcm->base_time += delta;
     258        delta *= dpcm->rate;
     259        dpcm->frac_pos += delta;
     260        while (dpcm->frac_pos >= dpcm->frac_buffer_size)
     261                dpcm->frac_pos -= dpcm->frac_buffer_size;
     262        while (dpcm->frac_period_rest <= delta) {
     263                dpcm->elapsed++;
     264                dpcm->frac_period_rest += dpcm->frac_period_size;
     265        }
     266        dpcm->frac_period_rest -= delta;
     267}
     268
     269static int dummy_systimer_start(struct snd_pcm_substream *substream)
     270{
     271        struct dummy_systimer_pcm *dpcm = substream->runtime->private_data;
     272        spin_lock(&dpcm->lock);
     273        dpcm->base_time = jiffies;
     274        dummy_systimer_rearm(dpcm);
     275        spin_unlock(&dpcm->lock);
     276        return 0;
     277}
     278
     279static int dummy_systimer_stop(struct snd_pcm_substream *substream)
     280{
     281        struct dummy_systimer_pcm *dpcm = substream->runtime->private_data;
     282        spin_lock(&dpcm->lock);
    204283        del_timer(&dpcm->timer);
    205 }
    206 
    207 static int snd_card_dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
     284        spin_unlock(&dpcm->lock);
     285        return 0;
     286}
     287
     288static int dummy_systimer_prepare(struct snd_pcm_substream *substream)
    208289{
    209290        struct snd_pcm_runtime *runtime = substream->runtime;
    210         struct snd_dummy_pcm *dpcm = runtime->private_data;
    211         int err = 0;
     291        struct dummy_systimer_pcm *dpcm = runtime->private_data;
     292
     293        dpcm->frac_pos = 0;
     294        dpcm->rate = runtime->rate;
     295        dpcm->frac_buffer_size = runtime->buffer_size * HZ;
     296        dpcm->frac_period_size = runtime->period_size * HZ;
     297        dpcm->frac_period_rest = dpcm->frac_period_size;
     298        dpcm->elapsed = 0;
     299
     300        return 0;
     301}
     302
     303static void dummy_systimer_callback(unsigned long data)
     304{
     305        struct dummy_systimer_pcm *dpcm = (struct dummy_systimer_pcm *)data;
     306        unsigned long flags;
     307        int elapsed = 0;
     308       
     309        spin_lock_irqsave(&dpcm->lock, flags);
     310        dummy_systimer_update(dpcm);
     311        dummy_systimer_rearm(dpcm);
     312        elapsed = dpcm->elapsed;
     313        dpcm->elapsed = 0;
     314        spin_unlock_irqrestore(&dpcm->lock, flags);
     315        if (elapsed)
     316                snd_pcm_period_elapsed(dpcm->substream);
     317}
     318
     319static snd_pcm_uframes_t
     320dummy_systimer_pointer(struct snd_pcm_substream *substream)
     321{
     322        struct dummy_systimer_pcm *dpcm = substream->runtime->private_data;
     323        snd_pcm_uframes_t pos;
    212324
    213325        spin_lock(&dpcm->lock);
     326        dummy_systimer_update(dpcm);
     327        pos = dpcm->frac_pos / HZ;
     328        spin_unlock(&dpcm->lock);
     329        return pos;
     330}
     331
     332static int dummy_systimer_create(struct snd_pcm_substream *substream)
     333{
     334        struct dummy_systimer_pcm *dpcm;
     335
     336        dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
     337        if (!dpcm)
     338                return -ENOMEM;
     339        substream->runtime->private_data = dpcm;
     340        init_timer(&dpcm->timer);
     341        dpcm->timer.data = (unsigned long) dpcm;
     342        dpcm->timer.function = dummy_systimer_callback;
     343        spin_lock_init(&dpcm->lock);
     344        dpcm->substream = substream;
     345        return 0;
     346}
     347
     348static void dummy_systimer_free(struct snd_pcm_substream *substream)
     349{
     350        kfree(substream->runtime->private_data);
     351}
     352
     353static struct dummy_timer_ops dummy_systimer_ops = {
     354        .create =       dummy_systimer_create,
     355        .free =         dummy_systimer_free,
     356        .prepare =      dummy_systimer_prepare,
     357        .start =        dummy_systimer_start,
     358        .stop =         dummy_systimer_stop,
     359        .pointer =      dummy_systimer_pointer,
     360};
     361
     362#ifdef CONFIG_HIGH_RES_TIMERS
     363/*
     364 * hrtimer interface
     365 */
     366
     367struct dummy_hrtimer_pcm {
     368        ktime_t base_time;
     369        ktime_t period_time;
     370        atomic_t running;
     371        struct hrtimer timer;
     372        struct tasklet_struct tasklet;
     373        struct snd_pcm_substream *substream;
     374};
     375
     376static void dummy_hrtimer_pcm_elapsed(unsigned long priv)
     377{
     378        struct dummy_hrtimer_pcm *dpcm = (struct dummy_hrtimer_pcm *)priv;
     379        if (atomic_read(&dpcm->running))
     380                snd_pcm_period_elapsed(dpcm->substream);
     381}
     382
     383static enum hrtimer_restart dummy_hrtimer_callback(struct hrtimer *timer)
     384{
     385        struct dummy_hrtimer_pcm *dpcm;
     386
     387        dpcm = container_of(timer, struct dummy_hrtimer_pcm, timer);
     388        if (!atomic_read(&dpcm->running))
     389                return HRTIMER_NORESTART;
     390        tasklet_schedule(&dpcm->tasklet);
     391        hrtimer_forward_now(timer, dpcm->period_time);
     392        return HRTIMER_RESTART;
     393}
     394
     395static int dummy_hrtimer_start(struct snd_pcm_substream *substream)
     396{
     397        struct dummy_hrtimer_pcm *dpcm = substream->runtime->private_data;
     398
     399        dpcm->base_time = hrtimer_cb_get_time(&dpcm->timer);
     400        hrtimer_start(&dpcm->timer, dpcm->period_time, HRTIMER_MODE_REL);
     401        atomic_set(&dpcm->running, 1);
     402        return 0;
     403}
     404
     405static int dummy_hrtimer_stop(struct snd_pcm_substream *substream)
     406{
     407        struct dummy_hrtimer_pcm *dpcm = substream->runtime->private_data;
     408
     409        atomic_set(&dpcm->running, 0);
     410        hrtimer_cancel(&dpcm->timer);
     411        return 0;
     412}
     413
     414static inline void dummy_hrtimer_sync(struct dummy_hrtimer_pcm *dpcm)
     415{
     416        tasklet_kill(&dpcm->tasklet);
     417}
     418
     419static snd_pcm_uframes_t
     420dummy_hrtimer_pointer(struct snd_pcm_substream *substream)
     421{
     422        struct snd_pcm_runtime *runtime = substream->runtime;
     423        struct dummy_hrtimer_pcm *dpcm = runtime->private_data;
     424        u64 delta;
     425        u32 pos;
     426
     427        delta = ktime_us_delta(hrtimer_cb_get_time(&dpcm->timer),
     428                               dpcm->base_time);
     429        delta = div_u64(delta * runtime->rate + 999999, 1000000);
     430        div_u64_rem(delta, runtime->buffer_size, &pos);
     431        return pos;
     432}
     433
     434static int dummy_hrtimer_prepare(struct snd_pcm_substream *substream)
     435{
     436        struct snd_pcm_runtime *runtime = substream->runtime;
     437        struct dummy_hrtimer_pcm *dpcm = runtime->private_data;
     438        unsigned int period, rate;
     439        long sec;
     440        unsigned long nsecs;
     441
     442        dummy_hrtimer_sync(dpcm);
     443        period = runtime->period_size;
     444        rate = runtime->rate;
     445        sec = period / rate;
     446        period %= rate;
     447        nsecs = div_u64((u64)period * 1000000000UL + rate - 1, rate);
     448        dpcm->period_time = ktime_set(sec, nsecs);
     449
     450        return 0;
     451}
     452
     453static int dummy_hrtimer_create(struct snd_pcm_substream *substream)
     454{
     455        struct dummy_hrtimer_pcm *dpcm;
     456
     457        dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
     458        if (!dpcm)
     459                return -ENOMEM;
     460        substream->runtime->private_data = dpcm;
     461        hrtimer_init(&dpcm->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
     462        dpcm->timer.function = dummy_hrtimer_callback;
     463        dpcm->substream = substream;
     464        atomic_set(&dpcm->running, 0);
     465        tasklet_init(&dpcm->tasklet, dummy_hrtimer_pcm_elapsed,
     466                     (unsigned long)dpcm);
     467        return 0;
     468}
     469
     470static void dummy_hrtimer_free(struct snd_pcm_substream *substream)
     471{
     472        struct dummy_hrtimer_pcm *dpcm = substream->runtime->private_data;
     473        dummy_hrtimer_sync(dpcm);
     474        kfree(dpcm);
     475}
     476
     477static struct dummy_timer_ops dummy_hrtimer_ops = {
     478        .create =       dummy_hrtimer_create,
     479        .free =         dummy_hrtimer_free,
     480        .prepare =      dummy_hrtimer_prepare,
     481        .start =        dummy_hrtimer_start,
     482        .stop =         dummy_hrtimer_stop,
     483        .pointer =      dummy_hrtimer_pointer,
     484};
     485
     486#endif /* CONFIG_HIGH_RES_TIMERS */
     487
     488/*
     489 * PCM interface
     490 */
     491
     492static int dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
     493{
     494        struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
     495
    214496        switch (cmd) {
    215497        case SNDRV_PCM_TRIGGER_START:
    216498        case SNDRV_PCM_TRIGGER_RESUME:
    217                 snd_card_dummy_pcm_timer_start(dpcm);
    218                 break;
     499                return dummy->timer_ops->start(substream);
    219500        case SNDRV_PCM_TRIGGER_STOP:
    220501        case SNDRV_PCM_TRIGGER_SUSPEND:
    221                 snd_card_dummy_pcm_timer_stop(dpcm);
    222                 break;
    223         default:
    224                 err = -EINVAL;
    225                 break;
    226         }
    227         spin_unlock(&dpcm->lock);
    228         return 0;
    229 }
    230 
    231 static int snd_card_dummy_pcm_prepare(struct snd_pcm_substream *substream)
    232 {
    233         struct snd_pcm_runtime *runtime = substream->runtime;
    234         struct snd_dummy_pcm *dpcm = runtime->private_data;
    235         int bps;
    236 
    237         bps = snd_pcm_format_width(runtime->format) * runtime->rate *
    238                 runtime->channels / 8;
    239 
    240         if (bps <= 0)
    241                 return -EINVAL;
    242 
    243         dpcm->pcm_bps = bps;
    244         dpcm->pcm_hz = HZ;
    245         dpcm->pcm_buffer_size = snd_pcm_lib_buffer_bytes(substream);
    246         dpcm->pcm_period_size = snd_pcm_lib_period_bytes(substream);
    247         dpcm->pcm_irq_pos = 0;
    248         dpcm->pcm_buf_pos = 0;
    249 
    250         snd_pcm_format_set_silence(runtime->format, runtime->dma_area,
    251                         bytes_to_samples(runtime, runtime->dma_bytes));
    252 
    253         return 0;
    254 }
    255 
    256 static void snd_card_dummy_pcm_timer_function(unsigned long data)
    257 {
    258         struct snd_dummy_pcm *dpcm = (struct snd_dummy_pcm *)data;
    259         unsigned long flags;
    260        
    261         spin_lock_irqsave(&dpcm->lock, flags);
    262         dpcm->timer.expires = 1 + jiffies;
    263         add_timer(&dpcm->timer);
    264         dpcm->pcm_irq_pos += dpcm->pcm_bps;
    265         dpcm->pcm_buf_pos += dpcm->pcm_bps;
    266         dpcm->pcm_buf_pos %= dpcm->pcm_buffer_size * dpcm->pcm_hz;
    267         if (dpcm->pcm_irq_pos >= dpcm->pcm_period_size * dpcm->pcm_hz) {
    268                 dpcm->pcm_irq_pos %= dpcm->pcm_period_size * dpcm->pcm_hz;
    269                 spin_unlock_irqrestore(&dpcm->lock, flags);
    270                 snd_pcm_period_elapsed(dpcm->substream);
    271         } else
    272                 spin_unlock_irqrestore(&dpcm->lock, flags);
    273 }
    274 
    275 static snd_pcm_uframes_t snd_card_dummy_pcm_pointer(struct snd_pcm_substream *substream)
    276 {
    277         struct snd_pcm_runtime *runtime = substream->runtime;
    278         struct snd_dummy_pcm *dpcm = runtime->private_data;
    279 
    280         return bytes_to_frames(runtime, dpcm->pcm_buf_pos / dpcm->pcm_hz);
    281 }
    282 
    283 static struct snd_pcm_hardware snd_card_dummy_playback =
    284 {
    285         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
    286                                  SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID),
     502                return dummy->timer_ops->stop(substream);
     503        }
     504        return -EINVAL;
     505}
     506
     507static int dummy_pcm_prepare(struct snd_pcm_substream *substream)
     508{
     509        struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
     510
     511        return dummy->timer_ops->prepare(substream);
     512}
     513
     514static snd_pcm_uframes_t dummy_pcm_pointer(struct snd_pcm_substream *substream)
     515{
     516        struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
     517
     518        return dummy->timer_ops->pointer(substream);
     519}
     520
     521static struct snd_pcm_hardware dummy_pcm_hardware = {
     522        .info =                 (SNDRV_PCM_INFO_MMAP |
     523                                 SNDRV_PCM_INFO_INTERLEAVED |
     524                                 SNDRV_PCM_INFO_RESUME |
     525                                 SNDRV_PCM_INFO_MMAP_VALID),
    287526        .formats =              USE_FORMATS,
    288527        .rates =                USE_RATE,
    … …  
    292531        .channels_max =         USE_CHANNELS_MAX,
    293532        .buffer_bytes_max =     MAX_BUFFER_SIZE,
    294         .period_bytes_min =     64,
     533        .period_bytes_min =     MIN_PERIOD_SIZE,
    295534        .period_bytes_max =     MAX_PERIOD_SIZE,
    296535        .periods_min =          USE_PERIODS_MIN,
    … …  
    299538};
    300539
    301 static struct snd_pcm_hardware snd_card_dummy_capture =
    302 {
    303         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
    304                                  SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID),
    305         .formats =              USE_FORMATS,
    306         .rates =                USE_RATE,
    307         .rate_min =             USE_RATE_MIN,
    308         .rate_max =             USE_RATE_MAX,
    309         .channels_min =         USE_CHANNELS_MIN,
    310         .channels_max =         USE_CHANNELS_MAX,
    311         .buffer_bytes_max =     MAX_BUFFER_SIZE,
    312         .period_bytes_min =     64,
    313         .period_bytes_max =     MAX_PERIOD_SIZE,
    314         .periods_min =          USE_PERIODS_MIN,
    315         .periods_max =          USE_PERIODS_MAX,
    316         .fifo_size =            0,
    317 };
    318 
    319 static void snd_card_dummy_runtime_free(struct snd_pcm_runtime *runtime)
    320 {
    321         kfree(runtime->private_data);
    322 }
    323 
    324 static int snd_card_dummy_hw_params(struct snd_pcm_substream *substream,
    325                                     struct snd_pcm_hw_params *hw_params)
    326 {
    327         return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
    328 }
    329 
    330 static int snd_card_dummy_hw_free(struct snd_pcm_substream *substream)
    331 {
     540static int dummy_pcm_hw_params(struct snd_pcm_substream *substream,
     541                               struct snd_pcm_hw_params *hw_params)
     542{
     543        if (fake_buffer) {
     544                /* runtime->dma_bytes has to be set manually to allow mmap */
     545                substream->runtime->dma_bytes = params_buffer_bytes(hw_params);
     546                return 0;
     547        }
     548        return snd_pcm_lib_malloc_pages(substream,
     549                                        params_buffer_bytes(hw_params));
     550}
     551
     552static int dummy_pcm_hw_free(struct snd_pcm_substream *substream)
     553{
     554        if (fake_buffer)
     555                return 0;
    332556        return snd_pcm_lib_free_pages(substream);
    333557}
    334558
    335 static struct snd_dummy_pcm *new_pcm_stream(struct snd_pcm_substream *substream)
    336 {
    337         struct snd_dummy_pcm *dpcm;
    338 
    339         dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
    340         if (! dpcm)
    341                 return dpcm;
    342         init_timer(&dpcm->timer);
    343         dpcm->timer.data = (unsigned long) dpcm;
    344         dpcm->timer.function = snd_card_dummy_pcm_timer_function;
    345         spin_lock_init(&dpcm->lock);
    346         dpcm->substream = substream;
    347         return dpcm;
    348 }
    349 
    350 static int snd_card_dummy_playback_open(struct snd_pcm_substream *substream)
    351 {
     559static int dummy_pcm_open(struct snd_pcm_substream *substream)
     560{
     561        struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
     562        struct dummy_model *model = dummy->model;
    352563        struct snd_pcm_runtime *runtime = substream->runtime;
    353         struct snd_dummy_pcm *dpcm;
    354564        int err;
    355565
    356         if ((dpcm = new_pcm_stream(substream)) == NULL)
    357                 return -ENOMEM;
    358         runtime->private_data = dpcm;
    359         /* makes the infrastructure responsible for freeing dpcm */
    360         runtime->private_free = snd_card_dummy_runtime_free;
    361         runtime->hw = snd_card_dummy_playback;
     566        dummy->timer_ops = &dummy_systimer_ops;
     567#ifdef CONFIG_HIGH_RES_TIMERS
     568        if (hrtimer)
     569                dummy->timer_ops = &dummy_hrtimer_ops;
     570#endif
     571
     572        err = dummy->timer_ops->create(substream);
     573        if (err < 0)
     574                return err;
     575
     576        runtime->hw = dummy->pcm_hw;
    362577        if (substream->pcm->device & 1) {
    363578                runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED;
    … …  
    365580        }
    366581        if (substream->pcm->device & 2)
    367                 runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP|SNDRV_PCM_INFO_MMAP_VALID);
    368         err = add_playback_constraints(runtime);
    369         if (err < 0)
     582                runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP |
     583                                      SNDRV_PCM_INFO_MMAP_VALID);
     584
     585        if (model == NULL)
     586                return 0;
     587
     588        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
     589                if (model->playback_constraints)
     590                        err = model->playback_constraints(substream->runtime);
     591        } else {
     592                if (model->capture_constraints)
     593                        err = model->capture_constraints(substream->runtime);
     594        }
     595        if (err < 0) {
     596                dummy->timer_ops->free(substream);
    370597                return err;
    371 
    372         return 0;
    373 }
    374 
    375 static int snd_card_dummy_capture_open(struct snd_pcm_substream *substream)
    376 {
    377         struct snd_pcm_runtime *runtime = substream->runtime;
    378         struct snd_dummy_pcm *dpcm;
    379         int err;
    380 
    381         if ((dpcm = new_pcm_stream(substream)) == NULL)
    382                 return -ENOMEM;
    383         runtime->private_data = dpcm;
    384         /* makes the infrastructure responsible for freeing dpcm */
    385         runtime->private_free = snd_card_dummy_runtime_free;
    386         runtime->hw = snd_card_dummy_capture;
    387         if (substream->pcm->device == 1) {
    388                 runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED;
    389                 runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
    390         }
    391         if (substream->pcm->device & 2)
    392                 runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP|SNDRV_PCM_INFO_MMAP_VALID);
    393         err = add_capture_constraints(runtime);
    394         if (err < 0)
    395                 return err;
    396 
    397         return 0;
    398 }
    399 
    400 static int snd_card_dummy_playback_close(struct snd_pcm_substream *substream)
    401 {
    402         return 0;
    403 }
    404 
    405 static int snd_card_dummy_capture_close(struct snd_pcm_substream *substream)
    406 {
    407         return 0;
    408 }
    409 
    410 static struct snd_pcm_ops snd_card_dummy_playback_ops = {
    411         .open =                 snd_card_dummy_playback_open,
    412         .close =                snd_card_dummy_playback_close,
    413         .ioctl =                snd_pcm_lib_ioctl,
    414         .hw_params =            snd_card_dummy_hw_params,
    415         .hw_free =              snd_card_dummy_hw_free,
    416         .prepare =              snd_card_dummy_pcm_prepare,
    417         .trigger =              snd_card_dummy_pcm_trigger,
    418         .pointer =              snd_card_dummy_pcm_pointer,
    419 };
    420 
    421 static struct snd_pcm_ops snd_card_dummy_capture_ops = {
    422         .open =                 snd_card_dummy_capture_open,
    423         .close =                snd_card_dummy_capture_close,
    424         .ioctl =                snd_pcm_lib_ioctl,
    425         .hw_params =            snd_card_dummy_hw_params,
    426         .hw_free =              snd_card_dummy_hw_free,
    427         .prepare =              snd_card_dummy_pcm_prepare,
    428         .trigger =              snd_card_dummy_pcm_trigger,
    429         .pointer =              snd_card_dummy_pcm_pointer,
     598        }
     599        return 0;
     600}
     601
     602static int dummy_pcm_close(struct snd_pcm_substream *substream)
     603{
     604        struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
     605        dummy->timer_ops->free(substream);
     606        return 0;
     607}
     608
     609/*
     610 * dummy buffer handling
     611 */
     612
     613static void *dummy_page[2];
     614
     615static void free_fake_buffer(void)
     616{
     617        if (fake_buffer) {
     618                int i;
     619                for (i = 0; i < 2; i++)
     620                        if (dummy_page[i]) {
     621                                free_page((unsigned long)dummy_page[i]);
     622                                dummy_page[i] = NULL;
     623                        }
     624        }
     625}
     626
     627static int alloc_fake_buffer(void)
     628{
     629        int i;
     630
     631        if (!fake_buffer)
     632                return 0;
     633        for (i = 0; i < 2; i++) {
     634                dummy_page[i] = (void *)get_zeroed_page(GFP_KERNEL);
     635                if (!dummy_page[i]) {
     636                        free_fake_buffer();
     637                        return -ENOMEM;
     638                }
     639        }
     640        return 0;
     641}
     642
     643static int dummy_pcm_copy(struct snd_pcm_substream *substream,
     644                          int channel, snd_pcm_uframes_t pos,
     645                          void __user *dst, snd_pcm_uframes_t count)
     646{
     647        return 0; /* do nothing */
     648}
     649
     650static int dummy_pcm_silence(struct snd_pcm_substream *substream,
     651                             int channel, snd_pcm_uframes_t pos,
     652                             snd_pcm_uframes_t count)
     653{
     654        return 0; /* do nothing */
     655}
     656
     657static struct page *dummy_pcm_page(struct snd_pcm_substream *substream,
     658                                   unsigned long offset)
     659{
     660        return virt_to_page(dummy_page[substream->stream]); /* the same page */
     661}
     662
     663static struct snd_pcm_ops dummy_pcm_ops = {
     664        .open =         dummy_pcm_open,
     665        .close =        dummy_pcm_close,
     666        .ioctl =        snd_pcm_lib_ioctl,
     667        .hw_params =    dummy_pcm_hw_params,
     668        .hw_free =      dummy_pcm_hw_free,
     669        .prepare =      dummy_pcm_prepare,
     670        .trigger =      dummy_pcm_trigger,
     671        .pointer =      dummy_pcm_pointer,
     672};
     673
     674static struct snd_pcm_ops dummy_pcm_ops_no_buf = {
     675        .open =         dummy_pcm_open,
     676        .close =        dummy_pcm_close,
     677        .ioctl =        snd_pcm_lib_ioctl,
     678        .hw_params =    dummy_pcm_hw_params,
     679        .hw_free =      dummy_pcm_hw_free,
     680        .prepare =      dummy_pcm_prepare,
     681        .trigger =      dummy_pcm_trigger,
     682        .pointer =      dummy_pcm_pointer,
     683        .copy =         dummy_pcm_copy,
     684        .silence =      dummy_pcm_silence,
     685        .page =         dummy_pcm_page,
    430686};
    431687
    … …  
    434690{
    435691        struct snd_pcm *pcm;
     692        struct snd_pcm_ops *ops;
    436693        int err;
    437694
    … …  
    441698                return err;
    442699        dummy->pcm = pcm;
    443         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_card_dummy_playback_ops);
    444         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_dummy_capture_ops);
     700        if (fake_buffer)
     701                ops = &dummy_pcm_ops_no_buf;
     702        else
     703                ops = &dummy_pcm_ops;
     704        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, ops);
     705        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, ops);
    445706        pcm->private_data = dummy;
    446707        pcm->info_flags = 0;
    447708        strcpy(pcm->name, "Dummy PCM");
    448         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
    449                                               snd_dma_continuous_data(GFP_KERNEL),
    450                                               0, 64*1024);
    451         return 0;
    452 }
     709        if (!fake_buffer) {
     710                snd_pcm_lib_preallocate_pages_for_all(pcm,
     711                        SNDRV_DMA_TYPE_CONTINUOUS,
     712                        snd_dma_continuous_data(GFP_KERNEL),
     713                        0, 64*1024);
     714        }
     715        return 0;
     716}
     717
     718/*
     719 * mixer interface
     720 */
    453721
    454722#define DUMMY_VOLUME(xname, xindex, addr) \
    … …  
    569837        int err;
    570838
    571         if (snd_BUG_ON(!dummy))
    572                 return -EINVAL;
    573839        spin_lock_init(&dummy->mixer_lock);
    574840        strcpy(card->mixername, "Dummy Mixer");
    … …  
    582848}
    583849
     850#if defined(CONFIG_SND_DEBUG) && defined(CONFIG_PROC_FS)
     851/*
     852 * proc interface
     853 */
     854static void print_formats(struct snd_dummy *dummy,
     855                          struct snd_info_buffer *buffer)
     856{
     857        int i;
     858
     859        for (i = 0; i < SNDRV_PCM_FORMAT_LAST; i++) {
     860                if (dummy->pcm_hw.formats & (1ULL << i))
     861                        snd_iprintf(buffer, " %s", snd_pcm_format_name(i));
     862        }
     863}
     864
     865static void print_rates(struct snd_dummy *dummy,
     866                        struct snd_info_buffer *buffer)
     867{
     868        static int rates[] = {
     869                5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000,
     870                64000, 88200, 96000, 176400, 192000,
     871        };
     872        int i;
     873
     874        if (dummy->pcm_hw.rates & SNDRV_PCM_RATE_CONTINUOUS)
     875                snd_iprintf(buffer, " continuous");
     876        if (dummy->pcm_hw.rates & SNDRV_PCM_RATE_KNOT)
     877                snd_iprintf(buffer, " knot");
     878        for (i = 0; i < ARRAY_SIZE(rates); i++)
     879                if (dummy->pcm_hw.rates & (1 << i))
     880                        snd_iprintf(buffer, " %d", rates[i]);
     881}
     882
     883#define get_dummy_int_ptr(dummy, ofs) \
     884        (unsigned int *)((char *)&((dummy)->pcm_hw) + (ofs))
     885#define get_dummy_ll_ptr(dummy, ofs) \
     886        (unsigned long long *)((char *)&((dummy)->pcm_hw) + (ofs))
     887
     888struct dummy_hw_field {
     889        const char *name;
     890        const char *format;
     891        unsigned int offset;
     892        unsigned int size;
     893};
     894#define FIELD_ENTRY(item, fmt) {                   \
     895        .name = #item,                             \
     896        .format = fmt,                             \
     897        .offset = offsetof(struct snd_pcm_hardware, item), \
     898        .size = sizeof(dummy_pcm_hardware.item) }
     899
     900static struct dummy_hw_field fields[] = {
     901        FIELD_ENTRY(formats, "%#llx"),
     902        FIELD_ENTRY(rates, "%#x"),
     903        FIELD_ENTRY(rate_min, "%d"),
     904        FIELD_ENTRY(rate_max, "%d"),
     905        FIELD_ENTRY(channels_min, "%d"),
     906        FIELD_ENTRY(channels_max, "%d"),
     907        FIELD_ENTRY(buffer_bytes_max, "%ld"),
     908        FIELD_ENTRY(period_bytes_min, "%ld"),
     909        FIELD_ENTRY(period_bytes_max, "%ld"),
     910        FIELD_ENTRY(periods_min, "%d"),
     911        FIELD_ENTRY(periods_max, "%d"),
     912};
     913
     914static void dummy_proc_read(struct snd_info_entry *entry,
     915                            struct snd_info_buffer *buffer)
     916{
     917        struct snd_dummy *dummy = entry->private_data;
     918        int i;
     919
     920        for (i = 0; i < ARRAY_SIZE(fields); i++) {
     921                snd_iprintf(buffer, "%s ", fields[i].name);
     922                if (fields[i].size == sizeof(int))
     923                        snd_iprintf(buffer, fields[i].format,
     924                                *get_dummy_int_ptr(dummy, fields[i].offset));
     925                else
     926                        snd_iprintf(buffer, fields[i].format,
     927                                *get_dummy_ll_ptr(dummy, fields[i].offset));
     928                if (!strcmp(fields[i].name, "formats"))
     929                        print_formats(dummy, buffer);
     930                else if (!strcmp(fields[i].name, "rates"))
     931                        print_rates(dummy, buffer);
     932                snd_iprintf(buffer, "\n");
     933        }
     934}
     935
     936static void dummy_proc_write(struct snd_info_entry *entry,
     937                             struct snd_info_buffer *buffer)
     938{
     939        struct snd_dummy *dummy = entry->private_data;
     940        char line[64];
     941
     942        while (!snd_info_get_line(buffer, line, sizeof(line))) {
     943                char item[20];
     944                const char *ptr;
     945                unsigned long long val;
     946                int i;
     947
     948                ptr = snd_info_get_str(item, line, sizeof(item));
     949                for (i = 0; i < ARRAY_SIZE(fields); i++) {
     950                        if (!strcmp(item, fields[i].name))
     951                                break;
     952                }
     953                if (i >= ARRAY_SIZE(fields))
     954                        continue;
     955                snd_info_get_str(item, ptr, sizeof(item));
     956                if (strict_strtoull(item, 0, &val))
     957                        continue;
     958                if (fields[i].size == sizeof(int))
     959                        *get_dummy_int_ptr(dummy, fields[i].offset) = val;
     960                else
     961                        *get_dummy_ll_ptr(dummy, fields[i].offset) = val;
     962        }
     963}
     964
     965static void __devinit dummy_proc_init(struct snd_dummy *chip)
     966{
     967        struct snd_info_entry *entry;
     968
     969        if (!snd_card_proc_new(chip->card, "dummy_pcm", &entry)) {
     970                snd_info_set_text_ops(entry, chip, dummy_proc_read);
     971                entry->c.text.write = dummy_proc_write;
     972                entry->mode |= S_IWUSR;
     973                entry->private_data = chip;
     974        }
     975}
     976#else
     977#define dummy_proc_init(x)
     978#endif /* CONFIG_SND_DEBUG && CONFIG_PROC_FS */
     979
    584980static int __devinit snd_dummy_probe(struct platform_device *devptr)
    585981{
    586982        struct snd_card *card;
    587983        struct snd_dummy *dummy;
     984        struct dummy_model *m = NULL, **mdl;
    588985        int idx, err;
    589986        int dev = devptr->id;
    … …  
    595992        dummy = card->private_data;
    596993        dummy->card = card;
     994        for (mdl = dummy_models; *mdl && model[dev]; mdl++) {
     995                if (strcmp(model[dev], (*mdl)->name) == 0) {
     996                        printk(KERN_INFO
     997                                "snd-dummy: Using model '%s' for card %i\n",
     998                                (*mdl)->name, card->number);
     999                        m = dummy->model = *mdl;
     1000                        break;
     1001                }
     1002        }
    5971003        for (idx = 0; idx < MAX_PCM_DEVICES && idx < pcm_devs[dev]; idx++) {
    5981004                if (pcm_substreams[dev] < 1)
    … …  
    6041010                        goto __nodev;
    6051011        }
     1012
     1013        dummy->pcm_hw = dummy_pcm_hardware;
     1014        if (m) {
     1015                if (m->formats)
     1016                        dummy->pcm_hw.formats = m->formats;
     1017                if (m->buffer_bytes_max)
     1018                        dummy->pcm_hw.buffer_bytes_max = m->buffer_bytes_max;
     1019                if (m->period_bytes_min)
     1020                        dummy->pcm_hw.period_bytes_min = m->period_bytes_min;
     1021                if (m->period_bytes_max)
     1022                        dummy->pcm_hw.period_bytes_max = m->period_bytes_max;
     1023                if (m->periods_min)
     1024                        dummy->pcm_hw.periods_min = m->periods_min;
     1025                if (m->periods_max)
     1026                        dummy->pcm_hw.periods_max = m->periods_max;
     1027                if (m->rates)
     1028                        dummy->pcm_hw.rates = m->rates;
     1029                if (m->rate_min)
     1030                        dummy->pcm_hw.rate_min = m->rate_min;
     1031                if (m->rate_max)
     1032                        dummy->pcm_hw.rate_max = m->rate_max;
     1033                if (m->channels_min)
     1034                        dummy->pcm_hw.channels_min = m->channels_min;
     1035                if (m->channels_max)
     1036                        dummy->pcm_hw.channels_max = m->channels_max;
     1037        }
     1038
    6061039        err = snd_card_dummy_new_mixer(dummy);
    6071040        if (err < 0)
    … …  
    6101043        strcpy(card->shortname, "Dummy");
    6111044        sprintf(card->longname, "Dummy %i", dev + 1);
     1045
     1046        dummy_proc_init(dummy);
    6121047
    6131048        snd_card_set_dev(card, &devptr->dev);
    … …  
    6711106                platform_device_unregister(devices[i]);
    6721107        platform_driver_unregister(&snd_dummy_driver);
     1108        free_fake_buffer();
    6731109}
    6741110
    … …  
    6801116        if (err < 0)
    6811117                return err;
     1118
     1119        err = alloc_fake_buffer();
     1120        if (err < 0) {
     1121                platform_driver_unregister(&snd_dummy_driver);
     1122                return err;
     1123        }
    6821124
    6831125        cards = 0;

  • GPL/trunk/alsa-kernel/drivers/mpu401/mpu401.c

    r410 r587  
    2222
    2323#ifdef TARGET_OS2
    24 #include <sound/config.h>
     24#include <config.h>
    2525#endif
    2626#include <linux/init.h>

  • GPL/trunk/alsa-kernel/drivers/mtpav.c

    r426 r587  
    5353#include <linux/init.h>
    5454#include <linux/interrupt.h>
     55#include <linux/module.h>
    5556#include <linux/err.h>
    5657#include <linux/platform_device.h>
    57 #include <linux/slab.h>
    5858#include <linux/ioport.h>
     59#include <linux/io.h>
    5960#include <linux/moduleparam.h>
    6061#include <sound/core.h>
    … …  
    6263#include <sound/rawmidi.h>
    6364#include <linux/delay.h>
    64 
    65 #include <asm/io.h>
    6665
    6766/*
    … …  
    592591        }
    593592        mcard->port = port;
    594         if (request_irq(irq, snd_mtpav_irqh, IRQF_DISABLED, "MOTU MTPAV", mcard)) {
     593        if (request_irq(irq, snd_mtpav_irqh, 0, "MOTU MTPAV", mcard)) {
    595594                snd_printk(KERN_ERR "MTVAP IRQ %d busy\n", irq);
    596595                return -EBUSY;

  • GPL/trunk/alsa-kernel/drivers/serial-u16550.c

    r426 r587  
    3737#include <linux/slab.h>
    3838#include <linux/ioport.h>
    39 #include <linux/moduleparam.h>
     39#include <linux/module.h>
    4040#include <sound/core.h>
    4141#include <sound/rawmidi.h>
    … …  
    7070static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
    7171static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
    72 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; /* Enable this card */
     72static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; /* Enable this card */
    7373static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* 0x3f8,0x2f8,0x3e8,0x2e8 */
    7474static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;        /* 3,4,5,7,9,10,11,14,15 */
    … …  
    7878static int ins[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};  /* 1 to 16 */
    7979static int adaptor[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = SNDRV_SERIAL_SOUNDCANVAS};
    80 static int droponfull[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS -1)] = SNDRV_SERIAL_NORMALBUFF };
     80static bool droponfull[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS -1)] = SNDRV_SERIAL_NORMALBUFF };
    8181
    8282module_param_array(index, int, NULL, 0444);
    … …  
    817817        if (irq >= 0 && irq != SNDRV_AUTO_IRQ) {
    818818                if (request_irq(irq, snd_uart16550_interrupt,
    819                                 IRQF_DISABLED, "Serial MIDI", uart)) {
     819                                0, "Serial MIDI", uart)) {
    820820                        snd_printk(KERN_WARNING
    821821                                   "irq %d busy. Using Polling.\n", irq);

  • GPL/trunk/alsa-kernel/drivers/virmidi.c

    r426 r587  
    4646#include <linux/err.h>
    4747#include <linux/platform_device.h>
    48 #include <linux/moduleparam.h>
     48#include <linux/module.h>
    4949#include <sound/core.h>
    5050#include <sound/seq_kernel.h>
    … …  
    6464static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
    6565static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
    66 static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0};
     66static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0};
    6767static int midi_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 4};
    6868
    … …  
    9595        if (err < 0)
    9696                return err;
    97         vmidi = (struct snd_card_virmidi *)card->private_data;
     97        vmidi = card->private_data;
    9898        vmidi->card = card;
    9999

  • GPL/trunk/alsa-kernel/include/sound/asequencer.h

    r305 r587  
    6868#define SNDRV_SEQ_EVENT_TIMESIGN        23      /* SMF Time Signature event */
    6969#define SNDRV_SEQ_EVENT_KEYSIGN         24      /* SMF Key Signature event */
    70                
     70       
    7171/** timer messages
    7272 * event data type = snd_seq_ev_queue_control
    … …  
    222222
    223223        /* external stored data */
    224 #ifndef TARGET_OS2
     224#ifndef TARGET_OS2     
    225225struct snd_seq_ev_ext {
    226226        unsigned int len;       /* length of data */
    … …  
    235235#pragma pack()
    236236#endif
     237
    237238struct snd_seq_result {
    238239        int event;              /* processed event type */
    … …  
    273274
    274275        /* quoted event - inside the kernel only */
    275 #ifndef TARGET_OS2
     276#ifndef TARGET_OS2     
    276277struct snd_seq_ev_quote {
    277278        struct snd_seq_addr origin;             /* original sender */
    … …  
    422423#define USER_CLIENT     ((__force snd_seq_client_type_t) 1)
    423424#define KERNEL_CLIENT   ((__force snd_seq_client_type_t) 2)
    424                        
     425
    425426        /* event filter flags */
    426427#define SNDRV_SEQ_FILTER_BROADCAST      (1<<0)  /* accept broadcast messages */

  • GPL/trunk/alsa-kernel/include/sound/asound.h

    r542 r587  
    4242#endif /* __KERNEL__ **/
    4343
     44#ifdef TARGET_OS2
    4445#ifndef __force
    4546#define __force
    … …  
    5051#endif
    5152
    52 #ifdef TARGET_OS2
    5353#define SNDRV_PCM_VOL_FRONT_LEFT        0
    5454#define SNDRV_PCM_VOL_FRONT_RIGHT       1
    … …  
    323323typedef int snd_pcm_hw_param_t;
    324324#define SNDRV_PCM_HW_PARAM_ACCESS       0       /* Access type */
    325 #ifdef TARGET_OS2
     325#ifndef TARGET_OS2
     326#define SNDRV_PCM_HW_PARAM_FORMAT       1       /* Format */
     327#define SNDRV_PCM_HW_PARAM_SUBFORMAT    2       /* Subformat */
     328#else
    326329#define SNDRV_PCM_HW_PARAM_RATE_MASK    1 /* Format */
    327 #endif
    328330#define SNDRV_PCM_HW_PARAM_FORMAT       2       /* Format */
    329331#define SNDRV_PCM_HW_PARAM_SUBFORMAT    3       /* Subformat */
     332#endif
    330333#define SNDRV_PCM_HW_PARAM_FIRST_MASK   SNDRV_PCM_HW_PARAM_ACCESS
    331334#define SNDRV_PCM_HW_PARAM_LAST_MASK    SNDRV_PCM_HW_PARAM_SUBFORMAT
    … …  
    356359#define SNDRV_PCM_HW_PARAM_LAST_INTERVAL        SNDRV_PCM_HW_PARAM_TICK_TIME
    357360
    358 #define SNDRV_PCM_HW_PARAMS_NORESAMPLE          (1<<0)  /* avoid rate resampling */
     361#define SNDRV_PCM_HW_PARAMS_NORESAMPLE  (1<<0)  /* avoid rate resampling */
    359362
    360363struct snd_interval {
    … …  
    789792        unsigned int device;            /* device/client number */
    790793        unsigned int subdevice;         /* subdevice (substream) number */
    791     unsigned char name[44];             /* ASCII name of item */
     794        unsigned char name[44];         /* ASCII name of item */
    792795        unsigned int index;             /* index of item */
    793796};
    … …  
    836839        struct snd_ctl_elem_id id;      /* W: element ID */
    837840        unsigned int indirect: 1;       /* W: indirect access - obsoleted */
    838     union {
     841        union {
    839842                union {
    840843                        long value[128];
    … …  
    854857                } bytes;
    855858                struct snd_aes_iec958 iec958;
    856     } value;                /* RO */
     859        } value;                /* RO */
    857860        struct timespec tstamp;
    858     unsigned char reserved[128-sizeof(struct timespec)];
     861        unsigned char reserved[128-sizeof(struct timespec)];
    859862};
    860863

  • GPL/trunk/alsa-kernel/include/sound/core.h

    r464 r587  
    2323 */
    2424#ifdef TARGET_OS2
    25 #include <sound\config.h>
     25#include <config.h>
    2626#endif
    2727
    … …  
    101101struct snd_monitor_file {
    102102        struct file *file;
    103 #ifndef TARGET_OS2
     103#ifndef TARGET_OS2     
    104104        const struct file_operations *disconnected_f_op;
    105105#else
    106106        struct file_operations *disconnected_f_op;
    107 #endif
     107#endif 
    108108        struct list_head shutdown_list; /* still need to shutdown */
    109109        struct list_head list;  /* link of monitor files */
    … …  
    205205        int card;                       /* card number */
    206206        int device;                     /* device number */
    207 #ifndef TARGET_OS2
     207#ifndef TARGET_OS2     
    208208        const struct file_operations *f_ops;    /* file operations */
    209209#else
    210210        struct file_operations *f_ops;  /* file operations */
    211 #endif
     211#endif 
    212212        void *private_data;             /* private data for f_ops->open */
    213213        struct device *dev;             /* device for sysfs */
    … …  
    234234int snd_register_device_for_dev(int type, struct snd_card *card,
    235235                                int dev,
    236 #ifndef TARGET_OS2
     236#ifndef TARGET_OS2                             
    237237                                const struct file_operations *f_ops,
    238238#else
    239239                                struct file_operations *f_ops,
    240 #endif
     240#endif                         
    241241                                void *private_data,
    242242                                const char *name,
    … …  
    263263#ifndef TARGET_OS2
    264264                                      const struct file_operations *f_ops,
    265 #else
     265#else                           
    266266                                      struct file_operations *f_ops,
    267 #endif
     267#endif                         
    268268                                      void *private_data,
    269269                                      const char *name)
    … …  
    285285#else
    286286                            struct file_operations *f_ops, void *private_data,
    287 #endif
     287#endif                 
    288288                            const char *name);
    289289int snd_unregister_oss_device(int type, struct snd_card *card, int dev);
    … …  
    376376#else
    377377#define __snd_printk printk
    378 #endif /* nothing */
     378#endif 
    379379#endif
    380380
    … …  
    418418 * When CONFIG_SND_DEBUG is set, this macro evaluates the given condition,
    419419 * and call WARN() and returns the value if it's non-zero.
    420  * 
     420 *
    421421 * When CONFIG_SND_DEBUG is not set, this just returns zero, and the given
    422422 * condition is ignored.
    … …  
    427427 * If you want to evaluate and give a warning, use standard WARN_ON().
    428428 */
    429 
    430429#define snd_BUG_ON(cond)        WARN((cond), "BUG? (%s)\n", __stringify(cond))
    431430
    … …  
    449448#define snd_BUG_ON(cond)        __snd_bug_on(0 && (cond))  /* always false */
    450449#endif
    451 
    452450
    453451#endif /* CONFIG_SND_DEBUG */

  • GPL/trunk/alsa-kernel/include/sound/info.h

    r410 r587  
    111111#endif
    112112
    113 #ifndef TARGET_OS2
    114113int snd_iprintf(struct snd_info_buffer *buffer, char *fmt, ...) \
    115114                                __attribute__ ((format (printf, 2, 3)));
    116 #else
    117 int snd_iprintf(struct snd_info_buffer * buffer, char *fmt,...);
    118 #endif
    119115int snd_info_init(void);
    120116int snd_info_done(void);

  • GPL/trunk/alsa-kernel/include/sound/initval.h

    r398 r587  
    2222 */
    2323
     24#ifdef TARGET_OS2
    2425#ifndef MODULE_GENERIC_STRING
    2526#ifdef MODULE
    … …  
    3233#endif
    3334
    34 #ifdef TARGET_OS2
    35 #define MODULE_CLASSES(val)
    36 #define MODULE_DEVICES(val)
    37 #define MODULE_PARM_SYNTAX(id, val)
     35#define MODULE_CLASSES(val)
     36#define MODULE_DEVICES(val)
     37#define MODULE_PARM_SYNTAX(id, val)
    3838#define module_param_array(name, type, nump, perm)
    3939#define module_param(name, type, perm)
    … …  
    5252#define module_param(name, type, perm) \
    5353        MODULE_PARM(name, SNDRV_MODULE_TYPE_##type)
    54 
    5554#endif
    5655
     56#ifndef TARGET_OS2
     57#define SNDRV_AUTO_PORT         1
     58#else
    5759#define SNDRV_AUTO_PORT         0xffff
     60#endif
    5861#define SNDRV_AUTO_IRQ          0xffff
    5962#define SNDRV_AUTO_DMA          0xffff
    … …  
    7578#define SNDRV_DEFAULT_ENABLE    { 1,1,1,1,1,1,1,1 }
    7679#define SNDRV_DEFAULT_ENABLE_PNP        SNDRV_DEFAULT_ENABLE
     80#ifdef CONFIG_PNP
     81#define SNDRV_DEFAULT_ENABLE_ISAPNP SNDRV_DEFAULT_ENABLE_PNP
     82#else
     83#define SNDRV_DEFAULT_ENABLE_ISAPNP SNDRV_DEFAULT_ENABLE
     84#endif
    7785#define SNDRV_DEFAULT_PORT      { REPEAT_SNDRV(-1) }
    7886#define SNDRV_DEFAULT_IRQ       { REPEAT_SNDRV(SNDRV_AUTO_IRQ) }
    … …  
    8391#define SNDDRV_DEFAULT_PCM_SUBSTREAMS {REPEAT_SNDRV(8)};
    8492#define SNDDRV_DEFAULT_MIDI_DEVS      {REPEAT_SNDRV(4)};
    85 #else
    86 #define SNDRV_DEFAULT_IDX       { [0 ... (SNDRV_CARDS-1)] = -1 }
    87 #define SNDRV_DEFAULT_STR       { [0 ... (SNDRV_CARDS-1)] = NULL }
    88 #define SNDRV_DEFAULT_ENABLE    { 1, [1 ... (SNDRV_CARDS-1)] = 0 }
    89 #define SNDRV_DEFAULT_ENABLE_PNP { [0 ... (SNDRV_CARDS-1)] = 1 }
    90 #define SNDRV_DEFAULT_PORT      { SNDRV_AUTO_PORT, [1 ... (SNDRV_CARDS-1)] = -1 }
    91 #define SNDRV_DEFAULT_IRQ       { [0 ... (SNDRV_CARDS-1)] = SNDRV_AUTO_IRQ }
    92 #define SNDRV_DEFAULT_DMA       { [0 ... (SNDRV_CARDS-1)] = SNDRV_AUTO_DMA }
    93 #define SNDRV_DEFAULT_DMA_SIZE  { [0 ... (SNDRV_CARDS-1)] = SNDRV_AUTO_DMA_SIZE }
    94 #define SNDRV_DEFAULT_PTR       SNDRV_DEFAULT_STR
    95 #endif
    96 
    97 #ifdef CONFIG_PNP
    98 #define SNDRV_DEFAULT_ENABLE_ISAPNP SNDRV_DEFAULT_ENABLE_PNP
    99 #else
    100 #define SNDRV_DEFAULT_ENABLE_ISAPNP SNDRV_DEFAULT_ENABLE
    101 #endif
    10293
    10394#define SNDRV_BOOLEAN_TRUE_DESC "allows:{{0,Disabled},{1,Enabled}},default:1,dialog:check"
    … …  
    119110#define SNDRV_PORT12_DESC       SNDRV_ENABLED ",allows:{{0,0x3fff}},base:16"
    120111#define SNDRV_PORT_DESC         SNDRV_ENABLED ",allows:{{0,0xffff}},base:16"
     112#else
     113#define SNDRV_DEFAULT_IDX       { [0 ... (SNDRV_CARDS-1)] = -1 }
     114#define SNDRV_DEFAULT_STR       { [0 ... (SNDRV_CARDS-1)] = NULL }
     115#define SNDRV_DEFAULT_ENABLE    { 1, [1 ... (SNDRV_CARDS-1)] = 0 }
     116#define SNDRV_DEFAULT_ENABLE_PNP { [0 ... (SNDRV_CARDS-1)] = 1 }
     117#ifdef CONFIG_PNP
     118#define SNDRV_DEFAULT_ENABLE_ISAPNP SNDRV_DEFAULT_ENABLE_PNP
     119#else
     120#define SNDRV_DEFAULT_ENABLE_ISAPNP SNDRV_DEFAULT_ENABLE
     121#endif
     122#define SNDRV_DEFAULT_PORT      { [0 ... (SNDRV_CARDS-1)] = SNDRV_AUTO_PORT }
     123#define SNDRV_DEFAULT_IRQ       { [0 ... (SNDRV_CARDS-1)] = SNDRV_AUTO_IRQ }
     124#define SNDRV_DEFAULT_DMA       { [0 ... (SNDRV_CARDS-1)] = SNDRV_AUTO_DMA }
     125#define SNDRV_DEFAULT_DMA_SIZE  { [0 ... (SNDRV_CARDS-1)] = SNDRV_AUTO_DMA_SIZE }
     126#define SNDRV_DEFAULT_PTR       SNDRV_DEFAULT_STR
     127#endif
    121128
    122129#ifdef SNDRV_LEGACY_FIND_FREE_IRQ
    … …  
    157164#endif
    158165
     166#ifdef TARGET_OS2
    159167#if defined(SNDRV_GET_ID) && !defined(MODULE)
    160168#include <linux/ctype.h>
    … …  
    182190}
    183191#endif
     192#endif
    184193
    185 #endif                          /* __INITVAL_H */
     194#endif /* __SOUND_INITVAL_H */
     195

  • GPL/trunk/alsa-kernel/include/sound/opl3.h

    r399 r587  
    1818 *
    1919 *      With the above exceptions the both sides can be operated independently.
    20  *     
     20 *
    2121 *      A 4 OP voice can be created by setting the corresponding
    2222 *      bit at offset 4 of the right side.
    … …  
    2727 *
    2828 *      If a voice is set to the 2 OP mode, it works like 2 OP modes
    29  *      of the original YM3812 (AdLib). In addition the voice can 
     29 *      of the original YM3812 (AdLib). In addition the voice can
    3030 *      be connected the left, right or both stereo channels. It can
    3131 *      even be left unconnected. This works with 4 OP voices also.
    … …  
    189189 *
    190190 *
    191  *                                     
     191 *
    192192 *                                       +---+
    193193 *                                       |   |
    … …  
    195195 *                                                |->
    196196 *                                      >--3----4-+
    197  *                                     
     197 *
    198198 *                                       +---+
    199199 *                                       |   |
    … …  
    251251        unsigned char sustain_release;
    252252        unsigned char wave_select;
    253 #ifndef TARGET_OS2
    254253} __attribute__((packed));
    255 #else
    256 };
     254#ifdef TARGET_OS2
    257255#pragma pack()
    258256#endif
    … …  
    343341        struct snd_midi_channel_set * oss_chset;
    344342#endif
    345  
     343
    346344#define OPL3_PATCH_HASH_SIZE    32
    347345        struct fm_patch *patch_table[OPL3_PATCH_HASH_SIZE];

  • GPL/trunk/alsa-kernel/include/sound/pcm.h

    r464 r587  
    7474                    snd_pcm_uframes_t pos,
    7575                    void __user *buf, snd_pcm_uframes_t count);
    76         int (*silence)(struct snd_pcm_substream *substream, int channel, 
     76        int (*silence)(struct snd_pcm_substream *substream, int channel,
    7777                       snd_pcm_uframes_t pos, snd_pcm_uframes_t count);
    7878        struct page *(*page)(struct snd_pcm_substream *substream,
    … …  
    216216
    217217struct snd_pcm_hw_constraints {
    218         struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - 
     218        struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK -
    219219                         SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
    220220        struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
    … …  
    330330        int tstamp_type;                /* timestamp type */
    331331
    332         /* -- DMA -- */           
     332        /* -- DMA -- */
    333333        unsigned char *dma_area;        /* DMA area */
    334334        dma_addr_t dma_addr;            /* physical bus address (not accessible from main CPU) */
    … …  
    538538} while (0)
    539539
     540#ifdef TARGET_OS2
    540541#define snd_pcm_group_for_each_entry(s, substream) \
    541542        list_for_each_entry(s, &substream->group->substreams, link_list, struct snd_pcm_substream)
     543#else   
     544#define snd_pcm_group_for_each_entry(s, substream) \
     545        list_for_each_entry(s, &substream->group->substreams, link_list)
     546#endif
    542547
    543548static inline int snd_pcm_running(struct snd_pcm_substream *substream)
    … …  
    592597        snd_pcm_sframes_t avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr;
    593598#if defined TARGET_OS2
    594        if ( runtime->buffer_size > runtime->control->appl_ptr) 
    595           avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr; 
    596        else 
    597        { 
    598  
    599           avail = runtime->control->appl_ptr - runtime->status->hw_ptr; 
    600           if ( avail > runtime->buffer_size ) 
    601              avail = 0; 
    602           else 
    603              avail = runtime->buffer_size - avail; 
    604        } 
    605 #endif /* TARGET_OS2  */ 
     599       if ( runtime->buffer_size > runtime->control->appl_ptr)
     600          avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr;
     601       else
     602       {
     603
     604          avail = runtime->control->appl_ptr - runtime->status->hw_ptr;
     605          if ( avail > runtime->buffer_size )
     606             avail = 0;
     607          else
     608             avail = runtime->buffer_size - avail;
     609       }
     610#endif /* TARGET_OS2  */
    606611        if (avail < 0)
    607612                avail += runtime->boundary;
    … …  
    706711}
    707712
    708 static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream, 
     713static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream,
    709714                                        struct snd_pcm_substream *master)
    710715{
    … …  
    763768void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c);
    764769void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c);
    765 void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b, 
     770void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,
    766771                          unsigned int k, struct snd_interval *c);
    767772void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
    … …  
    788793                                 unsigned int min, unsigned int max);
    789794int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var);
    790 int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, 
     795int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
    791796                               unsigned int cond,
    792797                               snd_pcm_hw_param_t var,
    793798                               struct snd_pcm_hw_constraint_list *l);
    794 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, 
     799int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,
    795800                                  unsigned int cond,
    796801                                  snd_pcm_hw_param_t var,
    797802                                  struct snd_pcm_hw_constraint_ratnums *r);
    798 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, 
     803int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,
    799804                                  unsigned int cond,
    800805                                  snd_pcm_hw_param_t var,
    801806                                  struct snd_pcm_hw_constraint_ratdens *r);
    802 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, 
     807int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,
    803808                                 unsigned int cond,
    804809                                 unsigned int width,
    … …  
    848853int snd_pcm_lib_interleave_len(struct snd_pcm_substream *substream);
    849854int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
    850                       unsigned int cmd, void *arg);                     
     855                      unsigned int cmd, void *arg);
    851856int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream);
    852857int snd_pcm_playback_xrun_check(struct snd_pcm_substream *substream);

  • GPL/trunk/alsa-kernel/include/sound/seq_kernel.h

    r358 r587  
    7676
    7777/* interface for kernel client */
    78 #ifndef TARGET_OS2
    7978int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
    8079                                 const char *name_fmt, ...)
    8180        __attribute__ ((format (printf, 3, 4)));
    82 #else
    83 int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
    84                                  const char *name_fmt, ...);
    85 #endif
    8681int snd_seq_delete_kernel_client(int client);
    8782int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event *ev, int atomic, int hop);

  • GPL/trunk/alsa-kernel/pci/ac97/Makefile

    r398 r587  
     1!ifndef %ROOT
     2!error ROOT is not defined. Please check your SETENV.CMD.
     3!endif
     4ROOT=$(%ROOT)
     5
     6!include $(ROOT)\tools\header.mif
     7
     8
     9#===================================================================
    110#
    2 # Makefile for ALSA
    3 # Copyright (c) 2001 by Jaroslav Kysela <perex@perex.cz>
     11#   List of source files
    412#
     13#===================================================================
     14FILES = ac97_codec.obj ac97_pcm.obj ac97_proc.obj
    515
    6 snd-ac97-codec-y := ac97_codec.o ac97_pcm.o
    7 snd-ac97-codec-$(CONFIG_PROC_FS) += ac97_proc.o
     16TARGET = ac97
    817
    9 # Toplevel Module Dependency
    10 obj-$(CONFIG_SND_AC97_CODEC) += snd-ac97-codec.o
     18LNKFILE = $(OBJDIR)\$(TARGET).lnk
     19
     20
     21#===================================================================
     22#
     23#   Specific dependencies
     24#
     25#===================================================================
     26all: $(OBJDIR)\$(TARGET).lib
     27
     28
     29$(LNKFILE): Makefile
     30    @%create $(LNKFILE)
     31    @for %f in ($(FILES)) do @%append $(LNKFILE) -+$(OBJDIR)\%f
     32
     33$(OBJDIR)\$(TARGET).lib: $(LNKFILE) $(FILES)
     34    $(LIB) $(OBJDIR)\$(TARGET).lib @$(LNKFILE)
     35    copy $(OBJDIR)\$(TARGET).lib $(ALSA_LIB)
     36
     37clean: .SYMBOLIC
     38    -@rm *.err
     39    @if exist obj @rm.exe -r obj
     40    @if exist bin @rm.exe -r bin
     41

  • GPL/trunk/alsa-kernel/pci/au88x0/Makefile

    r398 r587  
    1 snd-au8810-objs := au8810.o
    2 snd-au8820-objs := au8820.o
    3 snd-au8830-objs := au8830.o
     1!ifndef %ROOT
     2!error ROOT is not defined. Please check your SETENV.CMD.
     3!endif
     4ROOT=$(%ROOT)
    45
    5 obj-$(CONFIG_SND_AU8810) += snd-au8810.o
    6 obj-$(CONFIG_SND_AU8820) += snd-au8820.o
    7 obj-$(CONFIG_SND_AU8830) += snd-au8830.o
     6!include $(ROOT)\tools\header.mif
     7
     8
     9#===================================================================
     10#
     11#   List of source files
     12#
     13#===================================================================
     14# au8810.obj au8810_core.obj au8810_pcm.obj au8810_mixer.obj au8810_mpu401.obj au8810_eq.obj
     15FILES = au8820.obj au8820_core.obj au8820_pcm.obj au8820_mixer.obj au8820_mpu401.obj au8820_synth.obj
     16# au8830.obj au8830_core.obj au8830_pcm.obj au8830_mixer.obj au8830_mpu401.obj au8830_eq.obj au8830_synth.obj
     17
     18TARGET = au88xx
     19
     20LNKFILE = $(OBJDIR)\$(TARGET).lnk
     21
     22
     23#===================================================================
     24#
     25#   Specific dependencies
     26#
     27#===================================================================
     28all: $(OBJDIR)\$(TARGET).lib
     29
     30
     31$(LNKFILE): Makefile
     32    @%create $(LNKFILE)
     33    @for %f in ($(FILES)) do @%append $(LNKFILE) -+$(OBJDIR)\%f
     34
     35$(OBJDIR)\$(TARGET).lib: $(LNKFILE) $(FILES)
     36    $(LIB) $(OBJDIR)\$(TARGET).lib @$(LNKFILE)
     37    copy $(OBJDIR)\$(TARGET).lib $(ALSA_LIB)
     38
     39clean: .SYMBOLIC
     40    -@rm  *.err
     41    @if exist obj @rm.exe -r obj
     42    @if exist bin @rm.exe -r bin
     43

  • GPL/trunk/alsa-kernel/pci/ca0106/Makefile

    r398 r587  
    1 snd-ca0106-objs := ca0106_main.o ca0106_proc.o ca0106_mixer.o ca_midi.o
     1!ifndef %ROOT
     2!error ROOT is not defined. Please check your SETENV.CMD.
     3!endif
     4ROOT=$(%ROOT)
    25
    3 obj-$(CONFIG_SND_CA0106) += snd-ca0106.o
     6!include $(ROOT)\tools\header.mif
     7
     8
     9#===================================================================
     10#
     11#   List of source files
     12#
     13#===================================================================
     14FILES = ca0106_main.obj ca0106_proc.obj ca0106_mixer.obj &
     15  ca_midi.obj
     16
     17TARGET = ca0106
     18
     19LNKFILE = $(OBJDIR)\$(TARGET).lnk
     20
     21
     22#===================================================================
     23#
     24#   Specific dependencies
     25#
     26#===================================================================
     27all: $(OBJDIR)\$(TARGET).lib
     28
     29
     30$(LNKFILE): Makefile
     31    @%create $(LNKFILE)
     32    @for %f in ($(FILES)) do @%append $(LNKFILE) -+$(OBJDIR)\%f
     33
     34$(OBJDIR)\$(TARGET).lib: $(LNKFILE) $(FILES)
     35    $(LIB) $(OBJDIR)\$(TARGET).lib @$(LNKFILE)
     36    copy $(OBJDIR)\$(TARGET).lib $(ALSA_LIB)
     37
     38clean: .SYMBOLIC
     39    -@rm *.err
     40    @if exist obj @rm.exe -r obj
     41    @if exist bin @rm.exe -r bin
     42

  • GPL/trunk/alsa-kernel/pci/ymfpci/ymfpci_main.c

    r464 r587  
    847847{
    848848        .info =                 (SNDRV_PCM_INFO_MMAP |
    849                                  SNDRV_PCM_INFO_MMAP_VALID | 
     849                                 SNDRV_PCM_INFO_MMAP_VALID |
    850850                                 SNDRV_PCM_INFO_INTERLEAVED |
    851851                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
    … …  
    19581958 */
    19591959
    1960 static void snd_ymfpci_proc_read(struct snd_info_entry *entry, 
     1960static void snd_ymfpci_proc_read(struct snd_info_entry *entry,
    19611961                                 struct snd_info_buffer *buffer)
    19621962{
    … …  
    21122112           covered with the kernel page allocation mechanism */
    21132113        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
    2114                                 size, &chip->work_ptr) < 0) 
     2114                                size, &chip->work_ptr) < 0)
    21152115                return -ENOMEM;
    21162116        ptr = chip->work_ptr.area;
    … …  
    22182218#if 0
    22192219        /* FIXME: temporarily disabled, otherwise we cannot fire up
    2220          * the chip again unless reboot.  ACPI bug?
     2220         * the chip again unless reboot.
    22212221         */
    22222222        pci_set_power_state(chip->pci, 3);

  • GPL/trunk/clean.cmd

    r111 r587  
    88wmake -ms -f makefile.os2 DEBUG=1 clean
    99SET KEE=
    10 del drv32\bin\Release.W4\*
    11 del drv32\bin\Release.kee\*
     10del drv32\bin\Release\*

  • GPL/trunk/drv32/dispatch.c

    r542 r587  
    3030#include <devhelp.h>
    3131#include <devtype.h>
    32 #include <devrp.h>
     32#include <strategy.h>
    3333#include "devown.h"
    3434#include <ossidc.h>
    … …  
    3636#include <version.h>
    3737
    38 extern "C" int cdecl printk(const char * fmt, ...);
     38extern int cdecl printk(const char * fmt, ...);
    3939//******************************************************************************
    4040// Dispatch IOCtl requests received from the Strategy routine
    4141//******************************************************************************
    42 extern "C" int GetUniaudCardInfo(ULONG deviceid, void *info);
    43 extern "C" int GetUniaudControlNum(ULONG deviceid);
    44 extern "C" int GetUniaudControls(ULONG deviceid, void *pids);
    45 extern "C" int GetUniaudControlInfo(ULONG deviceid, ULONG id, void *info);
    46 extern "C" int GetUniaudControlValueGet(ULONG deviceid, ULONG id, void *value);
    47 extern "C" int GetUniaudControlValuePut(ULONG deviceid, ULONG id, void *value);
    48 extern "C" int GetNumberOfPcm(int card_id);
    49 extern "C" int GetUniaudPcmCaps(ULONG deviceid, void *caps);
    50 extern "C" int SetPCMInstance(int card_id, int pcm);
    51 extern "C" int WaitForControlChange(int card_id, int timeout);
    52 extern "C" int GetNumberOfCards(void);
    53 extern "C" OSSRET OSS32_WaveOpen(ULONG deviceid, ULONG streamtype, OSSSTREAMID *pStreamId, int pcm, USHORT fileid);
    54 extern "C" OSSRET OSS32_WaveClose(OSSSTREAMID streamid);
    55 extern "C" int UniaudIoctlHWRefine(OSSSTREAMID streamid, void *pHwParams);
    56 extern "C" int UniaudIoctlHWParamSet(OSSSTREAMID streamid, void *pHwParams);
    57 extern "C" int UniaudIoctlSWParamSet(OSSSTREAMID streamid, void *pSwParams);
    58 extern "C" int UniaudIoctlPCMStatus(OSSSTREAMID streamid, void *pstatus);
    59 extern "C" int UniaudIoctlPCMWrite(OSSSTREAMID streamid, char *buf, int size);
    60 extern "C" int UniaudIoctlPCMRead(OSSSTREAMID streamid, char *buf, int size);
    61 extern "C" int UniaudIoctlPCMPrepare(OSSSTREAMID streamid);
    62 extern "C" int UniaudIoctlPCMStart(OSSSTREAMID streamid);
    63 extern "C" int UniaudIoctlPCMDrop(OSSSTREAMID streamid);
    64 extern "C" int UniaudIoctlPCMResume(OSSSTREAMID streamid, int pause);
    65 extern "C" void UniaudCloseAll(USHORT fileid);
    66 extern "C" int WaitForPCMInterrupt(void *file, int timeout);
    67 extern "C" int unlock_all;
    68 extern "C" int OSS32_CloseUNI16(void);
    69 extern "C" int UniaudCtlGetPowerState(ULONG deviceid, void *state);
    70 extern "C" int UniaudCtlSetPowerState(ULONG deviceid, void *state);
     42extern int GetUniaudCardInfo(ULONG deviceid, void *info);
     43extern int GetUniaudControlNum(ULONG deviceid);
     44extern int GetUniaudControls(ULONG deviceid, void *pids);
     45extern int GetUniaudControlInfo(ULONG deviceid, ULONG id, void *info);
     46extern int GetUniaudControlValueGet(ULONG deviceid, ULONG id, void *value);
     47extern int GetUniaudControlValuePut(ULONG deviceid, ULONG id, void *value);
     48extern int GetNumberOfPcm(int card_id);
     49extern int GetUniaudPcmCaps(ULONG deviceid, void *caps);
     50extern int SetPCMInstance(int card_id, int pcm);
     51extern int WaitForControlChange(int card_id, int timeout);
     52extern int GetNumberOfCards(void);
     53extern OSSRET OSS32_WaveOpen(ULONG deviceid, ULONG streamtype, OSSSTREAMID *pStreamId, int pcm, USHORT fileid);
     54extern OSSRET OSS32_WaveClose(OSSSTREAMID streamid);
     55extern int UniaudIoctlHWRefine(OSSSTREAMID streamid, void *pHwParams);
     56extern int UniaudIoctlHWParamSet(OSSSTREAMID streamid, void *pHwParams);
     57extern int UniaudIoctlSWParamSet(OSSSTREAMID streamid, void *pSwParams);
     58extern int UniaudIoctlPCMStatus(OSSSTREAMID streamid, void *pstatus);
     59extern int UniaudIoctlPCMWrite(OSSSTREAMID streamid, char *buf, int size);
     60extern int UniaudIoctlPCMRead(OSSSTREAMID streamid, char *buf, int size);
     61extern int UniaudIoctlPCMPrepare(OSSSTREAMID streamid);
     62extern int UniaudIoctlPCMStart(OSSSTREAMID streamid);
     63extern int UniaudIoctlPCMDrop(OSSSTREAMID streamid);
     64extern int UniaudIoctlPCMResume(OSSSTREAMID streamid, int pause);
     65extern void UniaudCloseAll(USHORT fileid);
     66extern int WaitForPCMInterrupt(void *file, int timeout);
     67extern int unlock_all;
     68extern int OSS32_CloseUNI16(void);
     69extern int UniaudCtlGetPowerState(ULONG deviceid, void *state);
     70extern int UniaudCtlSetPowerState(ULONG deviceid, void *state);
    7171
    7272typedef UCHAR LOCKHANDLE[12];
    … …  
    8585#pragma pack()
    8686
    87 ULONG StratIOCtl(RP __far* _rp)
     87ULONG StratIOCtl(REQPACKET __far* rp)
    8888{
    89     RPIOCtl __far* rp = (RPIOCtl __far*)_rp;
    9089    USHORT rc = 0;;
    9190    LOCKHANDLE lhParm, lhData;
    … …  
    9695    ULONG ctl_id;
    9796
    98     if (rp->Category != CAT_IOCTL_OSS32)
    99     {
    100 //        printk("not our cat %x. func %x\n", rp->Category, rp->Function);
     97    if (rp->ioctl.bCategory != CAT_IOCTL_OSS32)
     98    {
     99        //printk("not our cat %x. func %x\n", rp->Category, rp->Function);
    101100        // not our category, exit with error
    102         return (RPERR_COMMAND | RPDONE);
     101        return (RPERR_BADCOMMAND | RPDONE);
    103102    }
    104103
    105 #ifdef DEBUG
     104    #ifdef DEBUG
    106105    //printk("StratIOCtl 0x%x\n", rp->Function);
    107 #endif
    108 //    printk("cmd: %x, len: %i, pack: %x\n",rp->Function, rp->ParmLength, rp->ParmPacket);
     106    #endif
     107    //    printk("cmd: %x, len: %i, pack: %x\n",rp->Function, rp->ioctl.usParmLen, rp->ParmPacket);
    109108    // work with Parm Packet
    110     if ((rp->ParmLength != 0 ||
    111          rp->Function == IOCTL_OSS32_ATTACH /*16 bit ioctl*/) &&
    112         ((rp->ParmPacket & 0xfffcffff) != 0))
     109    if ((rp->ioctl.usParmLen != 0 ||
     110         rp->ioctl.bFunction == IOCTL_OSS32_ATTACH /*16 bit ioctl*/) &&
     111        ((rp->ioctl.pvParm & 0xfffcffff) != 0))
    113112    {
    114113        // got Parm Packet
    115         rc = DevVirtToLin((USHORT)((ULONG)(rp->ParmPacket) >> 16),
    116                           (ULONG)((USHORT)(rp->ParmPacket)),
     114        rc = DevVirtToLin((USHORT)((ULONG)(rp->ioctl.pvParm) >> 16),
     115                          (ULONG)((USHORT)(rp->ioctl.pvParm)),
    117116                          (UCHAR * __far *)&linParm);
    118117
    119118        if (rc == 0)
    120119        {
    121             if (rp->Function == IOCTL_OSS32_ATTACH)
    122             {
    123                 rc = DevVMLock(VMDHL_LONG,
    124                            (ULONG)linParm,
    125                            4,
    126                            (LINEAR)-1L,
    127                            lhParm,
    128                                (UCHAR*)&pages);
    129             }else
    130             {
    131                 rc = DevVMLock(VMDHL_LONG,
    132                            (ULONG)linParm,
    133                            rp->ParmLength,
    134                            (LINEAR)-1L,
    135                                lhParm,
    136                                (UCHAR*)&pages);
     120            if (rp->ioctl.bFunction == IOCTL_OSS32_ATTACH)
     121            {
     122                rc = DevVMLock(VMDHL_LONG, (ULONG)linParm, 4, (LINEAR)-1L, lhParm, (UCHAR*)&pages);
     123            }
     124            else
     125            {
     126                rc = DevVMLock(VMDHL_LONG, (ULONG)linParm, rp->ioctl.usParmLen, (LINEAR)-1L, lhParm, (UCHAR*)&pages);
    137127            }
    138128
    … …  
    154144
    155145    // work with Data Packet
    156     if ((rp->DataLength != 0) &&
    157         ((rp->DataPacket & 0xfffcffff) != 0))
     146    if ((rp->ioctl.usDataLen != 0) &&
     147        ((rp->ioctl.pvData & 0xfffcffff) != 0))
    158148    {
    159149        // got Data Packet
    160         rc = DevVirtToLin((USHORT)((ULONG)(rp->DataPacket) >> 16),
    161                           (ULONG)((USHORT)(rp->DataPacket)),
     150        rc = DevVirtToLin((USHORT)((ULONG)(rp->ioctl.pvData) >> 16),
     151                          (ULONG)((USHORT)(rp->ioctl.pvData)),
    162152                          (UCHAR * __far *)&linData);
    163153        if (rc == 0)
    164154        {
    165             rc = DevVMLock(VMDHL_LONG,
    166                            (ULONG)linData,
    167                            rp->DataLength,
    168                            (LINEAR)-1L,
    169                            lhData,
     155            rc = DevVMLock(VMDHL_LONG, (ULONG)linData, rp->ioctl.usDataLen, (LINEAR)-1L, lhData,
    170156                           (UCHAR*)&pages);
    171157        } else
    … …  
    193179    rc = RPDONE; // ok by default
    194180
    195     switch(rp->Function)
     181    switch(rp->ioctl.bFunction)
    196182    {
    197183    case IOCTL_OSS32_ATTACH:
    … …  
    199185            card_id = (ULONG) *linParm;
    200186            // Check if audio init was successful
    201             if (OSS32_QueryNames(card_id, NULL, 0,
    202                                  NULL, 0, FALSE) != OSSERR_SUCCESS)
     187            if (OSS32_QueryNames(card_id, NULL, 0, NULL, 0, FALSE) != OSSERR_SUCCESS)
    203188            {
    204189                rc = RPERR_GENERAL | RPDONE;
    … …  
    208193    case IOCTL_OSS32_VERSION:
    209194        {
    210             if (rp->DataLength < sizeof(ULONG))
     195            if (rp->ioctl.usDataLen < sizeof(ULONG))
    211196            {
    212197                // invalid Data Pkt
    … …  
    221206    case IOCTL_OSS32_GET_PCM_NUM:
    222207        {
    223             if (rp->DataLength < sizeof(ULONG))
     208            if (rp->ioctl.usDataLen < sizeof(ULONG))
    224209            {
    225210                // invalid Data Pkt
    … …  
    234219
    235220    case IOCTL_OSS32_CARDS_NUM:
    236         if (rp->DataLength < sizeof(ULONG))
     221        if (rp->ioctl.usDataLen < sizeof(ULONG))
    237222        {
    238223            // invalid Data Pkt
    … …  
    246231    case IOCTL_OSS32_PCM_CAPS:
    247232        {
    248             if (rp->DataLength < sizeof(ULONG))
     233            if (rp->ioctl.usDataLen < sizeof(ULONG))
    249234            {
    250235                // invalid Data Pkt
    … …  
    259244    case IOCTL_OSS32_CARD_INFO:
    260245        {
    261             if (rp->DataLength < sizeof(ULONG))
     246            if (rp->ioctl.usDataLen < sizeof(ULONG))
    262247            {
    263248                // invalid Data Pkt
    … …  
    272257    case IOCTL_OSS32_GET_POWER_STATE:
    273258        {
    274             if (rp->DataLength < sizeof(ULONG))
     259            if (rp->ioctl.usDataLen < sizeof(ULONG))
    275260            {
    276261                // invalid Data Pkt
    … …  
    285270    case IOCTL_OSS32_SET_POWER_STATE:
    286271        {
    287             if (rp->DataLength < sizeof(ULONG))
     272            if (rp->ioctl.usDataLen < sizeof(ULONG))
    288273            {
    289274                // invalid Data Pkt
    … …  
    298283    case IOCTL_OSS32_GET_CNTRLS_NUM:
    299284        {
    300             if (rp->DataLength < sizeof(ULONG))
     285            if (rp->ioctl.usDataLen < sizeof(ULONG))
    301286            {
    302287                // invalid Data Pkt
    … …  
    313298    case IOCTL_OSS32_GET_CNTRLS:
    314299        {
    315             if (rp->DataLength < sizeof(ULONG))
     300            if (rp->ioctl.usDataLen < sizeof(ULONG))
    316301            {
    317302                // invalid Data Pkt
    … …  
    327312        {
    328313
    329             if (rp->DataLength < sizeof(ULONG))
    330             {
    331                 // invalid Data Pkt
    332                 rc = RPERR_PARAMETER | RPDONE;
    333                 break;
    334             }
    335 
    336             if (rp->ParmLength < sizeof(ULONG))
     314            if (rp->ioctl.usDataLen < sizeof(ULONG))
     315            {
     316                // invalid Data Pkt
     317                rc = RPERR_PARAMETER | RPDONE;
     318                break;
     319            }
     320
     321            if (rp->ioctl.usParmLen < sizeof(ULONG))
    337322            {
    338323                // invalid Data Pkt
    … …  
    351336    case IOCTL_OSS32_CNTRL_GET:
    352337        {
    353             if (rp->DataLength < sizeof(ULONG))
    354             {
    355                 // invalid Data Pkt
    356                 rc = RPERR_PARAMETER | RPDONE;
    357                 break;
    358             }
    359 
    360             if (rp->ParmLength < sizeof(ULONG))
     338            if (rp->ioctl.usDataLen < sizeof(ULONG))
     339            {
     340                // invalid Data Pkt
     341                rc = RPERR_PARAMETER | RPDONE;
     342                break;
     343            }
     344
     345            if (rp->ioctl.usParmLen < sizeof(ULONG))
    361346            {
    362347                // invalid Data Pkt
    … …  
    376361        {
    377362
    378             if (rp->DataLength < sizeof(ULONG)) {
    379                 // invalid Data Pkt
    380                 rc = RPERR_PARAMETER | RPDONE;
    381                 break;
    382             }
    383 
    384             if (rp->ParmLength < sizeof(ULONG)) {
     363            if (rp->ioctl.usDataLen < sizeof(ULONG)) {
     364                // invalid Data Pkt
     365                rc = RPERR_PARAMETER | RPDONE;
     366                break;
     367            }
     368
     369            if (rp->ioctl.usParmLen < sizeof(ULONG)) {
    385370                // invalid Data Pkt
    386371                rc = RPERR_PARAMETER | RPDONE;
    … …  
    399384        {
    400385
    401             if (rp->ParmLength < sizeof(ULONG))
     386            if (rp->ioctl.usParmLen < sizeof(ULONG))
    402387            {
    403388                // invalid Data Pkt
    … …  
    414399    case IOCTL_OSS32_CNTRL_WAIT:
    415400        {
    416             if (rp->DataLength < sizeof(ULONG))
     401            if (rp->ioctl.usDataLen < sizeof(ULONG))
    417402            {
    418403                // invalid Data Pkt
    … …  
    430415            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
    431416            // close all pcms from uniaud16 first
    432             pcm->ret = OSS32_WaveOpen(pcm->deviceid, pcm->streamtype, pData,  pcm->pcm, rp->FileID);
     417            pcm->ret = OSS32_WaveOpen(pcm->deviceid, pcm->streamtype, pData,  pcm->pcm, rp->ioctl.usSysFileNum);
    433418        }
    434419        break;
    … …  
    536521    default:
    537522        {
    538             printk("invalid function code %i\n",rp->Function);
     523            printk("invalid function code %i\n",rp->ioctl.bFunction);
    539524            // invalid function code
    540525            rc = RPERR_PARAMETER | RPDONE;
    … …  
    561546// Dispatch Close requests received from the strategy routine
    562547//******************************************************************************
    563 ULONG StratClose(RP __far* _rp)
     548ULONG StratClose(REQPACKET __far* rp)
    564549{
    565   RPOpenClose __far* rp = (RPOpenClose __far*)_rp;
    566 
    567550  // only called if device successfully opened
    568 //  printk("strat close\n");
     551  //  printk("strat close\n");
    569552  numOS2Opens--;
    570553
    571   UniaudCloseAll(rp->FileID);
     554  UniaudCloseAll(rp->open_close.usSysFileNum);
    572555
    573556  if (numOS2Opens == 0) {
    574         deviceOwner = DEV_NO_OWNER;
     557          deviceOwner = DEV_NO_OWNER;
    575558  }
    576559  return(RPDONE);
    577560}
    578 //******************************************************************************
    579 //******************************************************************************
     561

  • GPL/trunk/drv32/idc.c

    r549 r587  
    2323 */
    2424
    25 extern "C" {               // 16-bit header files are not C++ aware
     25//DAZ extern "C" {               // 16-bit header files are not C++ aware
    2626#define INCL_NOPMAPI
    2727#define INCL_DOSINFOSEG
    2828#include <os2.h>
    29 }
     29//DAZ }
    3030#include <devtype.h>
    3131#include <devhelp.h>
    32 #include <strategy.h>
     32//#include <strategy.h>
    3333#include <ossidc32.h>
    3434#include <irqos2.h>
    … …  
    3838//16:32 address of 16 bits pdd idc handler
    3939IDC16_HANDLER idc16_PddHandler = 0;
    40 extern "C" int pcm_device;
     40extern int pcm_device;
    4141WORD32 OSS32IDC(ULONG cmd, PIDC32_PACKET pPacket);
    42 extern "C" BOOL fRewired; //pci.c
     42extern BOOL fRewired; //pci.c
    4343
    4444//packet pointer must reference a structure on the stack
    4545
    46 OSSRET AlsaIDC(ULONG cmd, ULONG packet);
    4746#pragma aux AlsaIDC "ALSA_IDC" parm reverse [ecx edx]
    4847OSSRET AlsaIDC(ULONG cmd, ULONG packet)

  • GPL/trunk/drv32/init.c

    r535 r587  
    3131#include <devhelp.h>
    3232#include <devtype.h>
    33 #include <devrp.h>
     33//DAZ #include <devrp.h>
     34#include <strategy.h>
    3435#include "devown.h"
    3536#include <version.h>
    … …  
    6768} MSG_TABLE;
    6869
    69 extern "C" FARPTR16 MSG_TABLE32;
    70 extern "C" char szLastALSAError1[];
    71 extern "C" char szLastALSAError2[];
    72 extern "C" int sprintf (char *buffer, const char *format, ...);
    73 
    74 extern "C" APIRET APIENTRY DOS16OPEN(PSZ pszFileName, PHFILE phf, PULONG pulAction, ULONG cbFile, ULONG ulAttribute, ULONG fsOpenFlags, ULONG fsOpenMode, PEAOP2 peaop2 );
    75 extern "C" APIRET APIENTRY DOS16CLOSE(HFILE hFile);
    76 extern "C" APIRET APIENTRY DOS16WRITE(HFILE hFile, PVOID pBuffer, ULONG cbWrite, PULONG pcbActual);
    77 extern "C" void SaveBuffer(void);
     70extern FARPTR16 MSG_TABLE32;
     71extern char szLastALSAError1[];
     72extern char szLastALSAError2[];
     73extern int sprintf (char *buffer, const char *format, ...);
     74
     75extern APIRET APIENTRY DOS16OPEN(PSZ pszFileName, PHFILE phf, PULONG pulAction, ULONG cbFile, ULONG ulAttribute, ULONG fsOpenFlags, ULONG fsOpenMode, PEAOP2 peaop2 );
     76extern APIRET APIENTRY DOS16CLOSE(HFILE hFile);
     77extern APIRET APIENTRY DOS16WRITE(HFILE hFile, PVOID pBuffer, ULONG cbWrite, PULONG pcbActual);
     78extern void SaveBuffer(void);
    7879
    7980#define VMDHA_FIXED             0x0002
    8081
    81 extern "C" APIRET VMAlloc(ULONG size, ULONG flags, char NEAR* *pAddr);
     82extern APIRET VMAlloc(ULONG size, ULONG flags, char NEAR* *pAddr);
    8283
    8384//Print messages with DosWrite when init is done or has failed (see startup.asm)
    … …  
    8990
    9091  for(i=0;i<length;i++) {
    91         str16[msg->MsgLength + i] = str[i];
     92  str16[msg->MsgLength + i] = str[i];
    9293  }
    9394  str16[msg->MsgLength + length] = 0;
    … …  
    116117    segsize = OffsetFinalDS32 - ((OffsetBeginDS32) & ~0xFFF);
    117118    if(segsize & 0xFFF) {
    118             segsize += PAGE_SIZE;
     119      segsize += PAGE_SIZE;
    119120    }
    120121    segsize &= ~0xFFF;
    … …  
    134135                   (LINEAR)&PgCount)) {
    135136#endif
    136             return(1);
     137      return(1);
    137138    }
    138139    /*
    … …  
    141142    segsize = OffsetFinalCS32 - ((OffsetBeginCS32) & ~0xFFF);
    142143    if(segsize & 0xFFF) {
    143             segsize += PAGE_SIZE;
     144      segsize += PAGE_SIZE;
    144145    }
    145146    segsize &= ~0xFFF;
    … …  
    159160                 (LINEAR)&PgCount)) {
    160161#endif
    161             return(1);
     162      return(1);
    162163    }
    163164    return 0;
    … …  
    195196#endif
    196197// Initialize device driver
    197 WORD32 DiscardableInit(RPInit __far* rp)
    198 {
    199     char        debugmsg[64];
    200     char FAR48 *args;
    201 
    202 #ifdef KEE
    203     GetTKSSBase();
    204 #endif
    205 
    206     if(LockSegments()) {
    207         WriteString(ERR_ERROR, sizeof(ERR_ERROR)-1);
    208         WriteString(ERR_LOCK, sizeof(ERR_LOCK)-1);
    209         return RPDONE | RPERR_COMMAND;
    210     }
    211 
    212         DebugLevel = 1;
    213     rp->Out.FinalCS = 0;
    214     rp->Out.FinalDS = 0;
    215 
    216         if ( szprintBuf == 0 ) {
    217                 VMAlloc( DBG_MAX_BUF_SIZE, VMDHA_FIXED, &szprintBuf );
    218                 if (szprintBuf) {
    219                         memset( szprintBuf, 0, DBG_MAX_BUF_SIZE );
    220                         wrOffset= 0;
    221                 }
    222         }
    223         if (!HeapInit(HEAP_SIZE)) {
    224                 rprintf(("HeapInit failed!"));
    225         }
    226 
    227     args = MAKE_FARPTR32(rp->In.Args);
    228     GetParms(args);
    229 
    230 #ifdef DEBUG
    231         rprintf(("Uniaud32 version %s-DEBUG",UNIAUD_VERSION));
    232 #else
    233         rprintf(("Uniaud32 version %s",UNIAUD_VERSION));
    234 #endif
    235 
    236     if(fVerbose) {
    237         WriteString(szALSA, sizeof(szALSA)-1);
    238         WriteString(szCopyRight3, sizeof(szCopyRight3)-1);
    239         WriteString(szCopyRight2, sizeof(szCopyRight2)-1);
    240     }
    241 
    242 
    243     if(fDebug) {
    244         sprintf(debugmsg, szCodeStartEnd, OffsetBeginCS32, OffsetFinalCS32);
    245         WriteString(debugmsg, strlen(debugmsg));
    246     }
    247 
    248     //get the current time (to force retrieval of GIS pointer)
    249     os2gettimemsec();
    250 
    251     char szMixerName[64];
    252     char szDeviceName[128];
    253 
    254     if(OSS32_Initialize() != OSSERR_SUCCESS)
    255     {
    256         WriteString(ERR_ERROR, sizeof(ERR_ERROR)-1);
    257         WriteString(ERR_INIT, sizeof(ERR_INIT)-1);
    258         if(szLastALSAError1[0]) {
    259             WriteString(szLastALSAError1, strlen(szLastALSAError1));
    260         }
    261         if(szLastALSAError2[0]) {
    262             WriteString(szLastALSAError2, strlen(szLastALSAError2));
    263         }
    264         // !! dont exit when error !! return RPDONE | RPERR_COMMAND;
    265     } else if (OSS32_QueryNames(OSS32_DEFAULT_DEVICE, szDeviceName,
    266                                 sizeof(szDeviceName),szMixerName,
    267                                 sizeof(szMixerName), TRUE) != OSSERR_SUCCESS)
    268     {
    269         WriteString(ERR_ERROR, sizeof(ERR_ERROR)-1);
    270         WriteString(ERR_NAMES, sizeof(ERR_INIT)-1);
    271         if(szLastALSAError1[0]) {
    272             WriteString(szLastALSAError1, strlen(szLastALSAError1));
    273         }
    274         if(szLastALSAError2[0]) {
    275             WriteString(szLastALSAError2, strlen(szLastALSAError2));
    276         }
    277 
    278         // !! dont exit when error !! return RPDONE | RPERR_COMMAND;
    279     }
    280     else
    281     if(fVerbose) {
     198WORD32 DiscardableInit(REQPACKET __far* rp)
     199{
     200  char debugmsg[64];
     201  char FAR48 *args;
     202
     203#ifdef KEE
     204  GetTKSSBase();
     205#endif
     206
     207  if(LockSegments())
     208  {
     209    WriteString(ERR_ERROR, sizeof(ERR_ERROR)-1);
     210    WriteString(ERR_LOCK, sizeof(ERR_LOCK)-1);
     211    return RPDONE | RPERR_BADCOMMAND;
     212  }
     213
     214  DebugLevel = 1;
     215  rp->init_out.usCodeEnd = 0;
     216  rp->init_out.usDataEnd = 0;
     217
     218  if ( szprintBuf == 0 )
     219  {
     220    VMAlloc( DBG_MAX_BUF_SIZE, VMDHA_FIXED, &szprintBuf );
     221    if (szprintBuf)
     222    {
     223      memset( szprintBuf, 0, DBG_MAX_BUF_SIZE );
     224      wrOffset= 0;
     225    }
     226  }
     227  if (!HeapInit(HEAP_SIZE))
     228  {
     229    rprintf(("HeapInit failed!"));
     230  }
     231
     232  args = MAKE_FARPTR32(rp->init_in.szArgs);
     233  GetParms(args);
     234
     235  #ifdef DEBUG
     236  rprintf(("Uniaud32 version %s-DEBUG",UNIAUD_VERSION));
     237  #else
     238  rprintf(("Uniaud32 version %s",UNIAUD_VERSION));
     239  #endif
     240
     241  if(fVerbose)
     242  {
     243    WriteString(szALSA, sizeof(szALSA)-1);
     244    WriteString(szCopyRight3, sizeof(szCopyRight3)-1);
     245    WriteString(szCopyRight2, sizeof(szCopyRight2)-1);
     246  }
     247
     248  if(fDebug)
     249  {
     250    sprintf(debugmsg, szCodeStartEnd, OffsetBeginCS32, OffsetFinalCS32);
     251    WriteString(debugmsg, strlen(debugmsg));
     252  }
     253
     254  //get the current time (to force retrieval of GIS pointer)
     255  os2gettimemsec();
     256
     257  char szMixerName[64];
     258  char szDeviceName[128];
     259
     260  if(OSS32_Initialize() != OSSERR_SUCCESS)
     261  {
     262    WriteString(ERR_ERROR, sizeof(ERR_ERROR)-1);
     263    WriteString(ERR_INIT, sizeof(ERR_INIT)-1);
     264      if(szLastALSAError1[0])
     265      {
     266        WriteString(szLastALSAError1, strlen(szLastALSAError1));
     267      }
     268      if(szLastALSAError2[0])
     269      {
     270        WriteString(szLastALSAError2, strlen(szLastALSAError2));
     271      }
     272    // !! dont exit when error !! return RPDONE | RPERR_COMMAND;
     273  }
     274  else if (OSS32_QueryNames(OSS32_DEFAULT_DEVICE, szDeviceName,
     275                              sizeof(szDeviceName),szMixerName,
     276                              sizeof(szMixerName), TRUE) != OSSERR_SUCCESS)
     277  {
     278    WriteString(ERR_ERROR, sizeof(ERR_ERROR)-1);
     279    WriteString(ERR_NAMES, sizeof(ERR_INIT)-1);
     280    if(szLastALSAError1[0])
     281    {
     282      WriteString(szLastALSAError1, strlen(szLastALSAError1));
     283    }
     284    if(szLastALSAError2[0])
     285    {
     286      WriteString(szLastALSAError2, strlen(szLastALSAError2));
     287    }
     288
     289    // !! dont exit when error !! return RPDONE | RPERR_COMMAND;
     290  }
     291  else
     292  if(fVerbose)
     293  {
     294    WriteString(szDeviceName, strlen(szDeviceName));
     295    WriteString(szEOL, sizeof(szEOL)-1);
     296    WriteString(szMixerFound, sizeof(szMixerFound)-1);
     297    WriteString(szMixerName, strlen(szMixerName));
     298    WriteString(szEOL, sizeof(szEOL)-1);
     299
     300    #if 0
     301    for(int i=1;i<OSS32_MAX_AUDIOCARDS;i++)
     302    {
     303      if(OSS32_QueryNames(i, szDeviceName, sizeof(szDeviceName), szMixerName, sizeof(szMixerName)) == OSSERR_SUCCESS)
     304      {
    282305        WriteString(szDeviceName, strlen(szDeviceName));
    283306        WriteString(szEOL, sizeof(szEOL)-1);
    … …  
    285308        WriteString(szMixerName, strlen(szMixerName));
    286309        WriteString(szEOL, sizeof(szEOL)-1);
    287 
    288 #if 0
    289         for(int i=1;i<OSS32_MAX_AUDIOCARDS;i++) {
    290             if(OSS32_QueryNames(i, szDeviceName, sizeof(szDeviceName), szMixerName, sizeof(szMixerName)) == OSSERR_SUCCESS)
    291             {
    292                 WriteString(szDeviceName, strlen(szDeviceName));
    293                 WriteString(szEOL, sizeof(szEOL)-1);
    294                 WriteString(szMixerFound, sizeof(szMixerFound)-1);
    295                 WriteString(szMixerName, strlen(szMixerName));
    296                 WriteString(szEOL, sizeof(szEOL)-1);
    297             }
    298             else break;
    299         }
    300 #endif
    301         WriteString(szEOL, sizeof(szEOL)-1);
    302     }
    303     // Complete the installation
    304     rp->Out.FinalCS = _OffsetFinalCS16;
    305     rp->Out.FinalDS = _OffsetFinalDS16;
    306 
    307         //SaveBuffer();
    308 
    309     // Confirm a successful installation
    310     return RPDONE;
    311 }
    312 
     310      }
     311      else break;
     312    }
     313    #endif
     314    WriteString(szEOL, sizeof(szEOL)-1);
     315  }
     316  // Complete the installation
     317  rp->init_out.usCodeEnd = _OffsetFinalCS16;
     318  rp->init_out.usDataEnd = _OffsetFinalDS16;
     319
     320  //SaveBuffer();
     321
     322  // Confirm a successful installation
     323  return RPDONE;
     324}
     325

  • GPL/trunk/drv32/irq.h

    r63 r587  
    2525#define __IRQ_H__
    2626
    27 extern "C" FARPTR16 ISR00;
    28 extern "C" FARPTR16 ISR01;
    29 extern "C" FARPTR16 ISR02;
    30 extern "C" FARPTR16 ISR03;
    31 extern "C" FARPTR16 ISR04;
    32 extern "C" FARPTR16 ISR05;
    33 extern "C" FARPTR16 ISR06;
    34 extern "C" FARPTR16 ISR07;
     27extern FARPTR16 ISR00;
     28extern FARPTR16 ISR01;
     29extern FARPTR16 ISR02;
     30extern FARPTR16 ISR03;
     31extern FARPTR16 ISR04;
     32extern FARPTR16 ISR05;
     33extern FARPTR16 ISR06;
     34extern FARPTR16 ISR07;
    3535
    3636#endif //__IRQ_H__

  • GPL/trunk/drv32/parse.c

    r501 r587  
    3434#include <devhelp.h>
    3535#include <devtype.h>
    36 #include <devrp.h>
    3736#include <unicard.h>
    3837#include "parse.h"         // NUM_DEVICES
    … …  
    4645int ForceCard = CARD_NONE;
    4746
    48 extern "C" short int midi_port;
     47extern short int midi_port;
    4948
    5049#ifdef COMM_DEBUG
    51 extern "C" short int MAGIC_COMM_PORT;
     50extern short int MAGIC_COMM_PORT;
    5251#endif
    5352

  • GPL/trunk/drv32/strategy.c

    r549 r587  
    55 * (C) 2000-2002 InnoTek Systemberatung GmbH
    66 * (C) 2000-2001 Sander van Leeuwen (sandervl@xs4all.nl)
     7 * Copyright (c) 2013-2015 David Azarewicz david@88watts.net
    78 *
    89 * This program is free software; you can redistribute it and/or
    … …  
    2425
    2526#define INCL_NOPMAPI
    26 #define INCL_DOSINFOSEG         // Need Global info seg in rm.cpp algorithms
     27#define INCL_DOSINFOSEG   // Need Global info seg in rm.cpp algorithms
    2728#include <os2.h>
    2829
    2930#include <devhelp.h>
    30 #include <devrp.h>
     31//DAZ #include <devrp.h>
    3132#include <devown.h>
    3233#include "strategy.h"
    … …  
    3536#include <string.h>
    3637
    37 ULONG StratRead(RP __far *_rp);
    38 ULONG StratIOCtl(RP __far *_rp);
    39 ULONG StratClose(RP __far *_rp);
     38ULONG StratRead(REQPACKET __far *_rp);
     39ULONG StratIOCtl(REQPACKET __far *_rp);
     40ULONG StratClose(REQPACKET __far *_rp);
    4041
    41 ULONG DiscardableInit(RPInit __far*);
     42ULONG DiscardableInit(REQPACKET __far*);
    4243ULONG deviceOwner = DEV_NO_OWNER;
    4344ULONG numOS2Opens = 0;
    44 extern "C" BOOL fRewired; //pci.c
     45extern BOOL fRewired; //pci.c
    4546
    46 extern "C" DBGINT DbgInt;
     47extern DBGINT DbgInt;
    4748
    4849//******************************************************************************
     50ULONG StratOpen(REQPACKET __far* rp)
     51{
     52  if (numOS2Opens == 0)
     53  {
     54    deviceOwner = DEV_PDD_OWNER;
     55  }
     56  numOS2Opens++;
     57  return RPDONE;
     58}
     59
    4960//******************************************************************************
    50 ULONG StratOpen(RP __far*)
    51 {
    52         if (numOS2Opens == 0) {
    53                 deviceOwner = DEV_PDD_OWNER;
    54         }
    55         numOS2Opens++;
    56                 return RPDONE;
    57 }
    58 //******************************************************************************
    59 //******************************************************************************
    60 #pragma off (unreferenced)
    61 static ULONG StratWrite(RP __far* _rp)
    62 #pragma on (unreferenced)
     61//DAZ #pragma off (unreferenced)
     62static ULONG StratWrite(REQPACKET __far* rp)
     63//DAZ #pragma on (unreferenced)
    6364{
    6465  return RPDONE | RPERR;
    6566}
     67
    6668//******************************************************************************
    6769// External initialization entry-point
    6870//******************************************************************************
    69 ULONG StratInit(RP __far* _rp)
     71ULONG StratInit(REQPACKET __far* rp)
    7072{
    71         ULONG rc;
     73  ULONG rc;
    7274
    73         memset(&DbgInt, 0, sizeof(DbgInt));
    74         DbgPrintIrq();
     75  memset(&DbgInt, 0, sizeof(DbgInt));
     76  DbgPrintIrq();
    7577
    76         RPInit __far* rp = (RPInit __far*)_rp;
    77         rc = DiscardableInit(rp);
    78         //dprintf(("StratInit End rc=%d", rc));
    79         DbgPrintIrq();
    80         DbgInt.ulState = 1;
    81         return rc;
     78  //DAZ RPInit __far* rp = (RPInit __far*)_rp;
     79  rc = DiscardableInit(rp);
     80  //dprintf(("StratInit End rc=%d", rc));
     81  DbgPrintIrq();
     82  DbgInt.ulState = 1;
     83  return rc;
    8284}
     85
    8386//******************************************************************************
    8487// External initialization complete entry-point
    85 #ifdef ACPI
    86 #include "irqos2.h"
    87 #endif //ACPI
    8888//******************************************************************************
    89 #pragma off (unreferenced)
    90 ULONG StratInitComplete(RP __far* _rp)
    91 #pragma on (unreferenced)
     89//DAZ #pragma off (unreferenced)
     90ULONG StratInitComplete(REQPACKET __far* rp)
     91//DAZ #pragma on (unreferenced)
    9292{
    93         DbgInt.ulState = 2;
    94 #ifdef ACPI
    95         PciAdjustInterrupts();
    96 #endif
    97         DbgPrintIrq();
    98         //dprintf(("StratInitComplete"));
    99         return(RPDONE);
     93  DbgInt.ulState = 2;
     94  DbgPrintIrq();
     95  //dprintf(("StratInitComplete"));
     96  return(RPDONE);
    10097}
     98
    10199//******************************************************************************
    102 //******************************************************************************
    103 #pragma off (unreferenced)
    104 ULONG StratShutdown(RP __far *_rp)
    105 #pragma on (unreferenced)
     100//DAZ #pragma off (unreferenced)
     101ULONG StratShutdown(REQPACKET __far *rp)
     102//DAZ #pragma on (unreferenced)
    106103{
    107         RPShutdown __far *rp = (RPShutdown __far *)_rp;
     104  //DAZ RPShutdown __far *rp = (RPShutdown __far *)_rp;
    108105
    109         //dprintf(("StratShutdown %d", rp->Function));
    110         if(rp->Function == 1) {//end of shutdown
    111                 OSS32_Shutdown();
    112         }
    113         return(RPDONE);
     106  //dprintf(("StratShutdown %d", rp->Function));
     107  if(rp->shutdown.Function == 1) //end of shutdown
     108  {
     109    OSS32_Shutdown();
     110  }
     111  return(RPDONE);
    114112}
    115 //******************************************************************************
     113
    116114//******************************************************************************
    117115// Handle unsupported requests
    118 static ULONG StratError(RP __far*)
     116static ULONG StratError(REQPACKET __far* rp)
    119117{
    120   return RPERR_COMMAND | RPDONE;
     118  return RPERR_BADCOMMAND | RPDONE;
    121119}
     120
    122121//******************************************************************************
    123122// Strategy dispatch table
    … …  
    125124// This table is used by the strategy routine to dispatch strategy requests
    126125//******************************************************************************
    127 typedef ULONG (*RPHandler)(RP __far* rp);
     126typedef ULONG (*RPHandler)(REQPACKET __far* rp);
    128127RPHandler StratDispatch[] =
    129128{
    130   StratInit,                              // 00 (BC): Initialization
    131   StratError,                             // 01 (B ): Media check
    132   StratError,                             // 02 (B ): Build BIOS parameter block
    133   StratError,                             // 03 (  ): Unused
    134   StratRead,                              // 04 (BC): Read
    135   StratError,                             // 05 ( C): Nondestructive read with no wait
    136   StratError,                             // 06 ( C): Input status
    137   StratError,                             // 07 ( C): Input flush
    138   StratWrite,                             // 08 (BC): Write
    139   StratError,                             // 09 (BC): Write verify
    140   StratError,                             // 0A ( C): Output status
    141   StratError,                             // 0B ( C): Output flush
    142   StratError,                             // 0C (  ): Unused
    143   StratOpen,                              // 0D (BC): Open
    144   StratClose,                             // 0E (BC): Close
    145   StratError,                             // 0F (B ): Removable media check
    146   StratIOCtl,                             // 10 (BC): IO Control
    147   StratError,                             // 11 (B ): Reset media
    148   StratError,                             // 12 (B ): Get logical unit
    149   StratError,                             // 13 (B ): Set logical unit
    150   StratError,                             // 14 ( C): Deinstall character device driver
    151   StratError,                             // 15 (  ): Unused
    152   StratError,                             // 16 (B ): Count partitionable fixed disks
    153   StratError,                             // 17 (B ): Get logical unit mapping of fixed disk
    154   StratError,                             // 18 (  ): Unused
    155   StratError,                             // 19 (  ): Unused
    156   StratError,                             // 1A (  ): Unused
    157   StratError,                             // 1B (  ): Unused
    158   StratShutdown,                          // 1C (BC): Notify start or end of system shutdown
    159   StratError,                             // 1D (B ): Get driver capabilities
    160   StratError,                             // 1E (  ): Unused
    161   StratInitComplete               // 1F (BC): Notify end of initialization
     129  StratInit,          // 00 (BC): Initialization
     130  StratError,         // 01 (B ): Media check
     131  StratError,         // 02 (B ): Build BIOS parameter block
     132  StratError,         // 03 (  ): Unused
     133  StratRead,          // 04 (BC): Read
     134  StratError,         // 05 ( C): Nondestructive read with no wait
     135  StratError,         // 06 ( C): Input status
     136  StratError,         // 07 ( C): Input flush
     137  StratWrite,         // 08 (BC): Write
     138  StratError,         // 09 (BC): Write verify
     139  StratError,         // 0A ( C): Output status
     140  StratError,         // 0B ( C): Output flush
     141  StratError,         // 0C (  ): Unused
     142  StratOpen,          // 0D (BC): Open
     143  StratClose,         // 0E (BC): Close
     144  StratError,         // 0F (B ): Removable media check
     145  StratIOCtl,         // 10 (BC): IO Control
     146  StratError,         // 11 (B ): Reset media
     147  StratError,         // 12 (B ): Get logical unit
     148  StratError,         // 13 (B ): Set logical unit
     149  StratError,         // 14 ( C): Deinstall character device driver
     150  StratError,         // 15 (  ): Unused
     151  StratError,         // 16 (B ): Count partitionable fixed disks
     152  StratError,         // 17 (B ): Get logical unit mapping of fixed disk
     153  StratError,         // 18 (  ): Unused
     154  StratError,         // 19 (  ): Unused
     155  StratError,         // 1A (  ): Unused
     156  StratError,         // 1B (  ): Unused
     157  StratShutdown,        // 1C (BC): Notify start or end of system shutdown
     158  StratError,         // 1D (B ): Get driver capabilities
     159  StratError,         // 1E (  ): Unused
     160  StratInitComplete       // 1F (BC): Notify end of initialization
    162161};
     162
    163163//******************************************************************************
    164164// Strategy entry point
    … …  
    167167// calling convention, which fetches arguments from the correct registers.
    168168//******************************************************************************
    169 ULONG Strategy(RP __far* rp);
    170169#pragma aux (STRATEGY) Strategy "ALSA_STRATEGY";
    171 ULONG Strategy(RP __far* rp)
     170ULONG Strategy(REQPACKET __far* rp)
    172171{
    173         if (fRewired) {
    174                 fRewired = FALSE;
    175                 rprintf(("Strategy: Resuming"));
    176                 OSS32_APMResume();
    177                 DbgPrintIrq();
    178         }
     172  if (fRewired)
     173  {
     174    fRewired = FALSE;
     175    rprintf(("Strategy: Resuming"));
     176    OSS32_APMResume();
     177    DbgPrintIrq();
     178  }
    179179
    180         if (rp->Command < sizeof(StratDispatch)/sizeof(StratDispatch[0]))
    181                 return(StratDispatch[rp->Command](rp));
    182         else return(RPERR_COMMAND | RPDONE);
     180  if (rp->bCommand < sizeof(StratDispatch)/sizeof(StratDispatch[0])) return(StratDispatch[rp->bCommand](rp));
     181  else return(RPERR_BADCOMMAND | RPDONE);
    183182}
    184 //******************************************************************************
    185 //******************************************************************************
     183

  • GPL/trunk/howtobuild.txt

    r64 r587  
    1 NOTE! Use OpenWatcom 1.4rc1 or later. Also you need IBM's ILINK for driver
     1NOTE! Use OpenWatcom 1.9 or later. Also you need IBM's ILINK for driver
    22      linking. Possible, you can try wlink, but I never did that.
    33
    4 1. Run Configure.cmd
    54
    6 2. Enter path to watcom and ddk base
     51. Setup WATCOM and DDK in your environment.
    76
    8 3. within created makefile.inc check for:
    9    ALSA_SRC
    10    ALSA_LIB_
    11    ALSA_BIN_
    12    define and create corresponding directories
     72. type wmake or wmake -a
    138
    14 4. add following state if not added by configure:
    15    ################################################################################
    16    # Include the right watcom makefile
    17    ################################################################################
    18    !ifdef 32BIT
    19    !include E:\DEV\USS\test\GPL\include\watcom32.mk
    20    !include E:\DEV\USS\test\GPL\include\watcom32.mak
    21    !else
    22    !include E:\DEV\USS\ua2\OCO\include\watcom16.mk
    23    !include E:\DEV\USS\ua2\OCO\include\watcom16.mak
    24    !endif
    25 
    26    DDK_BASE       = e:\ddk\base
    27    WATCOM         = e:\owatcom
    28 
    29 5. run !m_kee.cmd or !m_v4.cmd scrips
    30 

  • GPL/trunk/include/DEVINFO.H

    r32 r587  
    2626#if !defined(DevInfo_h)
    2727#define DevInfo_h 1
    28 
    29 #if !defined(__cplusplus)
    30 #error C++ must be used for strict type checking
    31 #endif
    32 
    3328
    3429// Include the fundamental type definitions

  • GPL/trunk/include/DEVTYPE.H

    r32 r587  
    2525#if !defined(DevType_h)
    2626#define DevType_h 1
    27 
    28 #if !defined(__WATCOMC__) || !defined(__cplusplus)
    29 #error Watcom C++ must be used for strict type checking.
    30 #endif
    3127
    3228#pragma pack(1)
    … …  
    10298  WORD16      Count;          // Count of bytes in queue
    10399  };
    104 template <int s> struct QUEUE : public QBASE
    105   {
    106   BYTE        Buffer[s];      // Queue buffer
    107   };
     100//template <int s> struct QUEUE : public QBASE
     101//  {
     102//  BYTE        Buffer[s];      // Queue buffer
     103//  };
    108104
    109105// Inter device driver communication structure
    … …  
    137133struct DEVHEADER
    138134  {
    139   DEVHEADER FAR* Link;        // Link to next header in chain
     135  struct DEVHEADER FAR* Link;        // Link to next header in chain
    140136  WORD16      DAWFlags;       // Device attribute word
    141137  VOID*       StrategyEntry;  // Entry point to strategy routine
    … …  
    147143
    148144// Constant for final DEVHEADER in chain
    149 #define       FinalLink       ((DEVHEADER FAR*)0xFFFFFFFFul)
     145#define       FinalLink       ((struct DEVHEADER FAR*)0xFFFFFFFFul)
    150146
    151147// Constants for device attribute word
    … …  
    182178#define OffsetBeginDS32        ((WORD32)&_OffBeginDS32)
    183179
    184 extern "C"
    185 {
     180//extern "C"
     181//{
    186182  extern BYTE _OffFinalCS32;               // End of resident code
    187183  extern BYTE _OffFinalDS32;               // End of resident code
    … …  
    190186  extern WORD16 _OffsetFinalCS16;
    191187  extern WORD16 _OffsetFinalDS16;
    192 }
     188//}
    193189
    194190#pragma pack()

  • GPL/trunk/include/linux/compiler-gcc3.h

    r442 r587  
    66#define inline __inline
    77#define INLINE inline
    8 #define __attribute__
     8#define __attribute__(a)
    99
    1010#if __GNUC_MINOR__ >= 1  && __GNUC_MINOR__ < 4

  • GPL/trunk/include/linux/config.h

    r305 r587  
    33#ifndef _LINUX_CONFIG_H
    44#define _LINUX_CONFIG_H
    5 #include <sound/config.h>
     5#include <config.h>
    66#endif

  • GPL/trunk/include/linux/fs.h

    r446 r587  
    88 * upper limit on files-per-process.
    99 *
    10  * Some programs (notably those using select()) may have to be 
    11  * recompiled to take full advantage of the new limits.. 
     10 * Some programs (notably those using select()) may have to be
     11 * recompiled to take full advantage of the new limits..
    1212 */
    1313
    … …  
    6363
    6464/* public flags for file_system_type */
    65 #define FS_REQUIRES_DEV 1 
     65#define FS_REQUIRES_DEV 1
    6666#define FS_NO_DCACHE    2 /* Only dcache the necessary things. */
    6767#define FS_NO_PRELIM    4 /* prevent preloading of dentries, even if
    … …  
    265265extern void kill_fasync(struct fasync_struct *, int, int);
    266266
    267 #define fops_get(x) (x)
     267#define fops_get(x) ((struct file_operations *)x)
    268268#define fops_put(x) do { ; } while (0)
    269269

  • GPL/trunk/include/linux/pnp.h

    r441 r587  
    1313#ifdef __KERNEL__
    1414
    15 #ifndef TARGET_OS2
    1615#include <linux/isapnp.h>
    17 #else /* TARGET_OS2 */
    18 #include <sound/isapnp.h>
    19 #endif /* TARGET_OS2 */
    2016#include <linux/list.h>
    2117#include <linux/pm.h>

  • GPL/trunk/include/linux/workqueue.h

    r444 r587  
    33
    44#include <linux/timer.h>
    5 #include <sound/compat_22.h>
     5#include <compat_22.h>
    66/* we know this is used below exactly once for at most one waiter */
    77

  • GPL/trunk/include/malloc.h

    r502 r587  
    3535void NEAR *malloc(ULONG size, const char *filename, int lineno);
    3636void       free(void *NEAR ptr, const char *filename, int lineno);
    37 void NEAR *realloc(void *NEAR ptr, unsigned newsize, const char *filename, int lineno);
     37void NEAR *realloc(void *NEAR ptr, unsigned long newsize, const char *filename, int lineno);
    3838#else
    3939void NEAR *malloc(ULONG size);
    4040void       free(void NEAR *);
    41 void NEAR *realloc(void NEAR *, unsigned);
     41void NEAR *realloc(void NEAR *, unsigned long);
    4242#endif
    4343

  • GPL/trunk/include/strategy.h

    r32 r587  
    1 /* $Id: strategy.h,v 1.1.1.1 2003/07/02 13:56:58 eleph Exp $ */
    2 /*
    3  * OS/2 strategy handler definitions
    4  *
    5  * (C) 2000-2002 InnoTek Systemberatung GmbH
    6  * (C) 2000-2001 Sander van Leeuwen (sandervl@xs4all.nl)
    7  *
    8  * This program is free software; you can redistribute it and/or
    9  * modify it under the terms of the GNU General Public License as
    10  * published by the Free Software Foundation; either version 2 of
    11  * the License, or (at your option) any later version.
    12  *
    13  * This program is distributed in the hope that it will be useful,
    14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    16  * GNU General Public License for more details.
    17  *
    18  * You should have received a copy of the GNU General Public
    19  * License along with this program; if not, write to the Free
    20  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
    21  * USA.
    22  *
    23  */
    24 
     1/****************************************************************************
     2 *                                                                          *
     3 * Copyright (c) IBM Corporation 1994 - 1997.                               *
     4 *                                                                          *
     5 * The following IBM OS/2 source code is provided to you solely for the     *
     6 * the purpose of assisting you in your development of OS/2 device drivers. *
     7 * You may use this code in accordance with the IBM License Agreement       *
     8 * provided in the IBM Device Driver Source Kit for OS/2.                   *
     9 *                                                                          *
     10 * Copyright (c) 2013 David Azarewicz david@88watts.net                     *
     11 * Modified to fix problems and for OpenWatcom compatibility                *
     12 ****************************************************************************/
    2513#ifndef STRATEGY_INCLUDED
    2614#define STRATEGY_INCLUDED
    2715
     16#pragma pack(1);
    2817
    29 /* Constants relating to the Strategy Routines
    30 */
     18typedef struct {              /* template for request header */
     19  BYTE bLength;               /* 00 request packet length */
     20  BYTE bUnit;                 /* 01 unit code for block DD only */
     21  BYTE bCommand;              /* 02 command code */
     22  USHORT usStatus;            /* 03 return status */
     23  ULONG dwReserved;           /* 05 reserved bytes */
     24  ULONG ulQlink;              /* 09 queue linkage */
     25  union {                     /* command-specific data */
     26    struct {
     27      BYTE b;                 /* 0D */
     28      PFN  ulDevHlp;          /* 0E dev help address */
     29      ULONG szArgs; /* 12 argument pointer */
     30      BYTE bDrive;            /* 16 */
     31    } init_in;
     32    struct {
     33      BYTE bUnits;
     34      USHORT usCodeEnd;       // final code offset
     35      USHORT usDataEnd;       // final data offset
     36      ULONG ul;
     37    } init_out;
     38    struct {
     39      BYTE bMedia;
     40      ULONG ulAddress;
     41      USHORT usCount;
     42      ULONG ulStartSector;
     43      USHORT usSysFileNum;
     44    } io;
     45    struct {
     46      BYTE bData;
     47    } peek;
     48    struct {
     49      BYTE bCategory;         // category code
     50      BYTE bFunction;         // function code
     51      ULONG pvParm; // address of parameter buffer
     52      ULONG pvData; // address of data buffer
     53      USHORT usSysFileNum;    // system file number
     54      USHORT usParmLen;       // length of parameter buffer
     55      USHORT usDataLen;       // length of data buffer
     56    } ioctl;
     57    struct {
     58      USHORT usSysFileNum;    // system file number
     59    } open_close;
     60    struct {
     61      BYTE   Function;        // Shutdown code: 0 = start, 1 = end
     62      ULONG  Reserved;        // Reserved
     63    } shutdown;
     64    struct {
     65      BYTE Function;
     66    } save_restore;
     67  };
     68} REQPACKET;
     69
     70#pragma pack();
     71
     72/* Constants relating to the Strategy Routines */
    3173
    3274#define RPDONE    0x0100         // return successful, must be set
    … …  
    3577#define RPERR     0x8000         // return error
    3678
    37 // List of error codes, from chapter 8 of PDD reference
    38 #define RPNOTREADY  0x0002
    39 #define RPBADCMD    0x0003
    40 #define RPGENFAIL   0x000c
    41 #define RPDEVINUSE  0x0014
    42 #define RPINITFAIL  0x0015
     79#define RPERR_PROTECT         0x8000
     80#define RPERR_UNIT            0x8001
     81#define RPERR_NOTREADY        0x8002
     82#define RPERR_BADCOMMAND      0x8003
     83#define RPERR_CRC             0x8004
     84#define RPERR_LENGTH          0x8005
     85#define RPERR_SEEK            0x8006
     86#define RPERR_FORMAT          0x8007
     87#define RPERR_SECTOR          0x8008
     88#define RPERR_PAPER           0x8009
     89#define RPERR_WRITE           0x800A
     90#define RPERR_READ            0x800B
     91#define RPERR_GENERAL         0x800C
     92#define RPERR_DISK            0x800D
     93#define RPERR_MEDIA           0x8010
     94#define RPERR_INTERRUPTED     0x8011
     95#define RPERR_MONITOR         0x8012
     96#define RPERR_PARAMETER       0x8013
     97#define RPERR_DEVINUSE        0x8014
     98#define RPERR_INITFAIL        0x8015
    4399
    44100// list of Strategy commands from PDD reference
    45 // Note this is only the list of commands audio device drivers care about
    46 #define STRATEGY_INIT          0x00
    47 #define STRATEGY_OPEN          0x0D
    48 #define STRATEGY_CLOSE         0x0E
    49 #define STRATEGY_GENIOCTL      0x10
    50 #define STRATEGY_DEINSTALL     0x14
    51 #define STRATEGY_INITCOMPLETE  0x1F
     101#define STRATEGY_INIT            0x00
     102#define STRATEGY_MEDIACHECK      0x01
     103#define STRATEGY_BUILDBPB        0x02
     104#define STRATEGY_IOCTLR          0x03
     105#define STRATEGY_READ            0x04
     106#define STRATEGY_NDR             0x05
     107#define STRATEGY_INPUTSTATUS     0x06
     108#define STRATEGY_FLUSHINPUT      0x07
     109#define STRATEGY_WRITE           0x08
     110#define STRATEGY_WRITEVERIFY     0x09
     111#define STRATEGY_OUTPUTSTATUS    0x0A
     112#define STRATEGY_FLUSHOUTPUT     0x0B
     113#define STRATEGY_IOCTLW          0x0C
     114#define STRATEGY_OPEN            0x0D
     115#define STRATEGY_CLOSE           0x0E
     116#define STRATEGY_REMOVEABLEMEDIA 0x0F
     117#define STRATEGY_GENIOCTL        0x10
     118#define STRATEGY_RESETMEDIA      0x11
     119#define STRATEGY_GETLOGMAP       0x12
     120#define STRATEGY_SETLOGMAP       0x13
     121#define STRATEGY_DEINSTALL       0x14
     122#define STRATEGY_PARTFIXEDDISKS  0x16
     123#define STRATEGY_GETFDLOGUNITMAP 0x17
     124#define STRATEGY_INPUTBYPASS     0x18
     125#define STRATEGY_OUTPUTBYPASS    0x19
     126#define STRATEGY_OUTPUTBYPASSV   0x1A
     127#define STRATEGY_BASEDEVINIT     0x1B
     128#define STRATEGY_SHUTDOWN        0x1C
     129#define STRATEGY_GETDRIVERCAPS   0x1D
     130#define STRATEGY_INITCOMPLETE    0x1F
     131#define STRATEGY_SAVERESTORE     0x20
     132
     133#define IOCTL_ASYNC            0x0001
     134#define IOCTL_SCR_AND_PTRDRAW  0x0003
     135#define IOCTL_KEYBOARD         0x0004
     136#define IOCTL_PRINTER          0x0005
     137#define IOCTL_LIGHTPEN         0x0006
     138#define IOCTL_POINTINGDEVICE   0x0007
     139#define IOCTL_DISK             0x0008
     140#define IOCTL_PHYSICALDISK     0x0009
     141#define IOCTL_MONITOR          0x000A
     142#define IOCTL_GENERAL          0x000B
     143#define IOCTL_POWER            0x000C
     144#define IOCTL_OEMHLP           0x0080
     145#define IOCTL_TESTCFG_SYS      0x0080
     146#define IOCTL_CDROMDISK        0x0080
     147#define IOCTL_CDROMAUDIO       0x0081
     148#define IOCTL_TOUCH_DEVDEP     0x0081
     149#define IOCTL_TOUCH_DEVINDEP   0x0081
    52150
    53151#endif

  • GPL/trunk/lib32/initcall.h

    r455 r587  
    88typedef void (*exitcall_t)(void);
    99
    10 extern "C" int use_internal_drums;
     10extern int use_internal_drums;
    1111
    1212#define __initcall(fn)                                                          \
    … …  
    1919#define module_exit(x)  __exitcall(x);
    2020
    21 #define extern_module_init(x)   extern "C" initcall_t __initcall_##x;
    22 #define extern_module_exit(x)   extern "C" exitcall_t __exitcall_##x;
     21#define extern_module_init(x)   extern initcall_t __initcall_##x;
     22#define extern_module_exit(x)   extern exitcall_t __exitcall_##x;
    2323
    2424#define call_module_init(x)     __initcall_##x()

  • GPL/trunk/lib32/pci.c

    r577 r587  
    3131#include <asm/hardirq.h>
    3232#include <asm/io.h>
    33 #include <sound/config.h>
     33#include <config.h>
    3434#include <sound/core.h>
    3535#include <sound/asound.h>
    … …  
    5555#define PCI_CONFIG_DATA                 0xCFC
    5656
    57 #ifdef ACPI
    58 APIRET APIENTRY ACPIFindPCIDevice(ULONG Bus, ULONG Dev, ULONG Fun, ULONG *PicIRQ, ULONG *ApicIRQ, ULONG *Hdl, char *Component);
    59 #endif
    60 
    6157//******************************************************************************
    6258#define CONFIG_CMD(dev, where)  \
    … …  
    140136        int             resNo, addr;
    141137        u32 devNr, busNr, funcNr, detectedId, cfgaddrreg, ulPciAdr, ulTmp1, ulTmp2;
    142 #ifdef ACPI
    143         APIRET                   rc;
    144         ULONG                    PicIRQ, ApicIRQ;
    145 #endif
    146138        u8              headerType;
    147139
    … …  
    239231                                pci_read_config_dword(pcidev, PCI_INTERRUPT_LINE, &ulTmp1);
    240232                                rprintf(("pci_query_device: PCI config IRQ=%d", ulTmp1&0xff));
    241 #ifdef ACPI
    242                                 rc = ACPIFindPCIDevice( (ULONG)busNr,                                            // Bus
    243                                                                                 (ULONG)devNr,                                            // Dev
    244                                                                                 (ULONG)(pcidev->devfn >> 8) & 7,         // Function
    245                                                                                 &PicIRQ,                                                         // PIC IRQ
    246                                                                                 &ApicIRQ,                                                        // APIC IRQ
    247                                                                                 NULL,                                                            // ACPI handle to finding device
    248                                                                                 "Uniaud32");                                             // Name for acpi log
    249                                 if (!rc) {
    250                                         if (PicIRQ) ulTmp1 = (ulTmp1 & (~0xff)) | (PicIRQ & 0xff); // Choose Pic interrupt for init time processing
    251                                         else if (ApicIRQ) ulTmp1 = (ulTmp1 & (~0xff)) | (ApicIRQ & 0xff);
    252                                         rprintf(("pci_query_device: IRQs ACPI PIC=%ld APIC=%ld chosen=%d", PicIRQ, ApicIRQ, ulTmp1&0xff));
    253                                         pcidev->picirq = PicIRQ;   // Save the Pic and
    254                                         pcidev->apicirq = ApicIRQ; // Save the Apic interrupt for switching later
    255                                 }
    256 #endif /* ACPI */
    257233                                if( (u8)ulTmp1 && (u8)ulTmp1 != 0xff ) {
    258234                                        pcidev->irq_resource[0].flags = IORESOURCE_IRQ;
    … …  
    972948}
    973949
    974 #ifdef ACPI
    975 void PciAdjustInterrupts() {
    976         int i;
    977         struct pci_dev *pcidev;
    978         struct pci_driver *driver;
    979         ULONG ulTmp1, rc;
    980 
    981         for (i=0; i<MAX_PCI_DEVICES; i++) {
    982                 if (!pci_devices[i].devfn) continue;
    983                 pcidev = &pci_devices[i];
    984                 ulTmp1 = pcidev->irq;
    985                 if (pcidev->apicirq) ulTmp1 = pcidev->apicirq;
    986                 else if (pcidev->picirq) ulTmp1 = pcidev->picirq;
    987                 rprintf(("PciAdjustInterrupts: IRQs ACPI PIC=%ld APIC=%ld was=%d chosen=%ld", pcidev->picirq, pcidev->apicirq, pcidev->irq, ulTmp1));
    988                 if( (u8)ulTmp1 && ((u8)ulTmp1 != 0xff) && ((u8)ulTmp1 != pcidev->irq) ) {
    989                         RMSetHandles(pcidev->hAdapter, pcidev->hDevice); /* DAZ - dirty hack */
    990                         driver = pcidev->pcidriver;
    991                         if(driver && driver->suspend) driver->suspend(pcidev, SNDRV_CTL_POWER_D0);
    992 
    993                         pcidev->irq_resource[0].flags = IORESOURCE_IRQ;
    994                         pcidev->irq_resource[0].start = pcidev->irq_resource[0].end   = ulTmp1 & 0xffff;
    995                         pcidev->irq = (u8)ulTmp1;
    996 
    997                         fRewired = TRUE;
    998                         // if(driver && driver->resume) driver->resume(pcidev);
    999                 }
    1000         } /* for loop */
    1001 }
    1002 #endif

  • GPL/trunk/lib32/soundmidi.c

    r518 r587  
    3030#include <sound/minors.h>
    3131#include <sound/asequencer.h>
    32 #include <sound/seqmid.h>
     32#include <seqmid.h>
    3333#include <sound/seq_kernel.h>
    3434#include <linux/file.h>

  • GPL/trunk/tools/mkversion.cmd

    r577 r587  
    22 * Set time/date/hostname for uniaud build environment
    33 */
     4call RxFuncAdd 'SysLoadFuncs', 'RexxUtil', 'SysLoadFuncs';
     5call SysLoadFuncs;
    46
    5 parse arg sAlsaBase
     7parse arg sDebugMode;
    68
    79/* I don't this will ever change from Netlabs */
    8 projVendor    = "Netlabs"
    9 projProduct   = "OS/2 Universal Audio 32 Driver"
    10 projVendorNam = "Netlabs <www.netlabs.org>"
    11 projAdapter   = "OS/2 Universal Audio"
    12 
     10projVendor    = EnvVar_Get_If('VENDOR', 'Netlabs');
     11projProduct   = "OS/2 Universal Audio 32 Driver";
     12projVendorNam = "Netlabs <www.netlabs.org>";
     13projAdapter   = "OS/2 Universal Audio";
    1314
    1415/* uniaud.inc is located in the base gpl directory and
    … …  
    1617 * written to include\version.h.
    1718 */
    18 if sAlsaBase = "" then sAlsaBase = "."
    19 versConst = sAlsaBase"\uniaud.inc"
     19sAlsaBase = Directory();
     20versConst = sAlsaBase||"\uniaud.inc";
    2021
    21 versMak   = sAlsaBase"\include\version.mak"
    22 versHdr   = sAlsaBase"\include\version.h"
    23 AlsaVersHdr = sAlsaBase'\alsa-kernel\include\sound\version.h'
     22versMak   = sAlsaBase||"\include\version.mak";
     23versHdr   = sAlsaBase||"\include\version.h";
     24AlsaVersHdr = sAlsaBase||'\alsa-kernel\include\sound\version.h';
    2425
    2526/* get and format date and time */
    26 curDate    = DATE('S')
    27 projDate   = RIGHT(curDate, 2)"."SUBSTR(curDate, 5, 2)"."LEFT(curDate, 4)
    28 projDate2  = LEFT(curDate, 4)SUBSTR(curDate, 5, 2)RIGHT(curDate, 2)L
    29 projTime   = TIME( )
     27curDate    = DATE('S');
     28projDate   = RIGHT(curDate, 2)||"."||SUBSTR(curDate, 5, 2)||"."||LEFT(curDate, 4);
     29projDate2  = LEFT(curDate, 4)||SUBSTR(curDate, 5, 2)||RIGHT(curDate, 2)L
     30projTime   = TIME( );
    3031
    31 /* get hostname for build system */
    32 projHost = VALUE('HOSTNAME',,'OS2ENVIRONMENT')
     32if (sDebugMode<>'') then do
     33  say "Project date: "projDate
     34  say "Project time: "projTime
     35  say "Inc File:     "versConst
     36  say "Version Mak:   "versMak
     37  say "Version Hdr:   "versHdr
     38end
    3339
    34 projString = left(Date() TIME(),25)left(projHost,10)
     40LINEIN(versConst,,0);
    3541
    36 say "Project date: "projDate
    37 say "Project time: "projTime
    38 say "hostname:     "projHost
    39 say "Version In:    "versConst
    40 say "Version Mak:   "versMak
    41 say "Version Hdr:   "versHdr
    42 
    43 LINEIN(versConst,,0)
    44 
    45 fixpack = ''
     42fixpack = '';
    4643
    4744do while(LINES(versConst))
    48     tmpLine = LINEIN(versConst)
     45  tmpLine = LINEIN(versConst);
    4946
    50     IF POS('#', tmpline) = 1 Then iterate
     47  IF POS('#', tmpline) = 1 Then iterate;
    5148
    52     opLoc = POS('BUILDVERSION', tmpLine)
    53     if opLoc > 0 then
    54       versionIn = STRIP((RIGHT(tmpLine, ( LENGTH(tmpLine) - (POS("=", tmpLine)+1) ))), B, ' ')
     49  opLoc = POS('BUILDVERSION', tmpLine);
     50  if opLoc > 0 then
     51    versionIn = STRIP((RIGHT(tmpLine, ( LENGTH(tmpLine) - (POS("=", tmpLine)+1) ))), B, ' ')
    5552
    56     opLoc = POS('PRODUCTNAME', tmpLine)
    57     if opLoc > 0 then
    58       productName = STRIP((RIGHT(tmpLine, ( LENGTH(tmpLine) - (POS("=", tmpLine)+1) ))), B, ' ')
     53  opLoc = POS('PRODUCTNAME', tmpLine)
     54  if opLoc > 0 then
     55    productName = STRIP((RIGHT(tmpLine, ( LENGTH(tmpLine) - (POS("=", tmpLine)+1) ))), B, ' ')
    5956
    60     opLoc = POS('FIXPACK', tmpLine)
    61     if opLoc > 0 then
    62       fixpack = STRIP((RIGHT(tmpLine, ( LENGTH(tmpLine) - (POS("=", tmpLine)+1) ))), B, ' ')
    63 
     57  opLoc = POS('FIXPACK', tmpLine)
     58  if opLoc > 0 then
     59    fixpack = STRIP((RIGHT(tmpLine, ( LENGTH(tmpLine) - (POS("=", tmpLine)+1) ))), B, ' ')
    6460end
    6561
    66 if versionIn = "" then do
    67     say "Could not find Version in "versConst
    68     exit
     62if (sDebugMode<>'') then say 'versionIn='||versionIn;
     63
     64if (versionIn = "") then do
     65  say "Could not find Version in "||versConst;
     66  exit;
    6967end
    7068
    … …  
    7270
    7371if fixpack="" then
    74         projVers  = versionIn
     72  projVers = versionIn;
    7573else
    76         projVers  = versionIn'-'fixpack
     74  projVers = versionIn||'-'||fixpack;
    7775
    78 projVers2 = major||minor||projVersion
     76projVers2 = major||minor||projVersion;
    7977
    8078LINEIN(AlsaVersHdr,,0)
    … …  
    8381
    8482do while(LINES(AlsaVersHdr))
    85     tmpLine = LINEIN(AlsaVersHdr)
    86     opLoc = POS('#define CONFIG_SND_VERSION', tmpLine)
    87     if opLoc > 0 then
    88       AlsaLevel = STRIP(RIGHT(tmpLine, ( LENGTH(tmpLine) - (POS('"', tmpLine)))),,'"')
     83  tmpLine = LINEIN(AlsaVersHdr)
     84  opLoc = POS('#define CONFIG_SND_VERSION', tmpLine)
     85  if opLoc > 0 then AlsaLevel = STRIP(RIGHT(tmpLine, ( LENGTH(tmpLine) - (POS('"', tmpLine)))),,'"')
    8986end
    9087
    91 SAY 'Alsalevel = ' AlsaLevel
     88if (sDebugMode<>'') then do
     89  SAY 'Alsalevel='||AlsaLevel;
     90  say 'ProjVendor='||ProjVendor;
     91  say 'versionIn='||versionIn;
     92  say 'ProjString='||ProjString;
     93  say 'alsalevel='||alsalevel;
     94  say 'ProjVersion='||ProjVersion;
     95  say 'projVers='||projVers;
     96  say 'projVers2='||projVers2;
     97  say 'Fixpack='||Fixpack;
     98end
    9299
    93 SET "BUILDLEVEL=@#"ProjVendor":"versionIn"#@##1## "ProjString":"alsalevel":::"ProjVersion"::"Fixpack"@@"productname
    94 
    95 call RxFuncAdd 'SysLoadFuncs', 'RexxUtil', 'SysLoadFuncs'
    96 call SysLoadFuncs
    97 dummy = SysFileDelete(versMak)
     100dummy = SysFileDelete(versMak);
    98101
    99102if (stream(versMak, 'c', 'open write' ) = 'READY:') then
    100103do
    101104    call lineout versMak, '#'
    102 /*    call lineout versMak, '#       VERSION.MAK'
     105    call lineout versMak, '#       VERSION.MAK'
    103106    call lineout versMak, '#'
    104107    call lineout versMak, '#       Current build level for File Versioning'
    … …  
    106109    call lineout versMak, '#       Generated by mkversion.cmd, do NOT edit !'
    107110    call lineout versMak, '#'
    108     call lineout versMak, 'BLDLVL_VENDOR = 'projVendor
    109     call lineout versMak, 'BLDLVL_PRODUCT = 'projProduct
    110     call lineout versMak, 'BLDLVL_REVISION = 'major'.'minor
    111     call lineout versMak, 'BLDLVL_FILEVER = 'projVersion
    112     call lineout versMak, 'BLDLVL_DATETIME = 'projDate' 'projTime
    113     call lineout versMak, 'BLDLVL_MACHINE = 'projHost
     111    call lineout versMak, 'BLDLVL_VENDOR = '||projVendor;
     112    call lineout versMak, 'BLDLVL_VERSION = '||versionIn;
     113    call lineout versMak, 'BLDLVL_FIXPACK = '||Fixpack;
     114    call lineout versMak, 'BLDLVL_ALSA = '||alsalevel;
    114115    call stream versMak, 'c', 'close';
    115 */
    116116end
    117117else
    … …  
    121121end
    122122
    123 
    124123dummy = SysFileDelete(versHdr)
    125124
    126125if (stream(versHdr, 'c', 'open write' ) = 'READY:') then
    127126do
    128     call lineout versHdr, '/*'
    129     call lineout versHdr, ' * version.h   Header for version string'
    130     call lineout versHdr, ' *'
    131     call lineout versHdr, ' *    Generated by mkversion.cmd, do NOT edit !'
    132     call lineout versHdr, ' *'
    133     call lineout versHdr, ' */'
     127    call lineout versHdr, '/*';
     128    call lineout versHdr, ' * version.h   Header for version string';
     129    call lineout versHdr, ' *';
     130    call lineout versHdr, ' *    Generated by mkversion.cmd, do NOT edit !';
     131    call lineout versHdr, ' *';
     132    call lineout versHdr, ' */';
     133    call lineout versHdr, ' ';
     134    call lineout versHdr, ' ';
     135    call lineout versHdr, '#ifndef __UNIAUDVERSION_H__';
     136    call lineout versHdr, '#define __UNIAUDVERSION_H__';
     137    call lineout versHdr, ' ';
     138    call lineout versHdr, ' ';
     139    call lineout versHdr, '#define PRODUCT_NAME            "'||ProductName||'"';
     140    call lineout versHdr, '#define VENDOR_NAME             "'||projVendor||'"';
     141    call lineout versHdr, '#define PRODUCT_TIMESTAMP       '||projDate2||'       // YYYYMMDD';
     142    call lineout versHdr, '#define UNIAUD_VERSION          "'||projVers||'"';
     143    call lineout versHdr, '#define ALSA_VERSION            "'||alsalevel||'"';
    134144    call lineout versHdr, ' '
    135145    call lineout versHdr, ' '
    136     call lineout versHdr, '#ifndef __UNIAUDVERSION_H__'
    137     call lineout versHdr, '#define __UNIAUDVERSION_H__'
    138     call lineout versHdr, ' '
    139     call lineout versHdr, ' '
    140     call lineout versHdr, '#define PRODUCT_NAME            "'ProductName'"'
    141     call lineout versHdr, '#define VENDOR_NAME             "'projVendor'"'
    142     call lineout versHdr, '#define PRODUCT_TIMESTAMP       'projDate2'       // YYYYMMDD'
    143     call lineout versHdr, '#define UNIAUD_VERSION          "'projVers'"'
    144     call lineout versHdr, '#define ALSA_VERSION            "'alsalevel'"'
    145     call lineout versHdr, ' '
    146     call lineout versHdr, ' '
    147     call lineout versHdr, '#define RM_VERSION              'projVers2
    148     call lineout versHdr, '#define RM_DRIVER_NAME          "UNIAUD32.SYS"'
    149     call lineout versHdr, '#define RM_DRIVER_DESCRIPTION   "'projProduct'"'
    150     call lineout versHdr, '#define RM_ADAPTER_NAME         "'projAdapter'"'
    151     call lineout versHdr, '#define RM_DRIVER_VENDORNAME    "'projVendorNam'"'
    152     call lineout versHdr, '#define RM_DRIVER_BUILDYEAR     (PRODUCT_TIMESTAMP / 10000)'
    153     call lineout versHdr, '#define RM_DRIVER_BUILDMONTH    ((PRODUCT_TIMESTAMP / 100) % 100)'
    154     call lineout versHdr, '#define RM_DRIVER_BUILDDAY      (PRODUCT_TIMESTAMP % 100)'
    155     call lineout versHdr, ' '
    156     call lineout versHdr, ' '
    157     call lineout versHdr, "#endif //__UNIAUDVERSION_H__"
    158     call lineout versHdr, ' '
     146    call lineout versHdr, '#define RM_VERSION              '||projVers2;
     147    call lineout versHdr, '#define RM_DRIVER_NAME          "UNIAUD32.SYS"';
     148    call lineout versHdr, '#define RM_DRIVER_DESCRIPTION   "'||projProduct||'"';
     149    call lineout versHdr, '#define RM_ADAPTER_NAME         "'||projAdapter||'"';
     150    call lineout versHdr, '#define RM_DRIVER_VENDORNAME    "'||projVendorNam||'"';
     151    call lineout versHdr, '#define RM_DRIVER_BUILDYEAR     (PRODUCT_TIMESTAMP / 10000)';
     152    call lineout versHdr, '#define RM_DRIVER_BUILDMONTH    ((PRODUCT_TIMESTAMP / 100) % 100)';
     153    call lineout versHdr, '#define RM_DRIVER_BUILDDAY      (PRODUCT_TIMESTAMP % 100)';
     154    call lineout versHdr, ' ';
     155    call lineout versHdr, ' ';
     156    call lineout versHdr, "#endif //__UNIAUDVERSION_H__";
     157    call lineout versHdr, ' ';
    159158    call stream versHdr, 'c', 'close';
    160159end
    … …  
    167166exit 0;
    168167
     168/**
     169 * Procedure section
     170 **/
    169171
     172EnvVar_Get: procedure
     173    parse arg sEnvVar
     174    if translate(sEnvVar) == 'BEGINLIBPATH' then
     175      s = SysQueryExtLibpath('B')
     176    else if translate(sEnvVar) == 'ENDLIBPATH' then
     177      s = SysQueryExtLibpath('E')
     178    else
     179      s = value(sEnvVar,, 'OS2ENVIRONMENT')
     180    return s;
    170181
     182/*
     183 * Returns value of sEnvVar from environment if set or returns default value.
     184 */
     185EnvVar_Get_If: procedure
     186  parse arg sEnvVar, sDefault;
     187  s = EnvVar_Get(sEnvVar);
     188  if s == '' then
     189    s = sDefault;
     190  return s;
     191

  • GPL/trunk/uniaud.inc

    r577 r587  
    1313# ex RC3  GA  FIXPACK2 beta_47
    1414# Comment out to avoid a fixpack line in bldlevel
    15 FIXPACK = SVN551
     15FIXPACK = SVN
    1616
    1717# ALSA BUILD VERSION
Note: See TracChangeset for help on using the changeset viewer.