Changeset 587 for GPL/trunk/alsa-kernel
- Timestamp:
- Jun 9, 2016, 10:38:13 PM (9 years ago)
- Location:
- GPL/trunk/alsa-kernel
- Files:
-
- 79 added
- 121 deleted
- 27 edited
Legend:
- Unmodified
- Added
- Removed
-
GPL/trunk/alsa-kernel/core/control.c
r528 r587 29 29 #include <sound/info.h> 30 30 #include <sound/control.h> 31 #ifdef TARGET_OS2 31 32 #include <proto.h> 33 #endif 32 34 33 35 /* max number of user-defined controls */ … … 196 198 if (snd_BUG_ON(!control || !control->count)) 197 199 return NULL; 198 199 200 kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL); 200 201 201 if (kctl == NULL) { 202 202 snd_printk(KERN_ERR "Cannot allocate control instance\n"); -
GPL/trunk/alsa-kernel/core/info.c
r479 r587 649 649 if (!strcmp(card->id, card->proc_root->name)) 650 650 return 0; 651 651 652 #ifndef TARGET_OS2 652 653 p = proc_symlink(card->id, snd_proc_root, card->proc_root->name); -
GPL/trunk/alsa-kernel/core/init.c
r479 r587 60 60 static int module_slot_match(struct module *module, int idx) 61 61 { 62 int match = 1; 62 63 #ifndef TARGET_OS2 63 64 #ifdef MODULE 64 65 const char *s1, *s2; 65 66 66 int match = 1;67 67 if (!module || !module->name || !slots[idx]) 68 68 return 0; 69 69 70 s1 = module->name; 70 71 s2 = slots[idx]; … … 88 89 break; 89 90 } 90 91 91 #endif /* MODULE */ 92 #else93 int match = 1;94 92 #endif 95 93 return match; -
GPL/trunk/alsa-kernel/core/isadma.c
r305 r587 39 39 * Programs an ISA DMA transfer for the given buffer. 40 40 */ 41 42 41 void snd_dma_program(unsigned long dma, 43 42 unsigned long addr, unsigned int size, -
GPL/trunk/alsa-kernel/core/misc.c
r464 r587 128 128 EXPORT_SYMBOL(snd_pci_quirk_lookup); 129 129 #endif 130 131 //#include "misc.inc" -
GPL/trunk/alsa-kernel/core/pcm_compat.c
r479 r587 22 22 23 23 #include <linux/compat.h> 24 #include <proto.h>25 24 26 25 static int snd_pcm_ioctl_delay_compat(struct snd_pcm_substream *substream, -
GPL/trunk/alsa-kernel/core/pcm_lib.c
r549 r587 230 230 #define hw_ptr_error(substream, fmt, ...) ; 231 231 #endif 232 232 233 static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream) 233 234 { -
GPL/trunk/alsa-kernel/core/pcm_misc.c
r399 r587 19 19 * 20 20 */ 21 21 22 22 #include <linux/time.h> 23 23 #include <sound/core.h> … … 446 446 break; 447 447 } 448 449 448 } 450 449 return 0; -
GPL/trunk/alsa-kernel/core/sgbuf.c
r518 r587 22 22 #include <sound/core.h> 23 23 #endif 24 #include < sound/config.h>24 #include <config.h> 25 25 #include <linux/slab.h> 26 26 #include <linux/mm.h> -
GPL/trunk/alsa-kernel/core/sound_oss.c
r479 r587 20 20 */ 21 21 #ifdef TARGET_OS2 22 #include < sound/config.h>22 #include <config.h> 23 23 #endif 24 24 -
GPL/trunk/alsa-kernel/drivers/dummy.c
r410 r587 26 26 #include <linux/time.h> 27 27 #include <linux/wait.h> 28 #include <linux/moduleparam.h> 28 #include <linux/hrtimer.h> 29 #include <linux/math64.h> 30 #include <linux/module.h> 29 31 #include <sound/core.h> 30 32 #include <sound/control.h> … … 32 34 #include <sound/pcm.h> 33 35 #include <sound/rawmidi.h> 36 #include <sound/info.h> 34 37 #include <sound/initval.h> 35 38 … … 40 43 41 44 #define MAX_PCM_DEVICES 4 42 #define MAX_PCM_SUBSTREAMS 1 645 #define MAX_PCM_SUBSTREAMS 128 43 46 #define MAX_MIDI_DEVICES 2 44 47 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 61 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 62 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 63 static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0}; 64 static char *model[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = NULL}; 65 static int pcm_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; 66 static 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 69 static bool hrtimer = 1; 70 #endif 71 static bool fake_buffer = 1; 72 73 module_param_array(index, int, NULL, 0444); 74 MODULE_PARM_DESC(index, "Index value for dummy soundcard."); 75 module_param_array(id, charp, NULL, 0444); 76 MODULE_PARM_DESC(id, "ID string for dummy soundcard."); 77 module_param_array(enable, bool, NULL, 0444); 78 MODULE_PARM_DESC(enable, "Enable this dummy soundcard."); 79 module_param_array(model, charp, NULL, 0444); 80 MODULE_PARM_DESC(model, "Soundcard model."); 81 module_param_array(pcm_devs, int, NULL, 0444); 82 MODULE_PARM_DESC(pcm_devs, "PCM devices # (0-4) for dummy driver."); 83 module_param_array(pcm_substreams, int, NULL, 0444); 84 MODULE_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."); 87 module_param(fake_buffer, bool, 0444); 88 MODULE_PARM_DESC(fake_buffer, "Fake buffer allocations."); 89 #ifdef CONFIG_HIGH_RES_TIMERS 90 module_param(hrtimer, bool, 0644); 91 MODULE_PARM_DESC(hrtimer, "Use hrtimer as the timer source."); 92 #endif 93 94 static 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 103 struct 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 112 struct 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 129 struct 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 47 144 static int emu10k1_playback_constraints(struct snd_pcm_runtime *runtime) 48 145 { … … 56 153 return 0; 57 154 } 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 156 struct dummy_model model_emu10k1 = { 157 .name = "emu10k1", 158 .playback_constraints = emu10k1_playback_constraints, 159 .buffer_bytes_max = 128 * 1024, 160 }; 161 162 struct 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 172 struct 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 182 struct 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 192 struct 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 202 struct 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 216 struct 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 230 struct dummy_systimer_pcm { 184 231 spinlock_t lock; 185 232 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; 192 240 struct snd_pcm_substream *substream; 193 241 }; 194 242 195 196 static inline void snd_card_dummy_pcm_timer_start(struct snd_dummy_pcm *dpcm) 197 { 198 dpcm->timer.expires = 1 + jiffies;243 static 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; 199 247 add_timer(&dpcm->timer); 200 248 } 201 249 202 static inline void snd_card_dummy_pcm_timer_stop(struct snd_dummy_pcm *dpcm) 203 { 250 static 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 269 static 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 279 static 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); 204 283 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 288 static int dummy_systimer_prepare(struct snd_pcm_substream *substream) 208 289 { 209 290 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 303 static 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 319 static snd_pcm_uframes_t 320 dummy_systimer_pointer(struct snd_pcm_substream *substream) 321 { 322 struct dummy_systimer_pcm *dpcm = substream->runtime->private_data; 323 snd_pcm_uframes_t pos; 212 324 213 325 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 332 static 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 348 static void dummy_systimer_free(struct snd_pcm_substream *substream) 349 { 350 kfree(substream->runtime->private_data); 351 } 352 353 static 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 367 struct 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 376 static 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 383 static 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 395 static 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 405 static 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 414 static inline void dummy_hrtimer_sync(struct dummy_hrtimer_pcm *dpcm) 415 { 416 tasklet_kill(&dpcm->tasklet); 417 } 418 419 static snd_pcm_uframes_t 420 dummy_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 434 static 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 453 static 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 470 static 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 477 static 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 492 static int dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 493 { 494 struct snd_dummy *dummy = snd_pcm_substream_chip(substream); 495 214 496 switch (cmd) { 215 497 case SNDRV_PCM_TRIGGER_START: 216 498 case SNDRV_PCM_TRIGGER_RESUME: 217 snd_card_dummy_pcm_timer_start(dpcm); 218 break; 499 return dummy->timer_ops->start(substream); 219 500 case SNDRV_PCM_TRIGGER_STOP: 220 501 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 507 static 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 514 static 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 521 static 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), 287 526 .formats = USE_FORMATS, 288 527 .rates = USE_RATE, … … 292 531 .channels_max = USE_CHANNELS_MAX, 293 532 .buffer_bytes_max = MAX_BUFFER_SIZE, 294 .period_bytes_min = 64,533 .period_bytes_min = MIN_PERIOD_SIZE, 295 534 .period_bytes_max = MAX_PERIOD_SIZE, 296 535 .periods_min = USE_PERIODS_MIN, … … 299 538 }; 300 539 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 { 540 static 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 552 static int dummy_pcm_hw_free(struct snd_pcm_substream *substream) 553 { 554 if (fake_buffer) 555 return 0; 332 556 return snd_pcm_lib_free_pages(substream); 333 557 } 334 558 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 { 559 static 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; 352 563 struct snd_pcm_runtime *runtime = substream->runtime; 353 struct snd_dummy_pcm *dpcm;354 564 int err; 355 565 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; 362 577 if (substream->pcm->device & 1) { 363 578 runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED; … … 365 580 } 366 581 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); 370 597 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 602 static 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 613 static void *dummy_page[2]; 614 615 static 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 627 static 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 643 static 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 650 static 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 657 static 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 663 static 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 674 static 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, 430 686 }; 431 687 … … 434 690 { 435 691 struct snd_pcm *pcm; 692 struct snd_pcm_ops *ops; 436 693 int err; 437 694 … … 441 698 return err; 442 699 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); 445 706 pcm->private_data = dummy; 446 707 pcm->info_flags = 0; 447 708 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 */ 453 721 454 722 #define DUMMY_VOLUME(xname, xindex, addr) \ … … 569 837 int err; 570 838 571 if (snd_BUG_ON(!dummy))572 return -EINVAL;573 839 spin_lock_init(&dummy->mixer_lock); 574 840 strcpy(card->mixername, "Dummy Mixer"); … … 582 848 } 583 849 850 #if defined(CONFIG_SND_DEBUG) && defined(CONFIG_PROC_FS) 851 /* 852 * proc interface 853 */ 854 static 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 865 static 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 888 struct 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 900 static 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 914 static 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 936 static 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 965 static 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 584 980 static int __devinit snd_dummy_probe(struct platform_device *devptr) 585 981 { 586 982 struct snd_card *card; 587 983 struct snd_dummy *dummy; 984 struct dummy_model *m = NULL, **mdl; 588 985 int idx, err; 589 986 int dev = devptr->id; … … 595 992 dummy = card->private_data; 596 993 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 } 597 1003 for (idx = 0; idx < MAX_PCM_DEVICES && idx < pcm_devs[dev]; idx++) { 598 1004 if (pcm_substreams[dev] < 1) … … 604 1010 goto __nodev; 605 1011 } 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 606 1039 err = snd_card_dummy_new_mixer(dummy); 607 1040 if (err < 0) … … 610 1043 strcpy(card->shortname, "Dummy"); 611 1044 sprintf(card->longname, "Dummy %i", dev + 1); 1045 1046 dummy_proc_init(dummy); 612 1047 613 1048 snd_card_set_dev(card, &devptr->dev); … … 671 1106 platform_device_unregister(devices[i]); 672 1107 platform_driver_unregister(&snd_dummy_driver); 1108 free_fake_buffer(); 673 1109 } 674 1110 … … 680 1116 if (err < 0) 681 1117 return err; 1118 1119 err = alloc_fake_buffer(); 1120 if (err < 0) { 1121 platform_driver_unregister(&snd_dummy_driver); 1122 return err; 1123 } 682 1124 683 1125 cards = 0; -
GPL/trunk/alsa-kernel/drivers/mpu401/mpu401.c
r410 r587 22 22 23 23 #ifdef TARGET_OS2 24 #include < sound/config.h>24 #include <config.h> 25 25 #endif 26 26 #include <linux/init.h> -
GPL/trunk/alsa-kernel/drivers/mtpav.c
r426 r587 53 53 #include <linux/init.h> 54 54 #include <linux/interrupt.h> 55 #include <linux/module.h> 55 56 #include <linux/err.h> 56 57 #include <linux/platform_device.h> 57 #include <linux/slab.h>58 58 #include <linux/ioport.h> 59 #include <linux/io.h> 59 60 #include <linux/moduleparam.h> 60 61 #include <sound/core.h> … … 62 63 #include <sound/rawmidi.h> 63 64 #include <linux/delay.h> 64 65 #include <asm/io.h>66 65 67 66 /* … … 592 591 } 593 592 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)) { 595 594 snd_printk(KERN_ERR "MTVAP IRQ %d busy\n", irq); 596 595 return -EBUSY; -
GPL/trunk/alsa-kernel/drivers/serial-u16550.c
r426 r587 37 37 #include <linux/slab.h> 38 38 #include <linux/ioport.h> 39 #include <linux/module param.h>39 #include <linux/module.h> 40 40 #include <sound/core.h> 41 41 #include <sound/rawmidi.h> … … 70 70 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 71 71 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 72 static intenable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; /* Enable this card */72 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; /* Enable this card */ 73 73 static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* 0x3f8,0x2f8,0x3e8,0x2e8 */ 74 74 static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 3,4,5,7,9,10,11,14,15 */ … … 78 78 static int ins[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; /* 1 to 16 */ 79 79 static int adaptor[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = SNDRV_SERIAL_SOUNDCANVAS}; 80 static intdroponfull[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS -1)] = SNDRV_SERIAL_NORMALBUFF };80 static bool droponfull[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS -1)] = SNDRV_SERIAL_NORMALBUFF }; 81 81 82 82 module_param_array(index, int, NULL, 0444); … … 817 817 if (irq >= 0 && irq != SNDRV_AUTO_IRQ) { 818 818 if (request_irq(irq, snd_uart16550_interrupt, 819 IRQF_DISABLED, "Serial MIDI", uart)) {819 0, "Serial MIDI", uart)) { 820 820 snd_printk(KERN_WARNING 821 821 "irq %d busy. Using Polling.\n", irq); -
GPL/trunk/alsa-kernel/drivers/virmidi.c
r426 r587 46 46 #include <linux/err.h> 47 47 #include <linux/platform_device.h> 48 #include <linux/module param.h>48 #include <linux/module.h> 49 49 #include <sound/core.h> 50 50 #include <sound/seq_kernel.h> … … 64 64 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 65 65 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 66 static intenable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0};66 static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0}; 67 67 static int midi_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 4}; 68 68 … … 95 95 if (err < 0) 96 96 return err; 97 vmidi = (struct snd_card_virmidi *)card->private_data;97 vmidi = card->private_data; 98 98 vmidi->card = card; 99 99 -
GPL/trunk/alsa-kernel/include/sound/asequencer.h
r305 r587 68 68 #define SNDRV_SEQ_EVENT_TIMESIGN 23 /* SMF Time Signature event */ 69 69 #define SNDRV_SEQ_EVENT_KEYSIGN 24 /* SMF Key Signature event */ 70 70 71 71 /** timer messages 72 72 * event data type = snd_seq_ev_queue_control … … 222 222 223 223 /* external stored data */ 224 #ifndef TARGET_OS2 224 #ifndef TARGET_OS2 225 225 struct snd_seq_ev_ext { 226 226 unsigned int len; /* length of data */ … … 235 235 #pragma pack() 236 236 #endif 237 237 238 struct snd_seq_result { 238 239 int event; /* processed event type */ … … 273 274 274 275 /* quoted event - inside the kernel only */ 275 #ifndef TARGET_OS2 276 #ifndef TARGET_OS2 276 277 struct snd_seq_ev_quote { 277 278 struct snd_seq_addr origin; /* original sender */ … … 422 423 #define USER_CLIENT ((__force snd_seq_client_type_t) 1) 423 424 #define KERNEL_CLIENT ((__force snd_seq_client_type_t) 2) 424 425 425 426 /* event filter flags */ 426 427 #define SNDRV_SEQ_FILTER_BROADCAST (1<<0) /* accept broadcast messages */ -
GPL/trunk/alsa-kernel/include/sound/asound.h
r542 r587 42 42 #endif /* __KERNEL__ **/ 43 43 44 #ifdef TARGET_OS2 44 45 #ifndef __force 45 46 #define __force … … 50 51 #endif 51 52 52 #ifdef TARGET_OS253 53 #define SNDRV_PCM_VOL_FRONT_LEFT 0 54 54 #define SNDRV_PCM_VOL_FRONT_RIGHT 1 … … 323 323 typedef int snd_pcm_hw_param_t; 324 324 #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 326 329 #define SNDRV_PCM_HW_PARAM_RATE_MASK 1 /* Format */ 327 #endif328 330 #define SNDRV_PCM_HW_PARAM_FORMAT 2 /* Format */ 329 331 #define SNDRV_PCM_HW_PARAM_SUBFORMAT 3 /* Subformat */ 332 #endif 330 333 #define SNDRV_PCM_HW_PARAM_FIRST_MASK SNDRV_PCM_HW_PARAM_ACCESS 331 334 #define SNDRV_PCM_HW_PARAM_LAST_MASK SNDRV_PCM_HW_PARAM_SUBFORMAT … … 356 359 #define SNDRV_PCM_HW_PARAM_LAST_INTERVAL SNDRV_PCM_HW_PARAM_TICK_TIME 357 360 358 #define SNDRV_PCM_HW_PARAMS_NORESAMPLE 361 #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ 359 362 360 363 struct snd_interval { … … 789 792 unsigned int device; /* device/client number */ 790 793 unsigned int subdevice; /* subdevice (substream) number */ 791 unsigned char name[44]; /* ASCII name of item */794 unsigned char name[44]; /* ASCII name of item */ 792 795 unsigned int index; /* index of item */ 793 796 }; … … 836 839 struct snd_ctl_elem_id id; /* W: element ID */ 837 840 unsigned int indirect: 1; /* W: indirect access - obsoleted */ 838 union {841 union { 839 842 union { 840 843 long value[128]; … … 854 857 } bytes; 855 858 struct snd_aes_iec958 iec958; 856 } value; /* RO */859 } value; /* RO */ 857 860 struct timespec tstamp; 858 unsigned char reserved[128-sizeof(struct timespec)];861 unsigned char reserved[128-sizeof(struct timespec)]; 859 862 }; 860 863 -
GPL/trunk/alsa-kernel/include/sound/core.h
r464 r587 23 23 */ 24 24 #ifdef TARGET_OS2 25 #include < sound\config.h>25 #include <config.h> 26 26 #endif 27 27 … … 101 101 struct snd_monitor_file { 102 102 struct file *file; 103 #ifndef TARGET_OS2 103 #ifndef TARGET_OS2 104 104 const struct file_operations *disconnected_f_op; 105 105 #else 106 106 struct file_operations *disconnected_f_op; 107 #endif 107 #endif 108 108 struct list_head shutdown_list; /* still need to shutdown */ 109 109 struct list_head list; /* link of monitor files */ … … 205 205 int card; /* card number */ 206 206 int device; /* device number */ 207 #ifndef TARGET_OS2 207 #ifndef TARGET_OS2 208 208 const struct file_operations *f_ops; /* file operations */ 209 209 #else 210 210 struct file_operations *f_ops; /* file operations */ 211 #endif 211 #endif 212 212 void *private_data; /* private data for f_ops->open */ 213 213 struct device *dev; /* device for sysfs */ … … 234 234 int snd_register_device_for_dev(int type, struct snd_card *card, 235 235 int dev, 236 #ifndef TARGET_OS2 236 #ifndef TARGET_OS2 237 237 const struct file_operations *f_ops, 238 238 #else 239 239 struct file_operations *f_ops, 240 #endif 240 #endif 241 241 void *private_data, 242 242 const char *name, … … 263 263 #ifndef TARGET_OS2 264 264 const struct file_operations *f_ops, 265 #else 265 #else 266 266 struct file_operations *f_ops, 267 #endif 267 #endif 268 268 void *private_data, 269 269 const char *name) … … 285 285 #else 286 286 struct file_operations *f_ops, void *private_data, 287 #endif 287 #endif 288 288 const char *name); 289 289 int snd_unregister_oss_device(int type, struct snd_card *card, int dev); … … 376 376 #else 377 377 #define __snd_printk printk 378 #endif /* nothing */378 #endif 379 379 #endif 380 380 … … 418 418 * When CONFIG_SND_DEBUG is set, this macro evaluates the given condition, 419 419 * and call WARN() and returns the value if it's non-zero. 420 * 420 * 421 421 * When CONFIG_SND_DEBUG is not set, this just returns zero, and the given 422 422 * condition is ignored. … … 427 427 * If you want to evaluate and give a warning, use standard WARN_ON(). 428 428 */ 429 430 429 #define snd_BUG_ON(cond) WARN((cond), "BUG? (%s)\n", __stringify(cond)) 431 430 … … 449 448 #define snd_BUG_ON(cond) __snd_bug_on(0 && (cond)) /* always false */ 450 449 #endif 451 452 450 453 451 #endif /* CONFIG_SND_DEBUG */ -
GPL/trunk/alsa-kernel/include/sound/info.h
r410 r587 111 111 #endif 112 112 113 #ifndef TARGET_OS2114 113 int snd_iprintf(struct snd_info_buffer *buffer, char *fmt, ...) \ 115 114 __attribute__ ((format (printf, 2, 3))); 116 #else117 int snd_iprintf(struct snd_info_buffer * buffer, char *fmt,...);118 #endif119 115 int snd_info_init(void); 120 116 int snd_info_done(void); -
GPL/trunk/alsa-kernel/include/sound/initval.h
r398 r587 22 22 */ 23 23 24 #ifdef TARGET_OS2 24 25 #ifndef MODULE_GENERIC_STRING 25 26 #ifdef MODULE … … 32 33 #endif 33 34 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) 38 38 #define module_param_array(name, type, nump, perm) 39 39 #define module_param(name, type, perm) … … 52 52 #define module_param(name, type, perm) \ 53 53 MODULE_PARM(name, SNDRV_MODULE_TYPE_##type) 54 55 54 #endif 56 55 56 #ifndef TARGET_OS2 57 #define SNDRV_AUTO_PORT 1 58 #else 57 59 #define SNDRV_AUTO_PORT 0xffff 60 #endif 58 61 #define SNDRV_AUTO_IRQ 0xffff 59 62 #define SNDRV_AUTO_DMA 0xffff … … 75 78 #define SNDRV_DEFAULT_ENABLE { 1,1,1,1,1,1,1,1 } 76 79 #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 77 85 #define SNDRV_DEFAULT_PORT { REPEAT_SNDRV(-1) } 78 86 #define SNDRV_DEFAULT_IRQ { REPEAT_SNDRV(SNDRV_AUTO_IRQ) } … … 83 91 #define SNDDRV_DEFAULT_PCM_SUBSTREAMS {REPEAT_SNDRV(8)}; 84 92 #define SNDDRV_DEFAULT_MIDI_DEVS {REPEAT_SNDRV(4)}; 85 #else86 #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_STR95 #endif96 97 #ifdef CONFIG_PNP98 #define SNDRV_DEFAULT_ENABLE_ISAPNP SNDRV_DEFAULT_ENABLE_PNP99 #else100 #define SNDRV_DEFAULT_ENABLE_ISAPNP SNDRV_DEFAULT_ENABLE101 #endif102 93 103 94 #define SNDRV_BOOLEAN_TRUE_DESC "allows:{{0,Disabled},{1,Enabled}},default:1,dialog:check" … … 119 110 #define SNDRV_PORT12_DESC SNDRV_ENABLED ",allows:{{0,0x3fff}},base:16" 120 111 #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 121 128 122 129 #ifdef SNDRV_LEGACY_FIND_FREE_IRQ … … 157 164 #endif 158 165 166 #ifdef TARGET_OS2 159 167 #if defined(SNDRV_GET_ID) && !defined(MODULE) 160 168 #include <linux/ctype.h> … … 182 190 } 183 191 #endif 192 #endif 184 193 185 #endif /* __INITVAL_H */ 194 #endif /* __SOUND_INITVAL_H */ 195 -
GPL/trunk/alsa-kernel/include/sound/opl3.h
r399 r587 18 18 * 19 19 * With the above exceptions the both sides can be operated independently. 20 * 20 * 21 21 * A 4 OP voice can be created by setting the corresponding 22 22 * bit at offset 4 of the right side. … … 27 27 * 28 28 * 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 30 30 * be connected the left, right or both stereo channels. It can 31 31 * even be left unconnected. This works with 4 OP voices also. … … 189 189 * 190 190 * 191 * 191 * 192 192 * +---+ 193 193 * | | … … 195 195 * |-> 196 196 * >--3----4-+ 197 * 197 * 198 198 * +---+ 199 199 * | | … … 251 251 unsigned char sustain_release; 252 252 unsigned char wave_select; 253 #ifndef TARGET_OS2254 253 } __attribute__((packed)); 255 #else 256 }; 254 #ifdef TARGET_OS2 257 255 #pragma pack() 258 256 #endif … … 343 341 struct snd_midi_channel_set * oss_chset; 344 342 #endif 345 343 346 344 #define OPL3_PATCH_HASH_SIZE 32 347 345 struct fm_patch *patch_table[OPL3_PATCH_HASH_SIZE]; -
GPL/trunk/alsa-kernel/include/sound/pcm.h
r464 r587 74 74 snd_pcm_uframes_t pos, 75 75 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, 77 77 snd_pcm_uframes_t pos, snd_pcm_uframes_t count); 78 78 struct page *(*page)(struct snd_pcm_substream *substream, … … 216 216 217 217 struct 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 - 219 219 SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; 220 220 struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - … … 330 330 int tstamp_type; /* timestamp type */ 331 331 332 /* -- DMA -- */ 332 /* -- DMA -- */ 333 333 unsigned char *dma_area; /* DMA area */ 334 334 dma_addr_t dma_addr; /* physical bus address (not accessible from main CPU) */ … … 538 538 } while (0) 539 539 540 #ifdef TARGET_OS2 540 541 #define snd_pcm_group_for_each_entry(s, substream) \ 541 542 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 542 547 543 548 static inline int snd_pcm_running(struct snd_pcm_substream *substream) … … 592 597 snd_pcm_sframes_t avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr; 593 598 #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 */ 606 611 if (avail < 0) 607 612 avail += runtime->boundary; … … 706 711 } 707 712 708 static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream, 713 static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream, 709 714 struct snd_pcm_substream *master) 710 715 { … … 763 768 void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c); 764 769 void 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, 770 void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b, 766 771 unsigned int k, struct snd_interval *c); 767 772 void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k, … … 788 793 unsigned int min, unsigned int max); 789 794 int 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, 795 int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, 791 796 unsigned int cond, 792 797 snd_pcm_hw_param_t var, 793 798 struct snd_pcm_hw_constraint_list *l); 794 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, 799 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, 795 800 unsigned int cond, 796 801 snd_pcm_hw_param_t var, 797 802 struct snd_pcm_hw_constraint_ratnums *r); 798 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, 803 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, 799 804 unsigned int cond, 800 805 snd_pcm_hw_param_t var, 801 806 struct snd_pcm_hw_constraint_ratdens *r); 802 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, 807 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, 803 808 unsigned int cond, 804 809 unsigned int width, … … 848 853 int snd_pcm_lib_interleave_len(struct snd_pcm_substream *substream); 849 854 int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream, 850 unsigned int cmd, void *arg); 855 unsigned int cmd, void *arg); 851 856 int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream); 852 857 int snd_pcm_playback_xrun_check(struct snd_pcm_substream *substream); -
GPL/trunk/alsa-kernel/include/sound/seq_kernel.h
r358 r587 76 76 77 77 /* interface for kernel client */ 78 #ifndef TARGET_OS279 78 int snd_seq_create_kernel_client(struct snd_card *card, int client_index, 80 79 const char *name_fmt, ...) 81 80 __attribute__ ((format (printf, 3, 4))); 82 #else83 int snd_seq_create_kernel_client(struct snd_card *card, int client_index,84 const char *name_fmt, ...);85 #endif86 81 int snd_seq_delete_kernel_client(int client); 87 82 int 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 4 ROOT=$(%ROOT) 5 6 !include $(ROOT)\tools\header.mif 7 8 9 #=================================================================== 1 10 # 2 # Makefile for ALSA 3 # Copyright (c) 2001 by Jaroslav Kysela <perex@perex.cz> 11 # List of source files 4 12 # 13 #=================================================================== 14 FILES = ac97_codec.obj ac97_pcm.obj ac97_proc.obj 5 15 6 snd-ac97-codec-y := ac97_codec.o ac97_pcm.o 7 snd-ac97-codec-$(CONFIG_PROC_FS) += ac97_proc.o 16 TARGET = ac97 8 17 9 # Toplevel Module Dependency 10 obj-$(CONFIG_SND_AC97_CODEC) += snd-ac97-codec.o 18 LNKFILE = $(OBJDIR)\$(TARGET).lnk 19 20 21 #=================================================================== 22 # 23 # Specific dependencies 24 # 25 #=================================================================== 26 all: $(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 37 clean: .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 4 ROOT=$(%ROOT) 4 5 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 15 FILES = 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 18 TARGET = au88xx 19 20 LNKFILE = $(OBJDIR)\$(TARGET).lnk 21 22 23 #=================================================================== 24 # 25 # Specific dependencies 26 # 27 #=================================================================== 28 all: $(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 39 clean: .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 4 ROOT=$(%ROOT) 2 5 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 #=================================================================== 14 FILES = ca0106_main.obj ca0106_proc.obj ca0106_mixer.obj & 15 ca_midi.obj 16 17 TARGET = ca0106 18 19 LNKFILE = $(OBJDIR)\$(TARGET).lnk 20 21 22 #=================================================================== 23 # 24 # Specific dependencies 25 # 26 #=================================================================== 27 all: $(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 38 clean: .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 847 847 { 848 848 .info = (SNDRV_PCM_INFO_MMAP | 849 SNDRV_PCM_INFO_MMAP_VALID | 849 SNDRV_PCM_INFO_MMAP_VALID | 850 850 SNDRV_PCM_INFO_INTERLEAVED | 851 851 SNDRV_PCM_INFO_BLOCK_TRANSFER | … … 1958 1958 */ 1959 1959 1960 static void snd_ymfpci_proc_read(struct snd_info_entry *entry, 1960 static void snd_ymfpci_proc_read(struct snd_info_entry *entry, 1961 1961 struct snd_info_buffer *buffer) 1962 1962 { … … 2112 2112 covered with the kernel page allocation mechanism */ 2113 2113 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) 2115 2115 return -ENOMEM; 2116 2116 ptr = chip->work_ptr.area; … … 2218 2218 #if 0 2219 2219 /* FIXME: temporarily disabled, otherwise we cannot fire up 2220 * the chip again unless reboot. ACPI bug?2220 * the chip again unless reboot. 2221 2221 */ 2222 2222 pci_set_power_state(chip->pci, 3);
Note:
See TracChangeset
for help on using the changeset viewer.