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