?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / sound / oss / ymfpci.c
blob05203ad523f7a207f8f8ae8f035dcc2a834414b4
1 /*
2 * Copyright 1999 Jaroslav Kysela <perex@suse.cz>
3 * Copyright 2000 Alan Cox <alan@redhat.com>
4 * Copyright 2001 Kai Germaschewski <kai@tp1.ruhr-uni-bochum.de>
5 * Copyright 2002 Pete Zaitcev <zaitcev@yahoo.com>
6 *
7 * Yamaha YMF7xx driver.
8 *
9 * This code is a result of high-speed collision
10 * between ymfpci.c of ALSA and cs46xx.c of Linux.
11 * -- Pete Zaitcev <zaitcev@yahoo.com>; 2000/09/18
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 *
27 * TODO:
28 * - Use P44Slot for 44.1 playback (beware of idle buzzing in P44Slot).
29 * - 96KHz playback for DVD - use pitch of 2.0.
30 * - Retain DMA buffer on close, do not wait the end of frame.
31 * - Resolve XXX tagged questions.
32 * - Cannot play 5133Hz.
33 * - 2001/01/07 Consider if we can remove voice_lock, like so:
34 * : Allocate/deallocate voices in open/close under semafore.
35 * : We access voices in interrupt, that only for pcms that open.
36 * voice_lock around playback_prepare closes interrupts for insane duration.
37 * - Revisit the way voice_alloc is done - too confusing, overcomplicated.
38 * Should support various channel types, however.
39 * - Remove prog_dmabuf from read/write, leave it in open.
40 * - 2001/01/07 Replace the OPL3 part of CONFIG_SOUND_YMFPCI_LEGACY code with
41 * native synthesizer through a playback slot.
42 * - 2001/11/29 ac97_save_state
43 * Talk to Kai to remove ac97_save_state before it's too late!
44 * - Second AC97
45 * - Restore S/PDIF - Toshibas have it.
46 *
47 * Kai used pci_alloc_consistent for DMA buffer, which sounds a little
48 * unconventional. However, given how small our fragments can be,
49 * a little uncached access is perhaps better than endless flushing.
50 * On i386 and other I/O-coherent architectures pci_alloc_consistent
51 * is entirely harmless.
52 */
53
54 #include <linux/config.h>
55 #include <linux/module.h>
56 #include <linux/init.h>
57 #include <linux/interrupt.h>
58 #include <linux/ioport.h>
59 #include <linux/delay.h>
60 #include <linux/pci.h>
61 #include <linux/slab.h>
62 #include <linux/poll.h>
63 #include <linux/soundcard.h>
64 #include <linux/ac97_codec.h>
65 #include <linux/sound.h>
66
67 #include <asm/io.h>
68 #include <asm/dma.h>
69 #include <asm/uaccess.h>
70
71 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
72 # include "sound_config.h"
73 # include "mpu401.h"
74 #endif
75 #include "ymfpci.h"
76
77 /*
78 * I do not believe in debug levels as I never can guess what
79 * part of the code is going to be problematic in the future.
80 * Don't forget to run your klogd with -c 8.
81 *
82 * Example (do not remove):
83 * #define YMFDBG(fmt, arg...) do{ printk(KERN_DEBUG fmt, ##arg); }while(0)
84 */
85 #define YMFDBGW(fmt, arg...) /* */ /* write counts */
86 #define YMFDBGI(fmt, arg...) /* */ /* interrupts */
87 #define YMFDBGX(fmt, arg...) /* */ /* ioctl */
88
89 static int ymf_playback_trigger(ymfpci_t *unit, struct ymf_pcm *ypcm, int cmd);
90 static void ymf_capture_trigger(ymfpci_t *unit, struct ymf_pcm *ypcm, int cmd);
91 static void ymfpci_voice_free(ymfpci_t *unit, ymfpci_voice_t *pvoice);
92 static int ymf_capture_alloc(struct ymf_unit *unit, int *pbank);
93 static int ymf_playback_prepare(struct ymf_state *state);
94 static int ymf_capture_prepare(struct ymf_state *state);
95 static struct ymf_state *ymf_state_alloc(ymfpci_t *unit);
96
97 static void ymfpci_aclink_reset(struct pci_dev * pci);
98 static void ymfpci_disable_dsp(ymfpci_t *unit);
99 static void ymfpci_download_image(ymfpci_t *codec);
100 static void ymf_memload(ymfpci_t *unit);
101
102 static DEFINE_SPINLOCK(ymf_devs_lock);
103 static LIST_HEAD(ymf_devs);
104
105 /*
106 * constants
107 */
108
109 static struct pci_device_id ymf_id_tbl[] = {
110 #define DEV(v, d, data) \
111 { PCI_VENDOR_ID_##v, PCI_DEVICE_ID_##v##_##d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (unsigned long)data }
112 DEV (YAMAHA, 724, "YMF724"),
113 DEV (YAMAHA, 724F, "YMF724F"),
114 DEV (YAMAHA, 740, "YMF740"),
115 DEV (YAMAHA, 740C, "YMF740C"),
116 DEV (YAMAHA, 744, "YMF744"),
117 DEV (YAMAHA, 754, "YMF754"),
118 #undef DEV
119 { }
120 };
121 MODULE_DEVICE_TABLE(pci, ymf_id_tbl);
122
123 /*
124 * common I/O routines
125 */
126
127 static inline void ymfpci_writeb(ymfpci_t *codec, u32 offset, u8 val)
128 {
129 writeb(val, codec->reg_area_virt + offset);
130 }
131
132 static inline u16 ymfpci_readw(ymfpci_t *codec, u32 offset)
133 {
134 return readw(codec->reg_area_virt + offset);
135 }
136
137 static inline void ymfpci_writew(ymfpci_t *codec, u32 offset, u16 val)
138 {
139 writew(val, codec->reg_area_virt + offset);
140 }
141
142 static inline u32 ymfpci_readl(ymfpci_t *codec, u32 offset)
143 {
144 return readl(codec->reg_area_virt + offset);
145 }
146
147 static inline void ymfpci_writel(ymfpci_t *codec, u32 offset, u32 val)
148 {
149 writel(val, codec->reg_area_virt + offset);
150 }
151
152 static int ymfpci_codec_ready(ymfpci_t *codec, int secondary, int sched)
153 {
154 signed long end_time;
155 u32 reg = secondary ? YDSXGR_SECSTATUSADR : YDSXGR_PRISTATUSADR;
156
157 end_time = jiffies + 3 * (HZ / 4);
158 do {
159 if ((ymfpci_readw(codec, reg) & 0x8000) == 0)
160 return 0;
161 if (sched) {
162 set_current_state(TASK_UNINTERRUPTIBLE);
163 schedule_timeout(1);
164 }
165 } while (end_time - (signed long)jiffies >= 0);
166 printk(KERN_ERR "ymfpci_codec_ready: codec %i is not ready [0x%x]\n",
167 secondary, ymfpci_readw(codec, reg));
168 return -EBUSY;
169 }
170
171 static void ymfpci_codec_write(struct ac97_codec *dev, u8 reg, u16 val)
172 {
173 ymfpci_t *codec = dev->private_data;
174 u32 cmd;
175
176 spin_lock(&codec->ac97_lock);
177 /* XXX Do make use of dev->id */
178 ymfpci_codec_ready(codec, 0, 0);
179 cmd = ((YDSXG_AC97WRITECMD | reg) << 16) | val;
180 ymfpci_writel(codec, YDSXGR_AC97CMDDATA, cmd);
181 spin_unlock(&codec->ac97_lock);
182 }
183
184 static u16 _ymfpci_codec_read(ymfpci_t *unit, u8 reg)
185 {
186 int i;
187
188 if (ymfpci_codec_ready(unit, 0, 0))
189 return ~0;
190 ymfpci_writew(unit, YDSXGR_AC97CMDADR, YDSXG_AC97READCMD | reg);
191 if (ymfpci_codec_ready(unit, 0, 0))
192 return ~0;
193 if (unit->pci->device == PCI_DEVICE_ID_YAMAHA_744 && unit->rev < 2) {
194 for (i = 0; i < 600; i++)
195 ymfpci_readw(unit, YDSXGR_PRISTATUSDATA);
196 }
197 return ymfpci_readw(unit, YDSXGR_PRISTATUSDATA);
198 }
199
200 static u16 ymfpci_codec_read(struct ac97_codec *dev, u8 reg)
201 {
202 ymfpci_t *unit = dev->private_data;
203 u16 ret;
204
205 spin_lock(&unit->ac97_lock);
206 ret = _ymfpci_codec_read(unit, reg);
207 spin_unlock(&unit->ac97_lock);
208
209 return ret;
210 }
211
212 /*
213 * Misc routines
214 */
215
216 /*
217 * Calculate the actual sampling rate relatetively to the base clock (48kHz).
218 */
219 static u32 ymfpci_calc_delta(u32 rate)
220 {
221 switch (rate) {
222 case 8000: return 0x02aaab00;
223 case 11025: return 0x03accd00;
224 case 16000: return 0x05555500;
225 case 22050: return 0x07599a00;
226 case 32000: return 0x0aaaab00;
227 case 44100: return 0x0eb33300;
228 default: return ((rate << 16) / 48000) << 12;
229 }
230 }
231
232 static u32 def_rate[8] = {
233 100, 2000, 8000, 11025, 16000, 22050, 32000, 48000
234 };
235
236 static u32 ymfpci_calc_lpfK(u32 rate)
237 {
238 u32 i;
239 static u32 val[8] = {
240 0x00570000, 0x06AA0000, 0x18B20000, 0x20930000,
241 0x2B9A0000, 0x35A10000, 0x3EAA0000, 0x40000000
242 };
243
244 if (rate == 44100)
245 return 0x40000000; /* FIXME: What's the right value? */
246 for (i = 0; i < 8; i++)
247 if (rate <= def_rate[i])
248 return val[i];
249 return val[0];
250 }
251
252 static u32 ymfpci_calc_lpfQ(u32 rate)
253 {
254 u32 i;
255 static u32 val[8] = {
256 0x35280000, 0x34A70000, 0x32020000, 0x31770000,
257 0x31390000, 0x31C90000, 0x33D00000, 0x40000000
258 };
259
260 if (rate == 44100)
261 return 0x370A0000;
262 for (i = 0; i < 8; i++)
263 if (rate <= def_rate[i])
264 return val[i];
265 return val[0];
266 }
267
268 static u32 ymf_calc_lend(u32 rate)
269 {
270 return (rate * YMF_SAMPF) / 48000;
271 }
272
273 /*
274 * We ever allow only a few formats, but let's be generic, for smaller surprise.
275 */
276 static int ymf_pcm_format_width(int format)
277 {
278 static int mask16 = AFMT_S16_LE|AFMT_S16_BE|AFMT_U16_LE|AFMT_U16_BE;
279
280 if ((format & (format-1)) != 0) {
281 printk(KERN_ERR "ymfpci: format 0x%x is not a power of 2\n", format);
282 return 8;
283 }
284
285 if (format == AFMT_IMA_ADPCM) return 4;
286 if ((format & mask16) != 0) return 16;
287 return 8;
288 }
289
290 static void ymf_pcm_update_shift(struct ymf_pcm_format *f)
291 {
292 f->shift = 0;
293 if (f->voices == 2)
294 f->shift++;
295 if (ymf_pcm_format_width(f->format) == 16)
296 f->shift++;
297 }
298
299 /* Are you sure 32K is not too much? See if mpg123 skips on loaded systems. */
300 #define DMABUF_DEFAULTORDER (15-PAGE_SHIFT)
301 #define DMABUF_MINORDER 1
302
303 /*
304 * Allocate DMA buffer
305 */
306 static int alloc_dmabuf(ymfpci_t *unit, struct ymf_dmabuf *dmabuf)
307 {
308 void *rawbuf = NULL;
309 dma_addr_t dma_addr;
310 int order;
311 struct page *map, *mapend;
312
313 /* alloc as big a chunk as we can */
314 for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
315 rawbuf = pci_alloc_consistent(unit->pci, PAGE_SIZE << order, &dma_addr);
316 if (rawbuf)
317 break;
318 }
319 if (!rawbuf)
320 return -ENOMEM;
321
322 #if 0
323 printk(KERN_DEBUG "ymfpci: allocated %ld (order = %d) bytes at %p\n",
324 PAGE_SIZE << order, order, rawbuf);
325 #endif
326
327 dmabuf->ready = dmabuf->mapped = 0;
328 dmabuf->rawbuf = rawbuf;
329 dmabuf->dma_addr = dma_addr;
330 dmabuf->buforder = order;
331
332 /* now mark the pages as reserved; otherwise remap_pfn_range doesn't do what we want */
333 mapend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
334 for (map = virt_to_page(rawbuf); map <= mapend; map++)
335 set_bit(PG_reserved, &map->flags);
336
337 return 0;
338 }
339
340 /*
341 * Free DMA buffer
342 */
343 static void dealloc_dmabuf(ymfpci_t *unit, struct ymf_dmabuf *dmabuf)
344 {
345 struct page *map, *mapend;
346
347 if (dmabuf->rawbuf) {
348 /* undo marking the pages as reserved */
349 mapend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
350 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
351 clear_bit(PG_reserved, &map->flags);
352
353 pci_free_consistent(unit->pci, PAGE_SIZE << dmabuf->buforder,
354 dmabuf->rawbuf, dmabuf->dma_addr);
355 }
356 dmabuf->rawbuf = NULL;
357 dmabuf->mapped = dmabuf->ready = 0;
358 }
359
360 static int prog_dmabuf(struct ymf_state *state, int rec)
361 {
362 struct ymf_dmabuf *dmabuf;
363 int w_16;
364 unsigned bufsize;
365 unsigned long flags;
366 int redzone, redfrags;
367 int ret;
368
369 w_16 = ymf_pcm_format_width(state->format.format) == 16;
370 dmabuf = rec ? &state->rpcm.dmabuf : &state->wpcm.dmabuf;
371
372 spin_lock_irqsave(&state->unit->reg_lock, flags);
373 dmabuf->hwptr = dmabuf->swptr = 0;
374 dmabuf->total_bytes = 0;
375 dmabuf->count = 0;
376 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
377
378 /* allocate DMA buffer if not allocated yet */
379 if (!dmabuf->rawbuf)
380 if ((ret = alloc_dmabuf(state->unit, dmabuf)))
381 return ret;
382
383 /*
384 * Create fake fragment sizes and numbers for OSS ioctls.
385 * Import what Doom might have set with SNDCTL_DSP_SETFRAGMENT.
386 */
387 bufsize = PAGE_SIZE << dmabuf->buforder;
388 /* By default we give 4 big buffers. */
389 dmabuf->fragshift = (dmabuf->buforder + PAGE_SHIFT - 2);
390 if (dmabuf->ossfragshift > 3 &&
391 dmabuf->ossfragshift < dmabuf->fragshift) {
392 /* If OSS set smaller fragments, give more smaller buffers. */
393 dmabuf->fragshift = dmabuf->ossfragshift;
394 }
395 dmabuf->fragsize = 1 << dmabuf->fragshift;
396
397 dmabuf->numfrag = bufsize >> dmabuf->fragshift;
398 dmabuf->dmasize = dmabuf->numfrag << dmabuf->fragshift;
399
400 if (dmabuf->ossmaxfrags >= 2) {
401 redzone = ymf_calc_lend(state->format.rate);
402 redzone <<= state->format.shift;
403 redzone *= 3;
404 redfrags = (redzone + dmabuf->fragsize-1) >> dmabuf->fragshift;
405
406 if (dmabuf->ossmaxfrags + redfrags < dmabuf->numfrag) {
407 dmabuf->numfrag = dmabuf->ossmaxfrags + redfrags;
408 dmabuf->dmasize = dmabuf->numfrag << dmabuf->fragshift;
409 }
410 }
411
412 memset(dmabuf->rawbuf, w_16 ? 0 : 0x80, dmabuf->dmasize);
413
414 /*
415 * Now set up the ring
416 */
417
418 /* XXX ret = rec? cap_pre(): pbk_pre(); */
419 spin_lock_irqsave(&state->unit->voice_lock, flags);
420 if (rec) {
421 if ((ret = ymf_capture_prepare(state)) != 0) {
422 spin_unlock_irqrestore(&state->unit->voice_lock, flags);
423 return ret;
424 }
425 } else {
426 if ((ret = ymf_playback_prepare(state)) != 0) {
427 spin_unlock_irqrestore(&state->unit->voice_lock, flags);
428 return ret;
429 }
430 }
431 spin_unlock_irqrestore(&state->unit->voice_lock, flags);
432
433 /* set the ready flag for the dma buffer (this comment is not stupid) */
434 dmabuf->ready = 1;
435
436 #if 0
437 printk(KERN_DEBUG "prog_dmabuf: rate %d format 0x%x,"
438 " numfrag %d fragsize %d dmasize %d\n",
439 state->format.rate, state->format.format, dmabuf->numfrag,
440 dmabuf->fragsize, dmabuf->dmasize);
441 #endif
442
443 return 0;
444 }
445
446 static void ymf_start_dac(struct ymf_state *state)
447 {
448 ymf_playback_trigger(state->unit, &state->wpcm, 1);
449 }
450
451 // static void ymf_start_adc(struct ymf_state *state)
452 // {
453 // ymf_capture_trigger(state->unit, &state->rpcm, 1);
454 // }
455
456 /*
457 * Wait until output is drained.
458 * This does not kill the hardware for the sake of ioctls.
459 */
460 static void ymf_wait_dac(struct ymf_state *state)
461 {
462 struct ymf_unit *unit = state->unit;
463 struct ymf_pcm *ypcm = &state->wpcm;
464 DECLARE_WAITQUEUE(waita, current);
465 unsigned long flags;
466
467 add_wait_queue(&ypcm->dmabuf.wait, &waita);
468
469 spin_lock_irqsave(&unit->reg_lock, flags);
470 if (ypcm->dmabuf.count != 0 && !ypcm->running) {
471 ymf_playback_trigger(unit, ypcm, 1);
472 }
473
474 #if 0
475 if (file->f_flags & O_NONBLOCK) {
476 /*
477 * XXX Our mistake is to attach DMA buffer to state
478 * rather than to some per-device structure.
479 * Cannot skip waiting, can only make it shorter.
480 */
481 }
482 #endif
483
484 set_current_state(TASK_UNINTERRUPTIBLE);
485 while (ypcm->running) {
486 spin_unlock_irqrestore(&unit->reg_lock, flags);
487 schedule();
488 spin_lock_irqsave(&unit->reg_lock, flags);
489 set_current_state(TASK_UNINTERRUPTIBLE);
490 }
491 spin_unlock_irqrestore(&unit->reg_lock, flags);
492
493 set_current_state(TASK_RUNNING);
494 remove_wait_queue(&ypcm->dmabuf.wait, &waita);
495
496 /*
497 * This function may take up to 4 seconds to reach this point
498 * (32K circular buffer, 8000 Hz). User notices.
499 */
500 }
501
502 /* Can just stop, without wait. Or can we? */
503 static void ymf_stop_adc(struct ymf_state *state)
504 {
505 struct ymf_unit *unit = state->unit;
506 unsigned long flags;
507
508 spin_lock_irqsave(&unit->reg_lock, flags);
509 ymf_capture_trigger(unit, &state->rpcm, 0);
510 spin_unlock_irqrestore(&unit->reg_lock, flags);
511 }
512
513 /*
514 * Hardware start management
515 */
516
517 static void ymfpci_hw_start(ymfpci_t *unit)
518 {
519 unsigned long flags;
520
521 spin_lock_irqsave(&unit->reg_lock, flags);
522 if (unit->start_count++ == 0) {
523 ymfpci_writel(unit, YDSXGR_MODE,
524 ymfpci_readl(unit, YDSXGR_MODE) | 3);
525 unit->active_bank = ymfpci_readl(unit, YDSXGR_CTRLSELECT) & 1;
526 }
527 spin_unlock_irqrestore(&unit->reg_lock, flags);
528 }
529
530 static void ymfpci_hw_stop(ymfpci_t *unit)
531 {
532 unsigned long flags;
533 long timeout = 1000;
534
535 spin_lock_irqsave(&unit->reg_lock, flags);
536 if (--unit->start_count == 0) {
537 ymfpci_writel(unit, YDSXGR_MODE,
538 ymfpci_readl(unit, YDSXGR_MODE) & ~3);
539 while (timeout-- > 0) {
540 if ((ymfpci_readl(unit, YDSXGR_STATUS) & 2) == 0)
541 break;
542 }
543 }
544 spin_unlock_irqrestore(&unit->reg_lock, flags);
545 }
546
547 /*
548 * Playback voice management
549 */
550
551 static int voice_alloc(ymfpci_t *codec, ymfpci_voice_type_t type, int pair, ymfpci_voice_t *rvoice[])
552 {
553 ymfpci_voice_t *voice, *voice2;
554 int idx;
555
556 for (idx = 0; idx < YDSXG_PLAYBACK_VOICES; idx += pair ? 2 : 1) {
557 voice = &codec->voices[idx];
558 voice2 = pair ? &codec->voices[idx+1] : NULL;
559 if (voice->use || (voice2 && voice2->use))
560 continue;
561 voice->use = 1;
562 if (voice2)
563 voice2->use = 1;
564 switch (type) {
565 case YMFPCI_PCM:
566 voice->pcm = 1;
567 if (voice2)
568 voice2->pcm = 1;
569 break;
570 case YMFPCI_SYNTH:
571 voice->synth = 1;
572 break;
573 case YMFPCI_MIDI:
574 voice->midi = 1;
575 break;
576 }
577 ymfpci_hw_start(codec);
578 rvoice[0] = voice;
579 if (voice2) {
580 ymfpci_hw_start(codec);
581 rvoice[1] = voice2;
582 }
583 return 0;
584 }
585 return -EBUSY; /* Your audio channel is open by someone else. */
586 }
587
588 static void ymfpci_voice_free(ymfpci_t *unit, ymfpci_voice_t *pvoice)
589 {
590 ymfpci_hw_stop(unit);
591 pvoice->use = pvoice->pcm = pvoice->synth = pvoice->midi = 0;
592 pvoice->ypcm = NULL;
593 }
594
595 /*
596 */
597
598 static void ymf_pcm_interrupt(ymfpci_t *codec, ymfpci_voice_t *voice)
599 {
600 struct ymf_pcm *ypcm;
601 int redzone;
602 int pos, delta, swptr;
603 int played, distance;
604 struct ymf_state *state;
605 struct ymf_dmabuf *dmabuf;
606 char silence;
607
608 if ((ypcm = voice->ypcm) == NULL) {
609 return;
610 }
611 if ((state = ypcm->state) == NULL) {
612 ypcm->running = 0; // lock it
613 return;
614 }
615 dmabuf = &ypcm->dmabuf;
616 spin_lock(&codec->reg_lock);
617 if (ypcm->running) {
618 YMFDBGI("ymfpci: %d, intr bank %d count %d start 0x%x:%x\n",
619 voice->number, codec->active_bank, dmabuf->count,
620 le32_to_cpu(voice->bank[0].start),
621 le32_to_cpu(voice->bank[1].start));
622 silence = (ymf_pcm_format_width(state->format.format) == 16) ?
623 0 : 0x80;
624 /* We need actual left-hand-side redzone size here. */
625 redzone = ymf_calc_lend(state->format.rate);
626 redzone <<= (state->format.shift + 1);
627 swptr = dmabuf->swptr;
628
629 pos = le32_to_cpu(voice->bank[codec->active_bank].start);
630 pos <<= state->format.shift;
631 if (pos < 0 || pos >= dmabuf->dmasize) { /* ucode bug */
632 printk(KERN_ERR "ymfpci%d: runaway voice %d: hwptr %d=>%d dmasize %d\n",
633 codec->dev_audio, voice->number,
634 dmabuf->hwptr, pos, dmabuf->dmasize);
635 pos = 0;
636 }
637 if (pos < dmabuf->hwptr) {
638 delta = dmabuf->dmasize - dmabuf->hwptr;
639 memset(dmabuf->rawbuf + dmabuf->hwptr, silence, delta);
640 delta += pos;
641 memset(dmabuf->rawbuf, silence, pos);
642 } else {
643 delta = pos - dmabuf->hwptr;
644 memset(dmabuf->rawbuf + dmabuf->hwptr, silence, delta);
645 }
646 dmabuf->hwptr = pos;
647
648 if (dmabuf->count == 0) {
649 printk(KERN_ERR "ymfpci%d: %d: strain: hwptr %d\n",
650 codec->dev_audio, voice->number, dmabuf->hwptr);
651 ymf_playback_trigger(codec, ypcm, 0);
652 }
653
654 if (swptr <= pos) {
655 distance = pos - swptr;
656 } else {
657 distance = dmabuf->dmasize - (swptr - pos);
658 }
659 if (distance < redzone) {
660 /*
661 * hwptr inside redzone => DMA ran out of samples.
662 */
663 if (delta < dmabuf->count) {
664 /*
665 * Lost interrupt or other screwage.
666 */
667 printk(KERN_ERR "ymfpci%d: %d: lost: delta %d"
668 " hwptr %d swptr %d distance %d count %d\n",
669 codec->dev_audio, voice->number, delta,
670 dmabuf->hwptr, swptr, distance, dmabuf->count);
671 } else {
672 /*
673 * Normal end of DMA.
674 */
675 YMFDBGI("ymfpci%d: %d: done: delta %d"
676 " hwptr %d swptr %d distance %d count %d\n",
677 codec->dev_audio, voice->number, delta,
678 dmabuf->hwptr, swptr, distance, dmabuf->count);
679 }
680 played = dmabuf->count;
681 if (ypcm->running) {
682 ymf_playback_trigger(codec, ypcm, 0);
683 }
684 } else {
685 /*
686 * hwptr is chipping away towards a remote swptr.
687 * Calculate other distance and apply it to count.
688 */
689 if (swptr >= pos) {
690 distance = swptr - pos;
691 } else {
692 distance = dmabuf->dmasize - (pos - swptr);
693 }
694 if (distance < dmabuf->count) {
695 played = dmabuf->count - distance;
696 } else {
697 played = 0;
698 }
699 }
700
701 dmabuf->total_bytes += played;
702 dmabuf->count -= played;
703 if (dmabuf->count < dmabuf->dmasize / 2) {
704 wake_up(&dmabuf->wait);
705 }
706 }
707 spin_unlock(&codec->reg_lock);
708 }
709
710 static void ymf_cap_interrupt(ymfpci_t *unit, struct ymf_capture *cap)
711 {
712 struct ymf_pcm *ypcm;
713 int redzone;
714 struct ymf_state *state;
715 struct ymf_dmabuf *dmabuf;
716 int pos, delta;
717 int cnt;
718
719 if ((ypcm = cap->ypcm) == NULL) {
720 return;
721 }
722 if ((state = ypcm->state) == NULL) {
723 ypcm->running = 0; // lock it
724 return;
725 }
726 dmabuf = &ypcm->dmabuf;
727 spin_lock(&unit->reg_lock);
728 if (ypcm->running) {
729 redzone = ymf_calc_lend(state->format.rate);
730 redzone <<= (state->format.shift + 1);
731
732 pos = le32_to_cpu(cap->bank[unit->active_bank].start);
733 // pos <<= state->format.shift;
734 if (pos < 0 || pos >= dmabuf->dmasize) { /* ucode bug */
735 printk(KERN_ERR "ymfpci%d: runaway capture %d: hwptr %d=>%d dmasize %d\n",
736 unit->dev_audio, ypcm->capture_bank_number,
737 dmabuf->hwptr, pos, dmabuf->dmasize);
738 pos = 0;
739 }
740 if (pos < dmabuf->hwptr) {
741 delta = dmabuf->dmasize - dmabuf->hwptr;
742 delta += pos;
743 } else {
744 delta = pos - dmabuf->hwptr;
745 }
746 dmabuf->hwptr = pos;
747
748 cnt = dmabuf->count;
749 cnt += delta;
750 if (cnt + redzone > dmabuf->dmasize) {
751 /* Overflow - bump swptr */
752 dmabuf->count = dmabuf->dmasize - redzone;
753 dmabuf->swptr = dmabuf->hwptr + redzone;
754 if (dmabuf->swptr >= dmabuf->dmasize) {
755 dmabuf->swptr -= dmabuf->dmasize;
756 }
757 } else {
758 dmabuf->count = cnt;
759 }
760
761 dmabuf->total_bytes += delta;
762 if (dmabuf->count) { /* && is_sleeping XXX */
763 wake_up(&dmabuf->wait);
764 }
765 }
766 spin_unlock(&unit->reg_lock);
767 }
768
769 static int ymf_playback_trigger(ymfpci_t *codec, struct ymf_pcm *ypcm, int cmd)
770 {
771
772 if (ypcm->voices[0] == NULL) {
773 return -EINVAL;
774 }
775 if (cmd != 0) {
776 codec->ctrl_playback[ypcm->voices[0]->number + 1] =
777 cpu_to_le32(ypcm->voices[0]->bank_ba);
778 if (ypcm->voices[1] != NULL)
779 codec->ctrl_playback[ypcm->voices[1]->number + 1] =
780 cpu_to_le32(ypcm->voices[1]->bank_ba);
781 ypcm->running = 1;
782 } else {
783 codec->ctrl_playback[ypcm->voices[0]->number + 1] = 0;
784 if (ypcm->voices[1] != NULL)
785 codec->ctrl_playback[ypcm->voices[1]->number + 1] = 0;
786 ypcm->running = 0;
787 }
788 return 0;
789 }
790
791 static void ymf_capture_trigger(ymfpci_t *codec, struct ymf_pcm *ypcm, int cmd)
792 {
793 u32 tmp;
794
795 if (cmd != 0) {
796 tmp = ymfpci_readl(codec, YDSXGR_MAPOFREC) | (1 << ypcm->capture_bank_number);
797 ymfpci_writel(codec, YDSXGR_MAPOFREC, tmp);
798 ypcm->running = 1;
799 } else {
800 tmp = ymfpci_readl(codec, YDSXGR_MAPOFREC) & ~(1 << ypcm->capture_bank_number);
801 ymfpci_writel(codec, YDSXGR_MAPOFREC, tmp);
802 ypcm->running = 0;
803 }
804 }
805
806 static int ymfpci_pcm_voice_alloc(struct ymf_pcm *ypcm, int voices)
807 {
808 struct ymf_unit *unit;
809 int err;
810
811 unit = ypcm->state->unit;
812 if (ypcm->voices[1] != NULL && voices < 2) {
813 ymfpci_voice_free(unit, ypcm->voices[1]);
814 ypcm->voices[1] = NULL;
815 }
816 if (voices == 1 && ypcm->voices[0] != NULL)
817 return 0; /* already allocated */
818 if (voices == 2 && ypcm->voices[0] != NULL && ypcm->voices[1] != NULL)
819 return 0; /* already allocated */
820 if (voices > 1) {
821 if (ypcm->voices[0] != NULL && ypcm->voices[1] == NULL) {
822 ymfpci_voice_free(unit, ypcm->voices[0]);
823 ypcm->voices[0] = NULL;
824 }
825 if ((err = voice_alloc(unit, YMFPCI_PCM, 1, ypcm->voices)) < 0)
826 return err;
827 ypcm->voices[0]->ypcm = ypcm;
828 ypcm->voices[1]->ypcm = ypcm;
829 } else {
830 if ((err = voice_alloc(unit, YMFPCI_PCM, 0, ypcm->voices)) < 0)
831 return err;
832 ypcm->voices[0]->ypcm = ypcm;
833 }
834 return 0;
835 }
836
837 static void ymf_pcm_init_voice(ymfpci_voice_t *voice, int stereo,
838 int rate, int w_16, unsigned long addr, unsigned int end, int spdif)
839 {
840 u32 format;
841 u32 delta = ymfpci_calc_delta(rate);
842 u32 lpfQ = ymfpci_calc_lpfQ(rate);
843 u32 lpfK = ymfpci_calc_lpfK(rate);
844 ymfpci_playback_bank_t *bank;
845 int nbank;
846
847 /*
848 * The gain is a floating point number. According to the manual,
849 * bit 31 indicates a sign bit, bit 30 indicates an integer part,
850 * and bits [29:15] indicate a decimal fraction part. Thus,
851 * for a gain of 1.0 the constant of 0x40000000 is loaded.
852 */
853 unsigned default_gain = cpu_to_le32(0x40000000);
854
855 format = (stereo ? 0x00010000 : 0) | (w_16 ? 0 : 0x80000000);
856 if (stereo)
857 end >>= 1;
858 if (w_16)
859 end >>= 1;
860 for (nbank = 0; nbank < 2; nbank++) {
861 bank = &voice->bank[nbank];
862 bank->format = cpu_to_le32(format);
863 bank->loop_default = 0; /* 0-loops forever, otherwise count */
864 bank->base = cpu_to_le32(addr);
865 bank->loop_start = 0;
866 bank->loop_end = cpu_to_le32(end);
867 bank->loop_frac = 0;
868 bank->eg_gain_end = default_gain;
869 bank->lpfQ = cpu_to_le32(lpfQ);
870 bank->status = 0;
871 bank->num_of_frames = 0;
872 bank->loop_count = 0;
873 bank->start = 0;
874 bank->start_frac = 0;
875 bank->delta =
876 bank->delta_end = cpu_to_le32(delta);
877 bank->lpfK =
878 bank->lpfK_end = cpu_to_le32(lpfK);
879 bank->eg_gain = default_gain;
880 bank->lpfD1 =
881 bank->lpfD2 = 0;
882
883 bank->left_gain =
884 bank->right_gain =
885 bank->left_gain_end =
886 bank->right_gain_end =
887 bank->eff1_gain =
888 bank->eff2_gain =
889 bank->eff3_gain =
890 bank->eff1_gain_end =
891 bank->eff2_gain_end =
892 bank->eff3_gain_end = 0;
893
894 if (!stereo) {
895 if (!spdif) {
896 bank->left_gain =
897 bank->right_gain =
898 bank->left_gain_end =
899 bank->right_gain_end = default_gain;
900 } else {
901 bank->eff2_gain =
902 bank->eff2_gain_end =
903 bank->eff3_gain =
904 bank->eff3_gain_end = default_gain;
905 }
906 } else {
907 if (!spdif) {
908 if ((voice->number & 1) == 0) {
909 bank->left_gain =
910 bank->left_gain_end = default_gain;
911 } else {
912 bank->format |= cpu_to_le32(1);
913 bank->right_gain =
914 bank->right_gain_end = default_gain;
915 }
916 } else {
917 if ((voice->number & 1) == 0) {
918 bank->eff2_gain =
919 bank->eff2_gain_end = default_gain;
920 } else {
921 bank->format |= cpu_to_le32(1);
922 bank->eff3_gain =
923 bank->eff3_gain_end = default_gain;
924 }
925 }
926 }
927 }
928 }
929
930 /*
931 * XXX Capture channel allocation is entirely fake at the moment.
932 * We use only one channel and mark it busy as required.
933 */
934 static int ymf_capture_alloc(struct ymf_unit *unit, int *pbank)
935 {
936 struct ymf_capture *cap;
937 int cbank;
938
939 cbank = 1; /* Only ADC slot is used for now. */
940 cap = &unit->capture[cbank];
941 if (cap->use)
942 return -EBUSY;
943 cap->use = 1;
944 *pbank = cbank;
945 return 0;
946 }
947
948 static int ymf_playback_prepare(struct ymf_state *state)
949 {
950 struct ymf_pcm *ypcm = &state->wpcm;
951 int err, nvoice;
952
953 if ((err = ymfpci_pcm_voice_alloc(ypcm, state->format.voices)) < 0) {
954 /* Somebody started 32 mpg123's in parallel? */
955 printk(KERN_INFO "ymfpci%d: cannot allocate voice\n",
956 state->unit->dev_audio);
957 return err;
958 }
959
960 for (nvoice = 0; nvoice < state->format.voices; nvoice++) {
961 ymf_pcm_init_voice(ypcm->voices[nvoice],
962 state->format.voices == 2, state->format.rate,
963 ymf_pcm_format_width(state->format.format) == 16,
964 ypcm->dmabuf.dma_addr, ypcm->dmabuf.dmasize,
965 ypcm->spdif);
966 }
967 return 0;
968 }
969
970 static int ymf_capture_prepare(struct ymf_state *state)
971 {
972 ymfpci_t *unit = state->unit;
973 struct ymf_pcm *ypcm = &state->rpcm;
974 ymfpci_capture_bank_t * bank;
975 /* XXX This is confusing, gotta rename one of them banks... */
976 int nbank; /* flip-flop bank */
977 int cbank; /* input [super-]bank */
978 struct ymf_capture *cap;
979 u32 rate, format;
980
981 if (ypcm->capture_bank_number == -1) {
982 if (ymf_capture_alloc(unit, &cbank) != 0)
983 return -EBUSY;
984
985 ypcm->capture_bank_number = cbank;
986
987 cap = &unit->capture[cbank];
988 cap->bank = unit->bank_capture[cbank][0];
989 cap->ypcm = ypcm;
990 ymfpci_hw_start(unit);
991 }
992
993 // ypcm->frag_size = snd_pcm_lib_transfer_fragment(substream);
994 // frag_size is replaced with nonfragged byte-aligned rolling buffer
995 rate = ((48000 * 4096) / state->format.rate) - 1;
996 format = 0;
997 if (state->format.voices == 2)
998 format |= 2;
999 if (ymf_pcm_format_width(state->format.format) == 8)
1000 format |= 1;
1001 switch (ypcm->capture_bank_number) {
1002 case 0:
1003 ymfpci_writel(unit, YDSXGR_RECFORMAT, format);
1004 ymfpci_writel(unit, YDSXGR_RECSLOTSR, rate);
1005 break;
1006 case 1:
1007 ymfpci_writel(unit, YDSXGR_ADCFORMAT, format);
1008 ymfpci_writel(unit, YDSXGR_ADCSLOTSR, rate);
1009 break;
1010 }
1011 for (nbank = 0; nbank < 2; nbank++) {
1012 bank = unit->bank_capture[ypcm->capture_bank_number][nbank];
1013 bank->base = cpu_to_le32(ypcm->dmabuf.dma_addr);
1014 // bank->loop_end = ypcm->dmabuf.dmasize >> state->format.shift;
1015 bank->loop_end = cpu_to_le32(ypcm->dmabuf.dmasize);
1016 bank->start = 0;
1017 bank->num_of_loops = 0;
1018 }
1019 #if 0 /* s/pdif */
1020 if (state->digital.dig_valid)
1021 /*state->digital.type == SND_PCM_DIG_AES_IEC958*/
1022 ymfpci_writew(codec, YDSXGR_SPDIFOUTSTATUS,
1023 state->digital.dig_status[0] | (state->digital.dig_status[1] << 8));
1024 #endif
1025 return 0;
1026 }
1027
1028 static irqreturn_t ymf_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1029 {
1030 ymfpci_t *codec = dev_id;
1031 u32 status, nvoice, mode;
1032 struct ymf_voice *voice;
1033 struct ymf_capture *cap;
1034
1035 status = ymfpci_readl(codec, YDSXGR_STATUS);
1036 if (status & 0x80000000) {
1037 codec->active_bank = ymfpci_readl(codec, YDSXGR_CTRLSELECT) & 1;
1038 spin_lock(&codec->voice_lock);
1039 for (nvoice = 0; nvoice < YDSXG_PLAYBACK_VOICES; nvoice++) {
1040 voice = &codec->voices[nvoice];
1041 if (voice->use)
1042 ymf_pcm_interrupt(codec, voice);
1043 }
1044 for (nvoice = 0; nvoice < YDSXG_CAPTURE_VOICES; nvoice++) {
1045 cap = &codec->capture[nvoice];
1046 if (cap->use)
1047 ymf_cap_interrupt(codec, cap);
1048 }
1049 spin_unlock(&codec->voice_lock);
1050 spin_lock(&codec->reg_lock);
1051 ymfpci_writel(codec, YDSXGR_STATUS, 0x80000000);
1052 mode = ymfpci_readl(codec, YDSXGR_MODE) | 2;
1053 ymfpci_writel(codec, YDSXGR_MODE, mode);
1054 spin_unlock(&codec->reg_lock);
1055 }
1056
1057 status = ymfpci_readl(codec, YDSXGR_INTFLAG);
1058 if (status & 1) {
1059 /* timer handler */
1060 ymfpci_writel(codec, YDSXGR_INTFLAG, ~0);
1061 }
1062 return IRQ_HANDLED;
1063 }
1064
1065 static void ymf_pcm_free_substream(struct ymf_pcm *ypcm)
1066 {
1067 unsigned long flags;
1068 struct ymf_unit *unit;
1069
1070 unit = ypcm->state->unit;
1071
1072 if (ypcm->type == PLAYBACK_VOICE) {
1073 spin_lock_irqsave(&unit->voice_lock, flags);
1074 if (ypcm->voices[1])
1075 ymfpci_voice_free(unit, ypcm->voices[1]);
1076 if (ypcm->voices[0])
1077 ymfpci_voice_free(unit, ypcm->voices[0]);
1078 spin_unlock_irqrestore(&unit->voice_lock, flags);
1079 } else {
1080 if (ypcm->capture_bank_number != -1) {
1081 unit->capture[ypcm->capture_bank_number].use = 0;
1082 ypcm->capture_bank_number = -1;
1083 ymfpci_hw_stop(unit);
1084 }
1085 }
1086 }
1087
1088 static struct ymf_state *ymf_state_alloc(ymfpci_t *unit)
1089 {
1090 struct ymf_pcm *ypcm;
1091 struct ymf_state *state;
1092
1093 if ((state = kmalloc(sizeof(struct ymf_state), GFP_KERNEL)) == NULL) {
1094 goto out0;
1095 }
1096 memset(state, 0, sizeof(struct ymf_state));
1097
1098 ypcm = &state->wpcm;
1099 ypcm->state = state;
1100 ypcm->type = PLAYBACK_VOICE;
1101 ypcm->capture_bank_number = -1;
1102 init_waitqueue_head(&ypcm->dmabuf.wait);
1103
1104 ypcm = &state->rpcm;
1105 ypcm->state = state;
1106 ypcm->type = CAPTURE_AC97;
1107 ypcm->capture_bank_number = -1;
1108 init_waitqueue_head(&ypcm->dmabuf.wait);
1109
1110 state->unit = unit;
1111
1112 state->format.format = AFMT_U8;
1113 state->format.rate = 8000;
1114 state->format.voices = 1;
1115 ymf_pcm_update_shift(&state->format);
1116
1117 return state;
1118
1119 out0:
1120 return NULL;
1121 }
1122
1123 /* AES/IEC958 channel status bits */
1124 #define SND_PCM_AES0_PROFESSIONAL (1<<0) /* 0 = consumer, 1 = professional */
1125 #define SND_PCM_AES0_NONAUDIO (1<<1) /* 0 = audio, 1 = non-audio */
1126 #define SND_PCM_AES0_PRO_EMPHASIS (7<<2) /* mask - emphasis */
1127 #define SND_PCM_AES0_PRO_EMPHASIS_NOTID (0<<2) /* emphasis not indicated */
1128 #define SND_PCM_AES0_PRO_EMPHASIS_NONE (1<<2) /* none emphasis */
1129 #define SND_PCM_AES0_PRO_EMPHASIS_5015 (3<<2) /* 50/15us emphasis */
1130 #define SND_PCM_AES0_PRO_EMPHASIS_CCITT (7<<2) /* CCITT J.17 emphasis */
1131 #define SND_PCM_AES0_PRO_FREQ_UNLOCKED (1<<5) /* source sample frequency: 0 = locked, 1 = unlocked */
1132 #define SND_PCM_AES0_PRO_FS (3<<6) /* mask - sample frequency */
1133 #define SND_PCM_AES0_PRO_FS_NOTID (0<<6) /* fs not indicated */
1134 #define SND_PCM_AES0_PRO_FS_44100 (1<<6) /* 44.1kHz */
1135 #define SND_PCM_AES0_PRO_FS_48000 (2<<6) /* 48kHz */
1136 #define SND_PCM_AES0_PRO_FS_32000 (3<<6) /* 32kHz */
1137 #define SND_PCM_AES0_CON_NOT_COPYRIGHT (1<<2) /* 0 = copyright, 1 = not copyright */
1138 #define SND_PCM_AES0_CON_EMPHASIS (7<<3) /* mask - emphasis */
1139 #define SND_PCM_AES0_CON_EMPHASIS_NONE (0<<3) /* none emphasis */
1140 #define SND_PCM_AES0_CON_EMPHASIS_5015 (1<<3) /* 50/15us emphasis */
1141 #define SND_PCM_AES0_CON_MODE (3<<6) /* mask - mode */
1142 #define SND_PCM_AES1_PRO_MODE (15<<0) /* mask - channel mode */
1143 #define SND_PCM_AES1_PRO_MODE_NOTID (0<<0) /* not indicated */
1144 #define SND_PCM_AES1_PRO_MODE_STEREOPHONIC (2<<0) /* stereophonic - ch A is left */
1145 #define SND_PCM_AES1_PRO_MODE_SINGLE (4<<0) /* single channel */
1146 #define SND_PCM_AES1_PRO_MODE_TWO (8<<0) /* two channels */
1147 #define SND_PCM_AES1_PRO_MODE_PRIMARY (12<<0) /* primary/secondary */
1148 #define SND_PCM_AES1_PRO_MODE_BYTE3 (15<<0) /* vector to byte 3 */
1149 #define SND_PCM_AES1_PRO_USERBITS (15<<4) /* mask - user bits */
1150 #define SND_PCM_AES1_PRO_USERBITS_NOTID (0<<4) /* not indicated */
1151 #define SND_PCM_AES1_PRO_USERBITS_192 (8<<4) /* 192-bit structure */
1152 #define SND_PCM_AES1_PRO_USERBITS_UDEF (12<<4) /* user defined application */
1153 #define SND_PCM_AES1_CON_CATEGORY 0x7f
1154 #define SND_PCM_AES1_CON_GENERAL 0x00
1155 #define SND_PCM_AES1_CON_EXPERIMENTAL 0x40
1156 #define SND_PCM_AES1_CON_SOLIDMEM_MASK 0x0f
1157 #define SND_PCM_AES1_CON_SOLIDMEM_ID 0x08
1158 #define SND_PCM_AES1_CON_BROADCAST1_MASK 0x07
1159 #define SND_PCM_AES1_CON_BROADCAST1_ID 0x04
1160 #define SND_PCM_AES1_CON_DIGDIGCONV_MASK 0x07
1161 #define SND_PCM_AES1_CON_DIGDIGCONV_ID 0x02
1162 #define SND_PCM_AES1_CON_ADC_COPYRIGHT_MASK 0x1f
1163 #define SND_PCM_AES1_CON_ADC_COPYRIGHT_ID 0x06
1164 #define SND_PCM_AES1_CON_ADC_MASK 0x1f
1165 #define SND_PCM_AES1_CON_ADC_ID 0x16
1166 #define SND_PCM_AES1_CON_BROADCAST2_MASK 0x0f
1167 #define SND_PCM_AES1_CON_BROADCAST2_ID 0x0e
1168 #define SND_PCM_AES1_CON_LASEROPT_MASK 0x07
1169 #define SND_PCM_AES1_CON_LASEROPT_ID 0x01
1170 #define SND_PCM_AES1_CON_MUSICAL_MASK 0x07
1171 #define SND_PCM_AES1_CON_MUSICAL_ID 0x05
1172 #define SND_PCM_AES1_CON_MAGNETIC_MASK 0x07
1173 #define SND_PCM_AES1_CON_MAGNETIC_ID 0x03
1174 #define SND_PCM_AES1_CON_IEC908_CD (SND_PCM_AES1_CON_LASEROPT_ID|0x00)
1175 #define SND_PCM_AES1_CON_NON_IEC908_CD (SND_PCM_AES1_CON_LASEROPT_ID|0x08)
1176 #define SND_PCM_AES1_CON_PCM_CODER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x00)
1177 #define SND_PCM_AES1_CON_SAMPLER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x20)
1178 #define SND_PCM_AES1_CON_MIXER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x10)
1179 #define SND_PCM_AES1_CON_RATE_CONVERTER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x18)
1180 #define SND_PCM_AES1_CON_SYNTHESIZER (SND_PCM_AES1_CON_MUSICAL_ID|0x00)
1181 #define SND_PCM_AES1_CON_MICROPHONE (SND_PCM_AES1_CON_MUSICAL_ID|0x08)
1182 #define SND_PCM_AES1_CON_DAT (SND_PCM_AES1_CON_MAGNETIC_ID|0x00)
1183 #define SND_PCM_AES1_CON_VCR (SND_PCM_AES1_CON_MAGNETIC_ID|0x08)
1184 #define SND_PCM_AES1_CON_ORIGINAL (1<<7) /* this bits depends on the category code */
1185 #define SND_PCM_AES2_PRO_SBITS (7<<0) /* mask - sample bits */
1186 #define SND_PCM_AES2_PRO_SBITS_20 (2<<0) /* 20-bit - coordination */
1187 #define SND_PCM_AES2_PRO_SBITS_24 (4<<0) /* 24-bit - main audio */
1188 #define SND_PCM_AES2_PRO_SBITS_UDEF (6<<0) /* user defined application */
1189 #define SND_PCM_AES2_PRO_WORDLEN (7<<3) /* mask - source word length */
1190 #define SND_PCM_AES2_PRO_WORDLEN_NOTID (0<<3) /* not indicated */
1191 #define SND_PCM_AES2_PRO_WORDLEN_22_18 (2<<3) /* 22-bit or 18-bit */
1192 #define SND_PCM_AES2_PRO_WORDLEN_23_19 (4<<3) /* 23-bit or 19-bit */
1193 #define SND_PCM_AES2_PRO_WORDLEN_24_20 (5<<3) /* 24-bit or 20-bit */
1194 #define SND_PCM_AES2_PRO_WORDLEN_20_16 (6<<3) /* 20-bit or 16-bit */
1195 #define SND_PCM_AES2_CON_SOURCE (15<<0) /* mask - source number */
1196 #define SND_PCM_AES2_CON_SOURCE_UNSPEC (0<<0) /* unspecified */
1197 #define SND_PCM_AES2_CON_CHANNEL (15<<4) /* mask - channel number */
1198 #define SND_PCM_AES2_CON_CHANNEL_UNSPEC (0<<4) /* unspecified */
1199 #define SND_PCM_AES3_CON_FS (15<<0) /* mask - sample frequency */
1200 #define SND_PCM_AES3_CON_FS_44100 (0<<0) /* 44.1kHz */
1201 #define SND_PCM_AES3_CON_FS_48000 (2<<0) /* 48kHz */
1202 #define SND_PCM_AES3_CON_FS_32000 (3<<0) /* 32kHz */
1203 #define SND_PCM_AES3_CON_CLOCK (3<<4) /* mask - clock accuracy */
1204 #define SND_PCM_AES3_CON_CLOCK_1000PPM (0<<4) /* 1000 ppm */
1205 #define SND_PCM_AES3_CON_CLOCK_50PPM (1<<4) /* 50 ppm */
1206 #define SND_PCM_AES3_CON_CLOCK_VARIABLE (2<<4) /* variable pitch */
1207
1208 /*
1209 * User interface
1210 */
1211
1212 /*
1213 * in this loop, dmabuf.count signifies the amount of data that is
1214 * waiting to be copied to the user's buffer. it is filled by the dma
1215 * machine and drained by this loop.
1216 */
1217 static ssize_t
1218 ymf_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
1219 {
1220 struct ymf_state *state = (struct ymf_state *)file->private_data;
1221 struct ymf_dmabuf *dmabuf = &state->rpcm.dmabuf;
1222 struct ymf_unit *unit = state->unit;
1223 DECLARE_WAITQUEUE(waita, current);
1224 ssize_t ret;
1225 unsigned long flags;
1226 unsigned int swptr;
1227 int cnt; /* This many to go in this revolution */
1228
1229 if (dmabuf->mapped)
1230 return -ENXIO;
1231 if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
1232 return ret;
1233 ret = 0;
1234
1235 add_wait_queue(&dmabuf->wait, &waita);
1236 set_current_state(TASK_INTERRUPTIBLE);
1237 while (count > 0) {
1238 spin_lock_irqsave(&unit->reg_lock, flags);
1239 if (unit->suspended) {
1240 spin_unlock_irqrestore(&unit->reg_lock, flags);
1241 schedule();
1242 set_current_state(TASK_INTERRUPTIBLE);
1243 if (signal_pending(current)) {
1244 if (!ret) ret = -EAGAIN;
1245 break;
1246 }
1247 continue;
1248 }
1249 swptr = dmabuf->swptr;
1250 cnt = dmabuf->dmasize - swptr;
1251 if (dmabuf->count < cnt)
1252 cnt = dmabuf->count;
1253 spin_unlock_irqrestore(&unit->reg_lock, flags);
1254
1255 if (cnt > count)
1256 cnt = count;
1257 if (cnt <= 0) {
1258 unsigned long tmo;
1259 /* buffer is empty, start the dma machine and wait for data to be
1260 recorded */
1261 spin_lock_irqsave(&state->unit->reg_lock, flags);
1262 if (!state->rpcm.running) {
1263 ymf_capture_trigger(state->unit, &state->rpcm, 1);
1264 }
1265 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1266 if (file->f_flags & O_NONBLOCK) {
1267 if (!ret) ret = -EAGAIN;
1268 break;
1269 }
1270 /* This isnt strictly right for the 810 but it'll do */
1271 tmo = (dmabuf->dmasize * HZ) / (state->format.rate * 2);
1272 tmo >>= state->format.shift;
1273 /* There are two situations when sleep_on_timeout returns, one is when
1274 the interrupt is serviced correctly and the process is waked up by
1275 ISR ON TIME. Another is when timeout is expired, which means that
1276 either interrupt is NOT serviced correctly (pending interrupt) or it
1277 is TOO LATE for the process to be scheduled to run (scheduler latency)
1278 which results in a (potential) buffer overrun. And worse, there is
1279 NOTHING we can do to prevent it. */
1280 tmo = schedule_timeout(tmo);
1281 spin_lock_irqsave(&state->unit->reg_lock, flags);
1282 set_current_state(TASK_INTERRUPTIBLE);
1283 if (tmo == 0 && dmabuf->count == 0) {
1284 printk(KERN_ERR "ymfpci%d: recording schedule timeout, "
1285 "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1286 state->unit->dev_audio,
1287 dmabuf->dmasize, dmabuf->fragsize, dmabuf->count,
1288 dmabuf->hwptr, dmabuf->swptr);
1289 }
1290 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1291 if (signal_pending(current)) {
1292 if (!ret) ret = -ERESTARTSYS;
1293 break;
1294 }
1295 continue;
1296 }
1297
1298 if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
1299 if (!ret) ret = -EFAULT;
1300 break;
1301 }
1302
1303 swptr = (swptr + cnt) % dmabuf->dmasize;
1304
1305 spin_lock_irqsave(&unit->reg_lock, flags);
1306 if (unit->suspended) {
1307 spin_unlock_irqrestore(&unit->reg_lock, flags);
1308 continue;
1309 }
1310
1311 dmabuf->swptr = swptr;
1312 dmabuf->count -= cnt;
1313 // spin_unlock_irqrestore(&unit->reg_lock, flags);
1314
1315 count -= cnt;
1316 buffer += cnt;
1317 ret += cnt;
1318 // spin_lock_irqsave(&unit->reg_lock, flags);
1319 if (!state->rpcm.running) {
1320 ymf_capture_trigger(unit, &state->rpcm, 1);
1321 }
1322 spin_unlock_irqrestore(&unit->reg_lock, flags);
1323 }
1324 set_current_state(TASK_RUNNING);
1325 remove_wait_queue(&dmabuf->wait, &waita);
1326
1327 return ret;
1328 }
1329
1330 static ssize_t
1331 ymf_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
1332 {
1333 struct ymf_state *state = (struct ymf_state *)file->private_data;
1334 struct ymf_dmabuf *dmabuf = &state->wpcm.dmabuf;
1335 struct ymf_unit *unit = state->unit;
1336 DECLARE_WAITQUEUE(waita, current);
1337 ssize_t ret;
1338 unsigned long flags;
1339 unsigned int swptr;
1340 int cnt; /* This many to go in this revolution */
1341 int redzone;
1342 int delay;
1343
1344 YMFDBGW("ymf_write: count %d\n", count);
1345
1346 if (dmabuf->mapped)
1347 return -ENXIO;
1348 if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
1349 return ret;
1350 ret = 0;
1351
1352 /*
1353 * Alan's cs46xx works without a red zone - marvel of ingenuity.
1354 * We are not so brilliant... Red zone does two things:
1355 * 1. allows for safe start after a pause as we have no way
1356 * to know what the actual, relentlessly advancing, hwptr is.
1357 * 2. makes computations in ymf_pcm_interrupt simpler.
1358 */
1359 redzone = ymf_calc_lend(state->format.rate) << state->format.shift;
1360 redzone *= 3; /* 2 redzone + 1 possible uncertainty reserve. */
1361
1362 add_wait_queue(&dmabuf->wait, &waita);
1363 set_current_state(TASK_INTERRUPTIBLE);
1364 while (count > 0) {
1365 spin_lock_irqsave(&unit->reg_lock, flags);
1366 if (unit->suspended) {
1367 spin_unlock_irqrestore(&unit->reg_lock, flags);
1368 schedule();
1369 set_current_state(TASK_INTERRUPTIBLE);
1370 if (signal_pending(current)) {
1371 if (!ret) ret = -EAGAIN;
1372 break;
1373 }
1374 continue;
1375 }
1376 if (dmabuf->count < 0) {
1377 printk(KERN_ERR
1378 "ymf_write: count %d, was legal in cs46xx\n",
1379 dmabuf->count);
1380 dmabuf->count = 0;
1381 }
1382 if (dmabuf->count == 0) {
1383 swptr = dmabuf->hwptr;
1384 if (state->wpcm.running) {
1385 /*
1386 * Add uncertainty reserve.
1387 */
1388 cnt = ymf_calc_lend(state->format.rate);
1389 cnt <<= state->format.shift;
1390 if ((swptr += cnt) >= dmabuf->dmasize) {
1391 swptr -= dmabuf->dmasize;
1392 }
1393 }
1394 dmabuf->swptr = swptr;
1395 } else {
1396 /*
1397 * XXX This is not right if dmabuf->count is small -
1398 * about 2*x frame size or less. We cannot count on
1399 * on appending and not causing an artefact.
1400 * Should use a variation of the count==0 case above.
1401 */
1402 swptr = dmabuf->swptr;
1403 }
1404 cnt = dmabuf->dmasize - swptr;
1405 if (dmabuf->count + cnt > dmabuf->dmasize - redzone)
1406 cnt = (dmabuf->dmasize - redzone) - dmabuf->count;
1407 spin_unlock_irqrestore(&unit->reg_lock, flags);
1408
1409 if (cnt > count)
1410 cnt = count;
1411 if (cnt <= 0) {
1412 YMFDBGW("ymf_write: full, count %d swptr %d\n",
1413 dmabuf->count, dmabuf->swptr);
1414 /*
1415 * buffer is full, start the dma machine and
1416 * wait for data to be played
1417 */
1418 spin_lock_irqsave(&unit->reg_lock, flags);
1419 if (!state->wpcm.running) {
1420 ymf_playback_trigger(unit, &state->wpcm, 1);
1421 }
1422 spin_unlock_irqrestore(&unit->reg_lock, flags);
1423 if (file->f_flags & O_NONBLOCK) {
1424 if (!ret) ret = -EAGAIN;
1425 break;
1426 }
1427 schedule();
1428 set_current_state(TASK_INTERRUPTIBLE);
1429 if (signal_pending(current)) {
1430 if (!ret) ret = -ERESTARTSYS;
1431 break;
1432 }
1433 continue;
1434 }
1435 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
1436 if (!ret) ret = -EFAULT;
1437 break;
1438 }
1439
1440 if ((swptr += cnt) >= dmabuf->dmasize) {
1441 swptr -= dmabuf->dmasize;
1442 }
1443
1444 spin_lock_irqsave(&unit->reg_lock, flags);
1445 if (unit->suspended) {
1446 spin_unlock_irqrestore(&unit->reg_lock, flags);
1447 continue;
1448 }
1449 dmabuf->swptr = swptr;
1450 dmabuf->count += cnt;
1451
1452 /*
1453 * Start here is a bad idea - may cause startup click
1454 * in /bin/play when dmabuf is not full yet.
1455 * However, some broken applications do not make
1456 * any use of SNDCTL_DSP_SYNC (Doom is the worst).
1457 * One frame is about 5.3ms, Doom write size is 46ms.
1458 */
1459 delay = state->format.rate / 20; /* 50ms */
1460 delay <<= state->format.shift;
1461 if (dmabuf->count >= delay && !state->wpcm.running) {
1462 ymf_playback_trigger(unit, &state->wpcm, 1);
1463 }
1464
1465 spin_unlock_irqrestore(&unit->reg_lock, flags);
1466
1467 count -= cnt;
1468 buffer += cnt;
1469 ret += cnt;
1470 }
1471
1472 set_current_state(TASK_RUNNING);
1473 remove_wait_queue(&dmabuf->wait, &waita);
1474
1475 YMFDBGW("ymf_write: ret %d dmabuf.count %d\n", ret, dmabuf->count);
1476 return ret;
1477 }
1478
1479 static unsigned int ymf_poll(struct file *file, struct poll_table_struct *wait)
1480 {
1481 struct ymf_state *state = (struct ymf_state *)file->private_data;
1482 struct ymf_dmabuf *dmabuf;
1483 int redzone;
1484 unsigned long flags;
1485 unsigned int mask = 0;
1486
1487 if (file->f_mode & FMODE_WRITE)
1488 poll_wait(file, &state->wpcm.dmabuf.wait, wait);
1489 if (file->f_mode & FMODE_READ)
1490 poll_wait(file, &state->rpcm.dmabuf.wait, wait);
1491
1492 spin_lock_irqsave(&state->unit->reg_lock, flags);
1493 if (file->f_mode & FMODE_READ) {
1494 dmabuf = &state->rpcm.dmabuf;
1495 if (dmabuf->count >= (signed)dmabuf->fragsize)
1496 mask |= POLLIN | POLLRDNORM;
1497 }
1498 if (file->f_mode & FMODE_WRITE) {
1499 redzone = ymf_calc_lend(state->format.rate);
1500 redzone <<= state->format.shift;
1501 redzone *= 3;
1502
1503 dmabuf = &state->wpcm.dmabuf;
1504 if (dmabuf->mapped) {
1505 if (dmabuf->count >= (signed)dmabuf->fragsize)
1506 mask |= POLLOUT | POLLWRNORM;
1507 } else {
1508 /*
1509 * Don't select unless a full fragment is available.
1510 * Otherwise artsd does GETOSPACE, sees 0, and loops.
1511 */
1512 if (dmabuf->count + redzone + dmabuf->fragsize
1513 <= dmabuf->dmasize)
1514 mask |= POLLOUT | POLLWRNORM;
1515 }
1516 }
1517 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1518
1519 return mask;
1520 }
1521
1522 static int ymf_mmap(struct file *file, struct vm_area_struct *vma)
1523 {
1524 struct ymf_state *state = (struct ymf_state *)file->private_data;
1525 struct ymf_dmabuf *dmabuf = &state->wpcm.dmabuf;
1526 int ret;
1527 unsigned long size;
1528
1529 if (vma->vm_flags & VM_WRITE) {
1530 if ((ret = prog_dmabuf(state, 0)) != 0)
1531 return ret;
1532 } else if (vma->vm_flags & VM_READ) {
1533 if ((ret = prog_dmabuf(state, 1)) != 0)
1534 return ret;
1535 } else
1536 return -EINVAL;
1537
1538 if (vma->vm_pgoff != 0)
1539 return -EINVAL;
1540 size = vma->vm_end - vma->vm_start;
1541 if (size > (PAGE_SIZE << dmabuf->buforder))
1542 return -EINVAL;
1543 if (remap_pfn_range(vma, vma->vm_start,
1544 virt_to_phys(dmabuf->rawbuf) >> PAGE_SHIFT,
1545 size, vma->vm_page_prot))
1546 return -EAGAIN;
1547 dmabuf->mapped = 1;
1548
1549 /* P3 */ printk(KERN_INFO "ymfpci: using memory mapped sound, untested!\n");
1550 return 0;
1551 }
1552
1553 static int ymf_ioctl(struct inode *inode, struct file *file,
1554 unsigned int cmd, unsigned long arg)
1555 {
1556 struct ymf_state *state = (struct ymf_state *)file->private_data;
1557 struct ymf_dmabuf *dmabuf;
1558 unsigned long flags;
1559 audio_buf_info abinfo;
1560 count_info cinfo;
1561 int redzone;
1562 int val;
1563 void __user *argp = (void __user *)arg;
1564 int __user *p = argp;
1565
1566 switch (cmd) {
1567 case OSS_GETVERSION:
1568 YMFDBGX("ymf_ioctl: cmd 0x%x(GETVER) arg 0x%lx\n", cmd, arg);
1569 return put_user(SOUND_VERSION, p);
1570
1571 case SNDCTL_DSP_RESET:
1572 YMFDBGX("ymf_ioctl: cmd 0x%x(RESET)\n", cmd);
1573 if (file->f_mode & FMODE_WRITE) {
1574 ymf_wait_dac(state);
1575 dmabuf = &state->wpcm.dmabuf;
1576 spin_lock_irqsave(&state->unit->reg_lock, flags);
1577 dmabuf->ready = 0;
1578 dmabuf->swptr = dmabuf->hwptr;
1579 dmabuf->count = dmabuf->total_bytes = 0;
1580 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1581 }
1582 if (file->f_mode & FMODE_READ) {
1583 ymf_stop_adc(state);
1584 dmabuf = &state->rpcm.dmabuf;
1585 spin_lock_irqsave(&state->unit->reg_lock, flags);
1586 dmabuf->ready = 0;
1587 dmabuf->swptr = dmabuf->hwptr;
1588 dmabuf->count = dmabuf->total_bytes = 0;
1589 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1590 }
1591 return 0;
1592
1593 case SNDCTL_DSP_SYNC:
1594 YMFDBGX("ymf_ioctl: cmd 0x%x(SYNC)\n", cmd);
1595 if (file->f_mode & FMODE_WRITE) {
1596 dmabuf = &state->wpcm.dmabuf;
1597 if (file->f_flags & O_NONBLOCK) {
1598 spin_lock_irqsave(&state->unit->reg_lock, flags);
1599 if (dmabuf->count != 0 && !state->wpcm.running) {
1600 ymf_start_dac(state);
1601 }
1602 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1603 } else {
1604 ymf_wait_dac(state);
1605 }
1606 }
1607 /* XXX What does this do for reading? dmabuf->count=0; ? */
1608 return 0;
1609
1610 case SNDCTL_DSP_SPEED: /* set smaple rate */
1611 if (get_user(val, p))
1612 return -EFAULT;
1613 YMFDBGX("ymf_ioctl: cmd 0x%x(SPEED) sp %d\n", cmd, val);
1614 if (val >= 8000 && val <= 48000) {
1615 if (file->f_mode & FMODE_WRITE) {
1616 ymf_wait_dac(state);
1617 dmabuf = &state->wpcm.dmabuf;
1618 spin_lock_irqsave(&state->unit->reg_lock, flags);
1619 dmabuf->ready = 0;
1620 state->format.rate = val;
1621 ymf_pcm_update_shift(&state->format);
1622 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1623 }
1624 if (file->f_mode & FMODE_READ) {
1625 ymf_stop_adc(state);
1626 dmabuf = &state->rpcm.dmabuf;
1627 spin_lock_irqsave(&state->unit->reg_lock, flags);
1628 dmabuf->ready = 0;
1629 state->format.rate = val;
1630 ymf_pcm_update_shift(&state->format);
1631 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1632 }
1633 }
1634 return put_user(state->format.rate, p);
1635
1636 /*
1637 * OSS manual does not mention SNDCTL_DSP_STEREO at all.
1638 * All channels are mono and if you want stereo, you
1639 * play into two channels with SNDCTL_DSP_CHANNELS.
1640 * However, mpg123 calls it. I wonder, why Michael Hipp used it.
1641 */
1642 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
1643 if (get_user(val, p))
1644 return -EFAULT;
1645 YMFDBGX("ymf_ioctl: cmd 0x%x(STEREO) st %d\n", cmd, val);
1646 if (file->f_mode & FMODE_WRITE) {
1647 ymf_wait_dac(state);
1648 dmabuf = &state->wpcm.dmabuf;
1649 spin_lock_irqsave(&state->unit->reg_lock, flags);
1650 dmabuf->ready = 0;
1651 state->format.voices = val ? 2 : 1;
1652 ymf_pcm_update_shift(&state->format);
1653 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1654 }
1655 if (file->f_mode & FMODE_READ) {
1656 ymf_stop_adc(state);
1657 dmabuf = &state->rpcm.dmabuf;
1658 spin_lock_irqsave(&state->unit->reg_lock, flags);
1659 dmabuf->ready = 0;
1660 state->format.voices = val ? 2 : 1;
1661 ymf_pcm_update_shift(&state->format);
1662 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1663 }
1664 return 0;
1665
1666 case SNDCTL_DSP_GETBLKSIZE:
1667 YMFDBGX("ymf_ioctl: cmd 0x%x(GETBLK)\n", cmd);
1668 if (file->f_mode & FMODE_WRITE) {
1669 if ((val = prog_dmabuf(state, 0)))
1670 return val;
1671 val = state->wpcm.dmabuf.fragsize;
1672 YMFDBGX("ymf_ioctl: GETBLK w %d\n", val);
1673 return put_user(val, p);
1674 }
1675 if (file->f_mode & FMODE_READ) {
1676 if ((val = prog_dmabuf(state, 1)))
1677 return val;
1678 val = state->rpcm.dmabuf.fragsize;
1679 YMFDBGX("ymf_ioctl: GETBLK r %d\n", val);
1680 return put_user(val, p);
1681 }
1682 return -EINVAL;
1683
1684 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
1685 YMFDBGX("ymf_ioctl: cmd 0x%x(GETFMTS)\n", cmd);
1686 return put_user(AFMT_S16_LE|AFMT_U8, p);
1687
1688 case SNDCTL_DSP_SETFMT: /* Select sample format */
1689 if (get_user(val, p))
1690 return -EFAULT;
1691 YMFDBGX("ymf_ioctl: cmd 0x%x(SETFMT) fmt %d\n", cmd, val);
1692 if (val == AFMT_S16_LE || val == AFMT_U8) {
1693 if (file->f_mode & FMODE_WRITE) {
1694 ymf_wait_dac(state);
1695 dmabuf = &state->wpcm.dmabuf;
1696 spin_lock_irqsave(&state->unit->reg_lock, flags);
1697 dmabuf->ready = 0;
1698 state->format.format = val;
1699 ymf_pcm_update_shift(&state->format);
1700 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1701 }
1702 if (file->f_mode & FMODE_READ) {
1703 ymf_stop_adc(state);
1704 dmabuf = &state->rpcm.dmabuf;
1705 spin_lock_irqsave(&state->unit->reg_lock, flags);
1706 dmabuf->ready = 0;
1707 state->format.format = val;
1708 ymf_pcm_update_shift(&state->format);
1709 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1710 }
1711 }
1712 return put_user(state->format.format, p);
1713
1714 case SNDCTL_DSP_CHANNELS:
1715 if (get_user(val, p))
1716 return -EFAULT;
1717 YMFDBGX("ymf_ioctl: cmd 0x%x(CHAN) ch %d\n", cmd, val);
1718 if (val != 0) {
1719 if (file->f_mode & FMODE_WRITE) {
1720 ymf_wait_dac(state);
1721 if (val == 1 || val == 2) {
1722 spin_lock_irqsave(&state->unit->reg_lock, flags);
1723 dmabuf = &state->wpcm.dmabuf;
1724 dmabuf->ready = 0;
1725 state->format.voices = val;
1726 ymf_pcm_update_shift(&state->format);
1727 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1728 }
1729 }
1730 if (file->f_mode & FMODE_READ) {
1731 ymf_stop_adc(state);
1732 if (val == 1 || val == 2) {
1733 spin_lock_irqsave(&state->unit->reg_lock, flags);
1734 dmabuf = &state->rpcm.dmabuf;
1735 dmabuf->ready = 0;
1736 state->format.voices = val;
1737 ymf_pcm_update_shift(&state->format);
1738 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1739 }
1740 }
1741 }
1742 return put_user(state->format.voices, p);
1743
1744 case SNDCTL_DSP_POST:
1745 YMFDBGX("ymf_ioctl: cmd 0x%x(POST)\n", cmd);
1746 /*
1747 * Quoting OSS PG:
1748 * The ioctl SNDCTL_DSP_POST is a lightweight version of
1749 * SNDCTL_DSP_SYNC. It just tells to the driver that there
1750 * is likely to be a pause in the output. This makes it
1751 * possible for the device to handle the pause more
1752 * intelligently. This ioctl doesn't block the application.
1753 *
1754 * The paragraph above is a clumsy way to say "flush ioctl".
1755 * This ioctl is used by mpg123.
1756 */
1757 spin_lock_irqsave(&state->unit->reg_lock, flags);
1758 if (state->wpcm.dmabuf.count != 0 && !state->wpcm.running) {
1759 ymf_start_dac(state);
1760 }
1761 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1762 return 0;
1763
1764 case SNDCTL_DSP_SETFRAGMENT:
1765 if (get_user(val, p))
1766 return -EFAULT;
1767 YMFDBGX("ymf_ioctl: cmd 0x%x(SETFRAG) fr 0x%04x:%04x(%d:%d)\n",
1768 cmd,
1769 (val >> 16) & 0xFFFF, val & 0xFFFF,
1770 (val >> 16) & 0xFFFF, val & 0xFFFF);
1771 dmabuf = &state->wpcm.dmabuf;
1772 dmabuf->ossfragshift = val & 0xffff;
1773 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
1774 if (dmabuf->ossfragshift < 4)
1775 dmabuf->ossfragshift = 4;
1776 if (dmabuf->ossfragshift > 15)
1777 dmabuf->ossfragshift = 15;
1778 return 0;
1779
1780 case SNDCTL_DSP_GETOSPACE:
1781 YMFDBGX("ymf_ioctl: cmd 0x%x(GETOSPACE)\n", cmd);
1782 if (!(file->f_mode & FMODE_WRITE))
1783 return -EINVAL;
1784 dmabuf = &state->wpcm.dmabuf;
1785 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
1786 return val;
1787 redzone = ymf_calc_lend(state->format.rate);
1788 redzone <<= state->format.shift;
1789 redzone *= 3;
1790 spin_lock_irqsave(&state->unit->reg_lock, flags);
1791 abinfo.fragsize = dmabuf->fragsize;
1792 abinfo.bytes = dmabuf->dmasize - dmabuf->count - redzone;
1793 abinfo.fragstotal = dmabuf->numfrag;
1794 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
1795 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1796 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
1797
1798 case SNDCTL_DSP_GETISPACE:
1799 YMFDBGX("ymf_ioctl: cmd 0x%x(GETISPACE)\n", cmd);
1800 if (!(file->f_mode & FMODE_READ))
1801 return -EINVAL;
1802 dmabuf = &state->rpcm.dmabuf;
1803 if (!dmabuf->ready && (val = prog_dmabuf(state, 1)) != 0)
1804 return val;
1805 spin_lock_irqsave(&state->unit->reg_lock, flags);
1806 abinfo.fragsize = dmabuf->fragsize;
1807 abinfo.bytes = dmabuf->count;
1808 abinfo.fragstotal = dmabuf->numfrag;
1809 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
1810 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1811 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
1812
1813 case SNDCTL_DSP_NONBLOCK:
1814 YMFDBGX("ymf_ioctl: cmd 0x%x(NONBLOCK)\n", cmd);
1815 file->f_flags |= O_NONBLOCK;
1816 return 0;
1817
1818 case SNDCTL_DSP_GETCAPS:
1819 YMFDBGX("ymf_ioctl: cmd 0x%x(GETCAPS)\n", cmd);
1820 /* return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
1821 p); */
1822 return put_user(0, p);
1823
1824 case SNDCTL_DSP_GETIPTR:
1825 YMFDBGX("ymf_ioctl: cmd 0x%x(GETIPTR)\n", cmd);
1826 if (!(file->f_mode & FMODE_READ))
1827 return -EINVAL;
1828 dmabuf = &state->rpcm.dmabuf;
1829 spin_lock_irqsave(&state->unit->reg_lock, flags);
1830 cinfo.bytes = dmabuf->total_bytes;
1831 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
1832 cinfo.ptr = dmabuf->hwptr;
1833 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1834 YMFDBGX("ymf_ioctl: GETIPTR ptr %d bytes %d\n",
1835 cinfo.ptr, cinfo.bytes);
1836 return copy_to_user(argp, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
1837
1838 case SNDCTL_DSP_GETOPTR:
1839 YMFDBGX("ymf_ioctl: cmd 0x%x(GETOPTR)\n", cmd);
1840 if (!(file->f_mode & FMODE_WRITE))
1841 return -EINVAL;
1842 dmabuf = &state->wpcm.dmabuf;
1843 spin_lock_irqsave(&state->unit->reg_lock, flags);
1844 cinfo.bytes = dmabuf->total_bytes;
1845 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
1846 cinfo.ptr = dmabuf->hwptr;
1847 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1848 YMFDBGX("ymf_ioctl: GETOPTR ptr %d bytes %d\n",
1849 cinfo.ptr, cinfo.bytes);
1850 return copy_to_user(argp, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
1851
1852 case SNDCTL_DSP_SETDUPLEX:
1853 YMFDBGX("ymf_ioctl: cmd 0x%x(SETDUPLEX)\n", cmd);
1854 return 0; /* Always duplex */
1855
1856 case SOUND_PCM_READ_RATE:
1857 YMFDBGX("ymf_ioctl: cmd 0x%x(READ_RATE)\n", cmd);
1858 return put_user(state->format.rate, p);
1859
1860 case SOUND_PCM_READ_CHANNELS:
1861 YMFDBGX("ymf_ioctl: cmd 0x%x(READ_CH)\n", cmd);
1862 return put_user(state->format.voices, p);
1863
1864 case SOUND_PCM_READ_BITS:
1865 YMFDBGX("ymf_ioctl: cmd 0x%x(READ_BITS)\n", cmd);
1866 return put_user(AFMT_S16_LE, p);
1867
1868 case SNDCTL_DSP_MAPINBUF:
1869 case SNDCTL_DSP_MAPOUTBUF:
1870 case SNDCTL_DSP_SETSYNCRO:
1871 case SOUND_PCM_WRITE_FILTER:
1872 case SOUND_PCM_READ_FILTER:
1873 YMFDBGX("ymf_ioctl: cmd 0x%x unsupported\n", cmd);
1874 return -ENOTTY;
1875
1876 default:
1877 /*
1878 * Some programs mix up audio devices and ioctls
1879 * or perhaps they expect "universal" ioctls,
1880 * for instance we get SNDCTL_TMR_CONTINUE here.
1881 * (mpg123 -g 100 ends here too - to be fixed.)
1882 */
1883 YMFDBGX("ymf_ioctl: cmd 0x%x unknown\n", cmd);
1884 break;
1885 }
1886 return -ENOTTY;
1887 }
1888
1889 /*
1890 * open(2)
1891 * We use upper part of the minor to distinguish between soundcards.
1892 * Channels are opened with a clone open.
1893 */
1894 static int ymf_open(struct inode *inode, struct file *file)
1895 {
1896 struct list_head *list;
1897 ymfpci_t *unit = NULL;
1898 int minor;
1899 struct ymf_state *state;
1900 int err;
1901
1902 minor = iminor(inode);
1903 if ((minor & 0x0F) == 3) { /* /dev/dspN */
1904 ;
1905 } else {
1906 return -ENXIO;
1907 }
1908
1909 unit = NULL; /* gcc warns */
1910 spin_lock(&ymf_devs_lock);
1911 list_for_each(list, &ymf_devs) {
1912 unit = list_entry(list, ymfpci_t, ymf_devs);
1913 if (((unit->dev_audio ^ minor) & ~0x0F) == 0)
1914 break;
1915 }
1916 spin_unlock(&ymf_devs_lock);
1917 if (unit == NULL)
1918 return -ENODEV;
1919
1920 down(&unit->open_sem);
1921
1922 if ((state = ymf_state_alloc(unit)) == NULL) {
1923 up(&unit->open_sem);
1924 return -ENOMEM;
1925 }
1926 list_add_tail(&state->chain, &unit->states);
1927
1928 file->private_data = state;
1929
1930 /*
1931 * ymf_read and ymf_write that we borrowed from cs46xx
1932 * allocate buffers with prog_dmabuf(). We call prog_dmabuf
1933 * here so that in case of DMA memory exhaustion open
1934 * fails rather than write.
1935 *
1936 * XXX prog_dmabuf allocates voice. Should allocate explicitly, above.
1937 */
1938 if (file->f_mode & FMODE_WRITE) {
1939 if (!state->wpcm.dmabuf.ready) {
1940 if ((err = prog_dmabuf(state, 0)) != 0) {
1941 goto out_nodma;
1942 }
1943 }
1944 }
1945 if (file->f_mode & FMODE_READ) {
1946 if (!state->rpcm.dmabuf.ready) {
1947 if ((err = prog_dmabuf(state, 1)) != 0) {
1948 goto out_nodma;
1949 }
1950 }
1951 }
1952
1953 #if 0 /* test if interrupts work */
1954 ymfpci_writew(unit, YDSXGR_TIMERCOUNT, 0xfffe); /* ~ 680ms */
1955 ymfpci_writeb(unit, YDSXGR_TIMERCTRL,
1956 (YDSXGR_TIMERCTRL_TEN|YDSXGR_TIMERCTRL_TIEN));
1957 #endif
1958 up(&unit->open_sem);
1959
1960 return nonseekable_open(inode, file);
1961
1962 out_nodma:
1963 /*
1964 * XXX Broken custom: "goto out_xxx" in other place is
1965 * a nestable exception, but here it is not nestable due to semaphore.
1966 * XXX Doubtful technique of self-describing objects....
1967 */
1968 dealloc_dmabuf(unit, &state->wpcm.dmabuf);
1969 dealloc_dmabuf(unit, &state->rpcm.dmabuf);
1970 ymf_pcm_free_substream(&state->wpcm);
1971 ymf_pcm_free_substream(&state->rpcm);
1972
1973 list_del(&state->chain);
1974 kfree(state);
1975
1976 up(&unit->open_sem);
1977 return err;
1978 }
1979
1980 static int ymf_release(struct inode *inode, struct file *file)
1981 {
1982 struct ymf_state *state = (struct ymf_state *)file->private_data;
1983 ymfpci_t *unit = state->unit;
1984
1985 #if 0 /* test if interrupts work */
1986 ymfpci_writeb(unit, YDSXGR_TIMERCTRL, 0);
1987 #endif
1988
1989 down(&unit->open_sem);
1990
1991 /*
1992 * XXX Solve the case of O_NONBLOCK close - don't deallocate here.
1993 * Deallocate when unloading the driver and we can wait.
1994 */
1995 ymf_wait_dac(state);
1996 ymf_stop_adc(state); /* fortunately, it's immediate */
1997 dealloc_dmabuf(unit, &state->wpcm.dmabuf);
1998 dealloc_dmabuf(unit, &state->rpcm.dmabuf);
1999 ymf_pcm_free_substream(&state->wpcm);
2000 ymf_pcm_free_substream(&state->rpcm);
2001
2002 list_del(&state->chain);
2003 file->private_data = NULL; /* Can you tell I programmed Solaris */
2004 kfree(state);
2005
2006 up(&unit->open_sem);
2007
2008 return 0;
2009 }
2010
2011 /*
2012 * Mixer operations are based on cs46xx.
2013 */
2014 static int ymf_open_mixdev(struct inode *inode, struct file *file)
2015 {
2016 int minor = iminor(inode);
2017 struct list_head *list;
2018 ymfpci_t *unit;
2019 int i;
2020
2021 spin_lock(&ymf_devs_lock);
2022 list_for_each(list, &ymf_devs) {
2023 unit = list_entry(list, ymfpci_t, ymf_devs);
2024 for (i = 0; i < NR_AC97; i++) {
2025 if (unit->ac97_codec[i] != NULL &&
2026 unit->ac97_codec[i]->dev_mixer == minor) {
2027 spin_unlock(&ymf_devs_lock);
2028 goto match;
2029 }
2030 }
2031 }
2032 spin_unlock(&ymf_devs_lock);
2033 return -ENODEV;
2034
2035 match:
2036 file->private_data = unit->ac97_codec[i];
2037
2038 return nonseekable_open(inode, file);
2039 }
2040
2041 static int ymf_ioctl_mixdev(struct inode *inode, struct file *file,
2042 unsigned int cmd, unsigned long arg)
2043 {
2044 struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
2045
2046 return codec->mixer_ioctl(codec, cmd, arg);
2047 }
2048
2049 static int ymf_release_mixdev(struct inode *inode, struct file *file)
2050 {
2051 return 0;
2052 }
2053
2054 static /*const*/ struct file_operations ymf_fops = {
2055 .owner = THIS_MODULE,
2056 .llseek = no_llseek,
2057 .read = ymf_read,
2058 .write = ymf_write,
2059 .poll = ymf_poll,
2060 .ioctl = ymf_ioctl,
2061 .mmap = ymf_mmap,
2062 .open = ymf_open,
2063 .release = ymf_release,
2064 };
2065
2066 static /*const*/ struct file_operations ymf_mixer_fops = {
2067 .owner = THIS_MODULE,
2068 .llseek = no_llseek,
2069 .ioctl = ymf_ioctl_mixdev,
2070 .open = ymf_open_mixdev,
2071 .release = ymf_release_mixdev,
2072 };
2073
2074 /*
2075 */
2076
2077 static int ymf_suspend(struct pci_dev *pcidev, pm_message_t unused)
2078 {
2079 struct ymf_unit *unit = pci_get_drvdata(pcidev);
2080 unsigned long flags;
2081 struct ymf_dmabuf *dmabuf;
2082 struct list_head *p;
2083 struct ymf_state *state;
2084 struct ac97_codec *codec;
2085 int i;
2086
2087 spin_lock_irqsave(&unit->reg_lock, flags);
2088
2089 unit->suspended = 1;
2090
2091 for (i = 0; i < NR_AC97; i++) {
2092 if ((codec = unit->ac97_codec[i]) != NULL)
2093 ac97_save_state(codec);
2094 }
2095
2096 list_for_each(p, &unit->states) {
2097 state = list_entry(p, struct ymf_state, chain);
2098
2099 dmabuf = &state->wpcm.dmabuf;
2100 dmabuf->hwptr = dmabuf->swptr = 0;
2101 dmabuf->total_bytes = 0;
2102 dmabuf->count = 0;
2103
2104 dmabuf = &state->rpcm.dmabuf;
2105 dmabuf->hwptr = dmabuf->swptr = 0;
2106 dmabuf->total_bytes = 0;
2107 dmabuf->count = 0;
2108 }
2109
2110 ymfpci_writel(unit, YDSXGR_NATIVEDACOUTVOL, 0);
2111 ymfpci_disable_dsp(unit);
2112
2113 spin_unlock_irqrestore(&unit->reg_lock, flags);
2114
2115 return 0;
2116 }
2117
2118 static int ymf_resume(struct pci_dev *pcidev)
2119 {
2120 struct ymf_unit *unit = pci_get_drvdata(pcidev);
2121 unsigned long flags;
2122 struct list_head *p;
2123 struct ymf_state *state;
2124 struct ac97_codec *codec;
2125 int i;
2126
2127 ymfpci_aclink_reset(unit->pci);
2128 ymfpci_codec_ready(unit, 0, 1); /* prints diag if not ready. */
2129
2130 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2131 /* XXX At this time the legacy registers are probably deprogrammed. */
2132 #endif
2133
2134 ymfpci_download_image(unit);
2135
2136 ymf_memload(unit);
2137
2138 spin_lock_irqsave(&unit->reg_lock, flags);
2139
2140 if (unit->start_count) {
2141 ymfpci_writel(unit, YDSXGR_MODE, 3);
2142 unit->active_bank = ymfpci_readl(unit, YDSXGR_CTRLSELECT) & 1;
2143 }
2144
2145 for (i = 0; i < NR_AC97; i++) {
2146 if ((codec = unit->ac97_codec[i]) != NULL)
2147 ac97_restore_state(codec);
2148 }
2149
2150 unit->suspended = 0;
2151 list_for_each(p, &unit->states) {
2152 state = list_entry(p, struct ymf_state, chain);
2153 wake_up(&state->wpcm.dmabuf.wait);
2154 wake_up(&state->rpcm.dmabuf.wait);
2155 }
2156
2157 spin_unlock_irqrestore(&unit->reg_lock, flags);
2158 return 0;
2159 }
2160
2161 /*
2162 * initialization routines
2163 */
2164
2165 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2166
2167 static int ymfpci_setup_legacy(ymfpci_t *unit, struct pci_dev *pcidev)
2168 {
2169 int v;
2170 int mpuio = -1, oplio = -1;
2171
2172 switch (unit->iomidi) {
2173 case 0x330:
2174 mpuio = 0;
2175 break;
2176 case 0x300:
2177 mpuio = 1;
2178 break;
2179 case 0x332:
2180 mpuio = 2;
2181 break;
2182 case 0x334:
2183 mpuio = 3;
2184 break;
2185 default: ;
2186 }
2187
2188 switch (unit->iosynth) {
2189 case 0x388:
2190 oplio = 0;
2191 break;
2192 case 0x398:
2193 oplio = 1;
2194 break;
2195 case 0x3a0:
2196 oplio = 2;
2197 break;
2198 case 0x3a8:
2199 oplio = 3;
2200 break;
2201 default: ;
2202 }
2203
2204 if (mpuio >= 0 || oplio >= 0) {
2205 /* 0x0020: 1 - 10 bits of I/O address decoded, 0 - 16 bits. */
2206 v = 0x001e;
2207 pci_write_config_word(pcidev, PCIR_LEGCTRL, v);
2208
2209 switch (pcidev->device) {
2210 case PCI_DEVICE_ID_YAMAHA_724:
2211 case PCI_DEVICE_ID_YAMAHA_740:
2212 case PCI_DEVICE_ID_YAMAHA_724F:
2213 case PCI_DEVICE_ID_YAMAHA_740C:
2214 v = 0x8800;
2215 if (mpuio >= 0) { v |= mpuio<<4; }
2216 if (oplio >= 0) { v |= oplio; }
2217 pci_write_config_word(pcidev, PCIR_ELEGCTRL, v);
2218 break;
2219
2220 case PCI_DEVICE_ID_YAMAHA_744:
2221 case PCI_DEVICE_ID_YAMAHA_754:
2222 v = 0x8800;
2223 pci_write_config_word(pcidev, PCIR_ELEGCTRL, v);
2224 if (oplio >= 0) {
2225 pci_write_config_word(pcidev, PCIR_OPLADR, unit->iosynth);
2226 }
2227 if (mpuio >= 0) {
2228 pci_write_config_word(pcidev, PCIR_MPUADR, unit->iomidi);
2229 }
2230 break;
2231
2232 default:
2233 printk(KERN_ERR "ymfpci: Unknown device ID: 0x%x\n",
2234 pcidev->device);
2235 return -EINVAL;
2236 }
2237 }
2238
2239 return 0;
2240 }
2241 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2242
2243 static void ymfpci_aclink_reset(struct pci_dev * pci)
2244 {
2245 u8 cmd;
2246
2247 /*
2248 * In the 744, 754 only 0x01 exists, 0x02 is undefined.
2249 * It does not seem to hurt to trip both regardless of revision.
2250 */
2251 pci_read_config_byte(pci, PCIR_DSXGCTRL, &cmd);
2252 pci_write_config_byte(pci, PCIR_DSXGCTRL, cmd & 0xfc);
2253 pci_write_config_byte(pci, PCIR_DSXGCTRL, cmd | 0x03);
2254 pci_write_config_byte(pci, PCIR_DSXGCTRL, cmd & 0xfc);
2255
2256 pci_write_config_word(pci, PCIR_DSXPWRCTRL1, 0);
2257 pci_write_config_word(pci, PCIR_DSXPWRCTRL2, 0);
2258 }
2259
2260 static void ymfpci_enable_dsp(ymfpci_t *codec)
2261 {
2262 ymfpci_writel(codec, YDSXGR_CONFIG, 0x00000001);
2263 }
2264
2265 static void ymfpci_disable_dsp(ymfpci_t *codec)
2266 {
2267 u32 val;
2268 int timeout = 1000;
2269
2270 val = ymfpci_readl(codec, YDSXGR_CONFIG);
2271 if (val)
2272 ymfpci_writel(codec, YDSXGR_CONFIG, 0x00000000);
2273 while (timeout-- > 0) {
2274 val = ymfpci_readl(codec, YDSXGR_STATUS);
2275 if ((val & 0x00000002) == 0)
2276 break;
2277 }
2278 }
2279
2280 #include "ymfpci_image.h"
2281
2282 static void ymfpci_download_image(ymfpci_t *codec)
2283 {
2284 int i, ver_1e;
2285 u16 ctrl;
2286
2287 ymfpci_writel(codec, YDSXGR_NATIVEDACOUTVOL, 0x00000000);
2288 ymfpci_disable_dsp(codec);
2289 ymfpci_writel(codec, YDSXGR_MODE, 0x00010000);
2290 ymfpci_writel(codec, YDSXGR_MODE, 0x00000000);
2291 ymfpci_writel(codec, YDSXGR_MAPOFREC, 0x00000000);
2292 ymfpci_writel(codec, YDSXGR_MAPOFEFFECT, 0x00000000);
2293 ymfpci_writel(codec, YDSXGR_PLAYCTRLBASE, 0x00000000);
2294 ymfpci_writel(codec, YDSXGR_RECCTRLBASE, 0x00000000);
2295 ymfpci_writel(codec, YDSXGR_EFFCTRLBASE, 0x00000000);
2296 ctrl = ymfpci_readw(codec, YDSXGR_GLOBALCTRL);
2297 ymfpci_writew(codec, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
2298
2299 /* setup DSP instruction code */
2300 for (i = 0; i < YDSXG_DSPLENGTH / 4; i++)
2301 ymfpci_writel(codec, YDSXGR_DSPINSTRAM + (i << 2), DspInst[i]);
2302
2303 switch (codec->pci->device) {
2304 case PCI_DEVICE_ID_YAMAHA_724F:
2305 case PCI_DEVICE_ID_YAMAHA_740C:
2306 case PCI_DEVICE_ID_YAMAHA_744:
2307 case PCI_DEVICE_ID_YAMAHA_754:
2308 ver_1e = 1;
2309 break;
2310 default:
2311 ver_1e = 0;
2312 }
2313
2314 if (ver_1e) {
2315 /* setup control instruction code */
2316 for (i = 0; i < YDSXG_CTRLLENGTH / 4; i++)
2317 ymfpci_writel(codec, YDSXGR_CTRLINSTRAM + (i << 2), CntrlInst1E[i]);
2318 } else {
2319 for (i = 0; i < YDSXG_CTRLLENGTH / 4; i++)
2320 ymfpci_writel(codec, YDSXGR_CTRLINSTRAM + (i << 2), CntrlInst[i]);
2321 }
2322
2323 ymfpci_enable_dsp(codec);
2324
2325 /* 0.02s sounds not too bad, we may do schedule_timeout() later. */
2326 mdelay(20); /* seems we need some delay after downloading image.. */
2327 }
2328
2329 static int ymfpci_memalloc(ymfpci_t *codec)
2330 {
2331 unsigned int playback_ctrl_size;
2332 unsigned int bank_size_playback;
2333 unsigned int bank_size_capture;
2334 unsigned int bank_size_effect;
2335 unsigned int size;
2336 unsigned int off;
2337 char *ptr;
2338 dma_addr_t pba;
2339 int voice, bank;
2340
2341 playback_ctrl_size = 4 + 4 * YDSXG_PLAYBACK_VOICES;
2342 bank_size_playback = ymfpci_readl(codec, YDSXGR_PLAYCTRLSIZE) << 2;
2343 bank_size_capture = ymfpci_readl(codec, YDSXGR_RECCTRLSIZE) << 2;
2344 bank_size_effect = ymfpci_readl(codec, YDSXGR_EFFCTRLSIZE) << 2;
2345 codec->work_size = YDSXG_DEFAULT_WORK_SIZE;
2346
2347 size = ((playback_ctrl_size + 0x00ff) & ~0x00ff) +
2348 ((bank_size_playback * 2 * YDSXG_PLAYBACK_VOICES + 0xff) & ~0xff) +
2349 ((bank_size_capture * 2 * YDSXG_CAPTURE_VOICES + 0xff) & ~0xff) +
2350 ((bank_size_effect * 2 * YDSXG_EFFECT_VOICES + 0xff) & ~0xff) +
2351 codec->work_size;
2352
2353 ptr = pci_alloc_consistent(codec->pci, size + 0xff, &pba);
2354 if (ptr == NULL)
2355 return -ENOMEM;
2356 codec->dma_area_va = ptr;
2357 codec->dma_area_ba = pba;
2358 codec->dma_area_size = size + 0xff;
2359
2360 off = (unsigned long)ptr & 0xff;
2361 if (off) {
2362 ptr += 0x100 - off;
2363 pba += 0x100 - off;
2364 }
2365
2366 /*
2367 * Hardware requires only ptr[playback_ctrl_size] zeroed,
2368 * but in our judgement it is a wrong kind of savings, so clear it all.
2369 */
2370 memset(ptr, 0, size);
2371
2372 codec->ctrl_playback = (u32 *)ptr;
2373 codec->ctrl_playback_ba = pba;
2374 codec->ctrl_playback[0] = cpu_to_le32(YDSXG_PLAYBACK_VOICES);
2375 ptr += (playback_ctrl_size + 0x00ff) & ~0x00ff;
2376 pba += (playback_ctrl_size + 0x00ff) & ~0x00ff;
2377
2378 off = 0;
2379 for (voice = 0; voice < YDSXG_PLAYBACK_VOICES; voice++) {
2380 codec->voices[voice].number = voice;
2381 codec->voices[voice].bank =
2382 (ymfpci_playback_bank_t *) (ptr + off);
2383 codec->voices[voice].bank_ba = pba + off;
2384 off += 2 * bank_size_playback; /* 2 banks */
2385 }
2386 off = (off + 0xff) & ~0xff;
2387 ptr += off;
2388 pba += off;
2389
2390 off = 0;
2391 codec->bank_base_capture = pba;
2392 for (voice = 0; voice < YDSXG_CAPTURE_VOICES; voice++)
2393 for (bank = 0; bank < 2; bank++) {
2394 codec->bank_capture[voice][bank] =
2395 (ymfpci_capture_bank_t *) (ptr + off);
2396 off += bank_size_capture;
2397 }
2398 off = (off + 0xff) & ~0xff;
2399 ptr += off;
2400 pba += off;
2401
2402 off = 0;
2403 codec->bank_base_effect = pba;
2404 for (voice = 0; voice < YDSXG_EFFECT_VOICES; voice++)
2405 for (bank = 0; bank < 2; bank++) {
2406 codec->bank_effect[voice][bank] =
2407 (ymfpci_effect_bank_t *) (ptr + off);
2408 off += bank_size_effect;
2409 }
2410 off = (off + 0xff) & ~0xff;
2411 ptr += off;
2412 pba += off;
2413
2414 codec->work_base = pba;
2415
2416 return 0;
2417 }
2418
2419 static void ymfpci_memfree(ymfpci_t *codec)
2420 {
2421 ymfpci_writel(codec, YDSXGR_PLAYCTRLBASE, 0);
2422 ymfpci_writel(codec, YDSXGR_RECCTRLBASE, 0);
2423 ymfpci_writel(codec, YDSXGR_EFFCTRLBASE, 0);
2424 ymfpci_writel(codec, YDSXGR_WORKBASE, 0);
2425 ymfpci_writel(codec, YDSXGR_WORKSIZE, 0);
2426 pci_free_consistent(codec->pci,
2427 codec->dma_area_size, codec->dma_area_va, codec->dma_area_ba);
2428 }
2429
2430 static void ymf_memload(ymfpci_t *unit)
2431 {
2432
2433 ymfpci_writel(unit, YDSXGR_PLAYCTRLBASE, unit->ctrl_playback_ba);
2434 ymfpci_writel(unit, YDSXGR_RECCTRLBASE, unit->bank_base_capture);
2435 ymfpci_writel(unit, YDSXGR_EFFCTRLBASE, unit->bank_base_effect);
2436 ymfpci_writel(unit, YDSXGR_WORKBASE, unit->work_base);
2437 ymfpci_writel(unit, YDSXGR_WORKSIZE, unit->work_size >> 2);
2438
2439 /* S/PDIF output initialization */
2440 ymfpci_writew(unit, YDSXGR_SPDIFOUTCTRL, 0);
2441 ymfpci_writew(unit, YDSXGR_SPDIFOUTSTATUS,
2442 SND_PCM_AES0_CON_EMPHASIS_NONE |
2443 (SND_PCM_AES1_CON_ORIGINAL << 8) |
2444 (SND_PCM_AES1_CON_PCM_CODER << 8));
2445
2446 /* S/PDIF input initialization */
2447 ymfpci_writew(unit, YDSXGR_SPDIFINCTRL, 0);
2448
2449 /* move this volume setup to mixer */
2450 ymfpci_writel(unit, YDSXGR_NATIVEDACOUTVOL, 0x3fff3fff);
2451 ymfpci_writel(unit, YDSXGR_BUF441OUTVOL, 0);
2452 ymfpci_writel(unit, YDSXGR_NATIVEADCINVOL, 0x3fff3fff);
2453 ymfpci_writel(unit, YDSXGR_NATIVEDACINVOL, 0x3fff3fff);
2454 }
2455
2456 static int ymf_ac97_init(ymfpci_t *unit, int num_ac97)
2457 {
2458 struct ac97_codec *codec;
2459 u16 eid;
2460
2461 if ((codec = ac97_alloc_codec()) == NULL)
2462 return -ENOMEM;
2463
2464 /* initialize some basic codec information, other fields will be filled
2465 in ac97_probe_codec */
2466 codec->private_data = unit;
2467 codec->id = num_ac97;
2468
2469 codec->codec_read = ymfpci_codec_read;
2470 codec->codec_write = ymfpci_codec_write;
2471
2472 if (ac97_probe_codec(codec) == 0) {
2473 printk(KERN_ERR "ymfpci: ac97_probe_codec failed\n");
2474 goto out_kfree;
2475 }
2476
2477 eid = ymfpci_codec_read(codec, AC97_EXTENDED_ID);
2478 if (eid==0xFFFF) {
2479 printk(KERN_WARNING "ymfpci: no codec attached ?\n");
2480 goto out_kfree;
2481 }
2482
2483 unit->ac97_features = eid;
2484
2485 if ((codec->dev_mixer = register_sound_mixer(&ymf_mixer_fops, -1)) < 0) {
2486 printk(KERN_ERR "ymfpci: couldn't register mixer!\n");
2487 goto out_kfree;
2488 }
2489
2490 unit->ac97_codec[num_ac97] = codec;
2491
2492 return 0;
2493 out_kfree:
2494 ac97_release_codec(codec);
2495 return -ENODEV;
2496 }
2497
2498 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2499 # ifdef MODULE
2500 static int mpu_io;
2501 static int synth_io;
2502 module_param(mpu_io, int, 0);
2503 module_param(synth_io, int, 0);
2504 # else
2505 static int mpu_io = 0x330;
2506 static int synth_io = 0x388;
2507 # endif
2508 static int assigned;
2509 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2510
2511 static int __devinit ymf_probe_one(struct pci_dev *pcidev, const struct pci_device_id *ent)
2512 {
2513 u16 ctrl;
2514 unsigned long base;
2515 ymfpci_t *codec;
2516
2517 int err;
2518
2519 if ((err = pci_enable_device(pcidev)) != 0) {
2520 printk(KERN_ERR "ymfpci: pci_enable_device failed\n");
2521 return err;
2522 }
2523 base = pci_resource_start(pcidev, 0);
2524
2525 if ((codec = kmalloc(sizeof(ymfpci_t), GFP_KERNEL)) == NULL) {
2526 printk(KERN_ERR "ymfpci: no core\n");
2527 return -ENOMEM;
2528 }
2529 memset(codec, 0, sizeof(*codec));
2530
2531 spin_lock_init(&codec->reg_lock);
2532 spin_lock_init(&codec->voice_lock);
2533 spin_lock_init(&codec->ac97_lock);
2534 init_MUTEX(&codec->open_sem);
2535 INIT_LIST_HEAD(&codec->states);
2536 codec->pci = pcidev;
2537
2538 pci_read_config_byte(pcidev, PCI_REVISION_ID, &codec->rev);
2539
2540 if (request_mem_region(base, 0x8000, "ymfpci") == NULL) {
2541 printk(KERN_ERR "ymfpci: unable to request mem region\n");
2542 goto out_free;
2543 }
2544
2545 if ((codec->reg_area_virt = ioremap(base, 0x8000)) == NULL) {
2546 printk(KERN_ERR "ymfpci: unable to map registers\n");
2547 goto out_release_region;
2548 }
2549
2550 pci_set_master(pcidev);
2551
2552 printk(KERN_INFO "ymfpci: %s at 0x%lx IRQ %d\n",
2553 (char *)ent->driver_data, base, pcidev->irq);
2554
2555 ymfpci_aclink_reset(pcidev);
2556 if (ymfpci_codec_ready(codec, 0, 1) < 0)
2557 goto out_unmap;
2558
2559 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2560 if (assigned == 0) {
2561 codec->iomidi = mpu_io;
2562 codec->iosynth = synth_io;
2563 if (ymfpci_setup_legacy(codec, pcidev) < 0)
2564 goto out_unmap;
2565 assigned = 1;
2566 }
2567 #endif
2568
2569 ymfpci_download_image(codec);
2570
2571 if (ymfpci_memalloc(codec) < 0)
2572 goto out_disable_dsp;
2573 ymf_memload(codec);
2574
2575 if (request_irq(pcidev->irq, ymf_interrupt, SA_SHIRQ, "ymfpci", codec) != 0) {
2576 printk(KERN_ERR "ymfpci: unable to request IRQ %d\n",
2577 pcidev->irq);
2578 goto out_memfree;
2579 }
2580
2581 /* register /dev/dsp */
2582 if ((codec->dev_audio = register_sound_dsp(&ymf_fops, -1)) < 0) {
2583 printk(KERN_ERR "ymfpci: unable to register dsp\n");
2584 goto out_free_irq;
2585 }
2586
2587 /*
2588 * Poke just the primary for the moment.
2589 */
2590 if ((err = ymf_ac97_init(codec, 0)) != 0)
2591 goto out_unregister_sound_dsp;
2592
2593 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2594 codec->opl3_data.name = "ymfpci";
2595 codec->mpu_data.name = "ymfpci";
2596
2597 codec->opl3_data.io_base = codec->iosynth;
2598 codec->opl3_data.irq = -1;
2599
2600 codec->mpu_data.io_base = codec->iomidi;
2601 codec->mpu_data.irq = -1; /* May be different from our PCI IRQ. */
2602
2603 if (codec->iomidi) {
2604 if (!probe_uart401(&codec->mpu_data, THIS_MODULE)) {
2605 codec->iomidi = 0; /* XXX kludge */
2606 }
2607 }
2608 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2609
2610 /* put it into driver list */
2611 spin_lock(&ymf_devs_lock);
2612 list_add_tail(&codec->ymf_devs, &ymf_devs);
2613 spin_unlock(&ymf_devs_lock);
2614 pci_set_drvdata(pcidev, codec);
2615
2616 return 0;
2617
2618 out_unregister_sound_dsp:
2619 unregister_sound_dsp(codec->dev_audio);
2620 out_free_irq:
2621 free_irq(pcidev->irq, codec);
2622 out_memfree:
2623 ymfpci_memfree(codec);
2624 out_disable_dsp:
2625 ymfpci_disable_dsp(codec);
2626 ctrl = ymfpci_readw(codec, YDSXGR_GLOBALCTRL);
2627 ymfpci_writew(codec, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
2628 ymfpci_writel(codec, YDSXGR_STATUS, ~0);
2629 out_unmap:
2630 iounmap(codec->reg_area_virt);
2631 out_release_region:
2632 release_mem_region(pci_resource_start(pcidev, 0), 0x8000);
2633 out_free:
2634 if (codec->ac97_codec[0])
2635 ac97_release_codec(codec->ac97_codec[0]);
2636 return -ENODEV;
2637 }
2638
2639 static void __devexit ymf_remove_one(struct pci_dev *pcidev)
2640 {
2641 __u16 ctrl;
2642 ymfpci_t *codec = pci_get_drvdata(pcidev);
2643
2644 /* remove from list of devices */
2645 spin_lock(&ymf_devs_lock);
2646 list_del(&codec->ymf_devs);
2647 spin_unlock(&ymf_devs_lock);
2648
2649 unregister_sound_mixer(codec->ac97_codec[0]->dev_mixer);
2650 ac97_release_codec(codec->ac97_codec[0]);
2651 unregister_sound_dsp(codec->dev_audio);
2652 free_irq(pcidev->irq, codec);
2653 ymfpci_memfree(codec);
2654 ymfpci_writel(codec, YDSXGR_STATUS, ~0);
2655 ymfpci_disable_dsp(codec);
2656 ctrl = ymfpci_readw(codec, YDSXGR_GLOBALCTRL);
2657 ymfpci_writew(codec, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
2658 iounmap(codec->reg_area_virt);
2659 release_mem_region(pci_resource_start(pcidev, 0), 0x8000);
2660 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2661 if (codec->iomidi) {
2662 unload_uart401(&codec->mpu_data);
2663 }
2664 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2665 }
2666
2667 MODULE_AUTHOR("Jaroslav Kysela");
2668 MODULE_DESCRIPTION("Yamaha YMF7xx PCI Audio");
2669 MODULE_LICENSE("GPL");
2670
2671 static struct pci_driver ymfpci_driver = {
2672 .name = "ymfpci",
2673 .id_table = ymf_id_tbl,
2674 .probe = ymf_probe_one,
2675 .remove = __devexit_p(ymf_remove_one),
2676 .suspend = ymf_suspend,
2677 .resume = ymf_resume
2678 };
2679
2680 static int __init ymf_init_module(void)
2681 {
2682 return pci_module_init(&ymfpci_driver);
2683 }
2684
2685 static void __exit ymf_cleanup_module (void)
2686 {
2687 pci_unregister_driver(&ymfpci_driver);
2688 }
2689
2690 module_init(ymf_init_module);
2691 module_exit(ymf_cleanup_module);
Verdex Pro support