?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge with Linux 2.4.0-test4-pre3.
[linux-2.6/linux-mips.git] / drivers / sound / via82cxxx_audio.c
blobab14427d637533e9f79d8459f0f178de7b8698ba
1 /*
2 * Support for VIA 82Cxxx Audio Codecs
3 * Copyright 1999,2000 Jeff Garzik <jgarzik@mandrakesoft.com>
4 *
5 * Distributed under the GNU GENERAL PUBLIC LICENSE (GPL) Version 2.
6 * See the "COPYING" file distributed with this software for more info.
7 *
8 * For a list of known bugs (errata) and documentation,
9 * see via-audio.pdf in linux/Documentation/DocBook.
10 * If this documentation does not exist, run "make pdfdocs".
11 * If "make pdfdocs" fails, obtain the documentation from
12 * the driver's Website at
13 * http://gtf.org/garzik/drivers/via82cxxx/
14 *
15 */
16
17
18 #define VIA_VERSION "1.1.8"
19
20
21 #include <linux/config.h>
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/fs.h>
25 #include <linux/pci.h>
26 #include <linux/init.h>
27 #include <linux/proc_fs.h>
28 #include <linux/spinlock.h>
29 #include <linux/sound.h>
30 #include <linux/poll.h>
31 #include <linux/soundcard.h>
32 #include <linux/ac97_codec.h>
33 #include <asm/io.h>
34 #include <asm/delay.h>
35 #include <asm/uaccess.h>
36 #include <asm/hardirq.h>
37
38 /* much better to duplicate this value than include
39 * drivers/sound/sound_config.h just for this definition */
40 #define SND_DEV_DSP16 5
41
42
43 #undef VIA_DEBUG /* define to enable debugging output and checks */
44 #ifdef VIA_DEBUG
45 /* note: prints function name for you */
46 #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
47 #else
48 #define DPRINTK(fmt, args...)
49 #endif
50
51 #define VIA_NDEBUG /* define to disable lightweight runtime checks */
52 #ifdef VIA_NDEBUG
53 #define assert(expr)
54 #else
55 #define assert(expr) \
56 if(!(expr)) { \
57 printk( "Assertion failed! %s,%s,%s,line=%d\n", \
58 #expr,__FILE__,__FUNCTION__,__LINE__); \
59 }
60 #endif
61
62 /* user switch: undefine to exclude /proc data */
63 #define VIA_PROC_FS 1
64
65 /* don't mess with this */
66 #ifndef CONFIG_PROC_FS
67 #undef VIA_PROC_FS
68 #endif
69
70 #define arraysize(x) (sizeof(x)/sizeof(*(x)))
71
72 #define MAX_CARDS 1
73
74 #define LINE_SIZE 10
75
76 #define VIA_CARD_NAME "VIA 82Cxxx Audio driver " VIA_VERSION
77 #define VIA_MODULE_NAME "via82cxxx"
78 #define PFX VIA_MODULE_NAME ": "
79
80 #define VIA_COUNTER_LIMIT 100000
81
82 /* size of DMA buffers */
83 #define VIA_DMA_BUFFERS 16
84 #define VIA_DMA_BUF_SIZE PAGE_SIZE
85
86 /* 82C686 function 5 (audio codec) PCI configuration registers */
87 #define VIA_ACLINK_CTRL 0x41
88 #define VIA_FUNC_ENABLE 0x42
89 #define VIA_PNP_CONTROL 0x43
90 #define VIA_FM_NMI_CTRL 0x48
91
92 /*
93 * controller base 0 (scatter-gather) registers
94 *
95 * NOTE: Via datasheet lists first channel as "read"
96 * channel and second channel as "write" channel.
97 * I changed the naming of the constants to be more
98 * clear than I felt the datasheet to be.
99 */
100
101 #define VIA_BASE0_PCM_OUT_CHAN 0x00 /* output PCM to user */
102 #define VIA_BASE0_PCM_OUT_CHAN_STATUS 0x00
103 #define VIA_BASE0_PCM_OUT_CHAN_CTRL 0x01
104 #define VIA_BASE0_PCM_OUT_CHAN_TYPE 0x02
105 #define VIA_BASE0_PCM_OUT_BLOCK_COUNT 0x0C
106
107 #define VIA_BASE0_PCM_IN_CHAN 0x10 /* input PCM from user */
108 #define VIA_BASE0_PCM_IN_CHAN_STATUS 0x10
109 #define VIA_BASE0_PCM_IN_CHAN_CTRL 0x11
110 #define VIA_BASE0_PCM_IN_CHAN_TYPE 0x12
111
112 /* offsets from base */
113 #define VIA_PCM_STATUS 0x00
114 #define VIA_PCM_CONTROL 0x01
115 #define VIA_PCM_TYPE 0x02
116 #define VIA_PCM_TABLE_ADDR 0x04
117
118 /* XXX unused DMA channel for FM PCM data */
119 #define VIA_BASE0_FM_OUT_CHAN 0x20
120 #define VIA_BASE0_FM_OUT_CHAN_STATUS 0x20
121 #define VIA_BASE0_FM_OUT_CHAN_CTRL 0x21
122 #define VIA_BASE0_FM_OUT_CHAN_TYPE 0x22
123
124 #define VIA_BASE0_AC97_CTRL 0x80
125 #define VIA_BASE0_SGD_STATUS_SHADOW 0x84
126 #define VIA_BASE0_GPI_INT_ENABLE 0x8C
127
128 /* VIA_BASE0_AUDIO_xxx_CHAN_TYPE bits */
129 #define VIA_IRQ_ON_FLAG (1<<0) /* int on each flagged scatter block */
130 #define VIA_IRQ_ON_EOL (1<<1) /* int at end of scatter list */
131 #define VIA_INT_SEL_PCI_LAST_LINE_READ (0) /* int at PCI read of last line */
132 #define VIA_INT_SEL_LAST_SAMPLE_SENT (1<<2) /* int at last sample sent */
133 #define VIA_INT_SEL_ONE_LINE_LEFT (1<<3) /* int at less than one line to send */
134 #define VIA_PCM_FMT_STEREO (1<<4) /* PCM stereo format (bit clear == mono) */
135 #define VIA_PCM_FMT_16BIT (1<<5) /* PCM 16-bit format (bit clear == 8-bit) */
136 #define VIA_PCM_FIFO (1<<6) /* enable FIFO? documented as "reserved" */
137 #define VIA_RESTART_SGD_ON_EOL (1<<7) /* restart scatter-gather at EOL */
138 #define VIA_PCM_FMT_MASK (VIA_PCM_FMT_STEREO|VIA_PCM_FMT_16BIT)
139 #define VIA_CHAN_TYPE_MASK (VIA_RESTART_SGD_ON_EOL | \
140 VIA_PCM_FIFO | \
141 VIA_IRQ_ON_FLAG | \
142 VIA_IRQ_ON_EOL)
143 #define VIA_CHAN_TYPE_INT_SELECT (VIA_INT_SEL_LAST_SAMPLE_SENT)
144
145 /* PCI configuration register bits and masks */
146 #define VIA_CR40_AC97_READY 0x01
147 #define VIA_CR40_AC97_LOW_POWER 0x02
148 #define VIA_CR40_SECONDARY_READY 0x04
149
150 #define VIA_CR41_AC97_ENABLE 0x80 /* enable AC97 codec */
151 #define VIA_CR41_AC97_RESET 0x40 /* clear bit to reset AC97 */
152 #define VIA_CR41_AC97_WAKEUP 0x20 /* wake up from power-down mode */
153 #define VIA_CR41_AC97_SDO 0x10 /* force Serial Data Out (SDO) high */
154 #define VIA_CR41_VRA 0x08 /* enable variable sample rate */
155 #define VIA_CR41_PCM_ENABLE 0x04 /* AC Link SGD Read Channel PCM Data Output */
156 #define VIA_CR41_FM_PCM_ENABLE 0x02 /* AC Link FM Channel PCM Data Out */
157 #define VIA_CR41_SB_PCM_ENABLE 0x01 /* AC Link SB PCM Data Output */
158 #define VIA_CR41_BOOT_MASK (VIA_CR41_AC97_ENABLE | \
159 VIA_CR41_AC97_WAKEUP | \
160 VIA_CR41_AC97_SDO)
161 #define VIA_CR41_RUN_MASK (VIA_CR41_AC97_ENABLE | \
162 VIA_CR41_AC97_RESET | \
163 VIA_CR41_VRA | \
164 VIA_CR41_PCM_ENABLE)
165
166 #define VIA_CR42_SB_ENABLE 0x01
167 #define VIA_CR42_MIDI_ENABLE 0x02
168 #define VIA_CR42_FM_ENABLE 0x04
169 #define VIA_CR42_GAME_ENABLE 0x08
170
171 #define VIA_CR44_SECOND_CODEC_SUPPORT (1 << 6)
172 #define VIA_CR44_AC_LINK_ACCESS (1 << 7)
173
174 #define VIA_CR48_FM_TRAP_TO_NMI (1 << 2)
175
176 /* controller base 0 register bitmasks */
177 #define VIA_INT_DISABLE_MASK (~(0x01|0x02))
178 #define VIA_SGD_STOPPED (1 << 2)
179 #define VIA_SGD_ACTIVE (1 << 7)
180 #define VIA_SGD_TERMINATE (1 << 6)
181 #define VIA_SGD_FLAG (1 << 0)
182 #define VIA_SGD_EOL (1 << 1)
183 #define VIA_SGD_START (1 << 7)
184
185 #define VIA_CR80_FIRST_CODEC 0
186 #define VIA_CR80_SECOND_CODEC (1 << 30)
187 #define VIA_CR80_FIRST_CODEC_VALID (1 << 25)
188 #define VIA_CR80_VALID (1 << 25)
189 #define VIA_CR80_SECOND_CODEC_VALID (1 << 27)
190 #define VIA_CR80_BUSY (1 << 24)
191 #define VIA_CR83_BUSY (1)
192 #define VIA_CR83_FIRST_CODEC_VALID (1 << 1)
193 #define VIA_CR80_READ (1 << 23)
194 #define VIA_CR80_WRITE_MODE 0
195 #define VIA_CR80_REG_IDX(idx) ((((idx) & 0xFF) >> 1) << 16)
196
197 /* h r puff n stuff */
198 #define VIA_FMT_STEREO 0x01
199 #define VIA_FMT_16BIT 0x02
200 #define VIA_FMT_MASK 0x03
201 #define VIA_DAC_SHIFT 0
202 #define VIA_ADC_SHIFT 4
203
204 /* undocumented(?) values for setting rate, from Via's source */
205 #define VIA_SET_RATE_IN 0x00320000 /* set input rate */
206 #define VIA_SET_RATE_OUT 0x002c0000 /* set output rate */
207
208
209 /* scatter-gather DMA table entry, exactly as passed to hardware */
210 struct via_sgd_table {
211 u32 addr;
212 u32 count; /* includes additional bits also */
213 };
214 #define VIA_EOL (1 << 31)
215 #define VIA_FLAG (1 << 30)
216
217
218 enum via_channel_states {
219 sgd_stopped = 0,
220 sgd_in_progress = 1,
221 };
222
223
224 struct via_sgd_data {
225 dma_addr_t handle;
226 volatile void *cpuaddr;
227 };
228
229
230 struct via_channel {
231 unsigned rate; /* sample rate */
232
233 u8 pcm_fmt; /* VIA_PCM_FMT_xxx */
234
235 atomic_t state;
236 atomic_t buf_in_use;
237 atomic_t next_buf;
238
239 volatile struct via_sgd_table *sgtable;
240 dma_addr_t sgt_handle;
241
242 struct via_sgd_data sgbuf [VIA_DMA_BUFFERS];
243
244 wait_queue_head_t wait;
245
246 long iobase;
247 };
248
249
250 /* data stored for each chip */
251 struct via_info {
252 struct pci_dev *pdev;
253 long baseaddr;
254
255 struct ac97_codec ac97;
256 spinlock_t lock;
257 int card_num; /* unique card number, from 0 */
258
259 int dev_dsp; /* /dev/dsp index from register_sound_dsp() */
260
261 unsigned rev_h : 1;
262
263 wait_queue_head_t open_wait;
264 int open_mode;
265
266 struct via_channel ch_in;
267 struct via_channel ch_out;
268 };
269
270
271 /* number of cards, used for assigning unique numbers to cards */
272 static unsigned via_num_cards = 0;
273
274
275 /****************************************************************
276 *
277 * prototypes
278 *
279 *
280 */
281
282 static int via_init_one (struct pci_dev *dev, const struct pci_device_id *id);
283 static void via_remove_one (struct pci_dev *pdev);
284
285 static ssize_t via_dsp_read(struct file *file, char *buffer, size_t count, loff_t *ppos);
286 static ssize_t via_dsp_write(struct file *file, const char *buffer, size_t count, loff_t *ppos);
287 static unsigned int via_dsp_poll(struct file *file, struct poll_table_struct *wait);
288 static int via_dsp_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
289 static int via_dsp_open (struct inode *inode, struct file *file);
290 static int via_dsp_release(struct inode *inode, struct file *file);
291
292 static u16 via_ac97_read_reg (struct ac97_codec *codec, u8 reg);
293 static void via_ac97_write_reg (struct ac97_codec *codec, u8 reg, u16 value);
294 static u8 via_ac97_wait_idle (struct via_info *card);
295
296 static void via_chan_free (struct via_info *card, struct via_channel *chan);
297 static void via_chan_clear (struct via_channel *chan);
298 static void via_chan_pcm_fmt (struct via_info *card,
299 struct via_channel *chan, int reset);
300
301
302 /****************************************************************
303 *
304 * Various data the driver needs
305 *
306 *
307 */
308
309
310 static struct pci_device_id via_pci_tbl[] __initdata = {
311 { PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_5, PCI_ANY_ID, PCI_ANY_ID, },
312 { 0, }
313 };
314 MODULE_DEVICE_TABLE(pci,via_pci_tbl);
315
316
317 static struct pci_driver via_driver = {
318 name: VIA_MODULE_NAME,
319 id_table: via_pci_tbl,
320 probe: via_init_one,
321 remove: via_remove_one,
322 };
323
324
325 /****************************************************************
326 *
327 * Low-level base 0 register read/write helpers
328 *
329 *
330 */
331
332 /**
333 * via_chan_stop - Terminate DMA on specified PCM channel
334 * @iobase: PCI base address for SGD channel registers
335 *
336 * Terminate scatter-gather DMA operation for given
337 * channel (derived from @iobase), if DMA is active.
338 *
339 * Note that @iobase is not the PCI base address,
340 * but the PCI base address plus an offset to
341 * one of three PCM channels supported by the chip.
342 *
343 */
344
345 static inline void via_chan_stop (int iobase)
346 {
347 if (inb (iobase + VIA_PCM_STATUS) & VIA_SGD_ACTIVE)
348 outb (VIA_SGD_TERMINATE, iobase + VIA_PCM_CONTROL);
349 }
350
351
352 /**
353 * via_chan_status_clear - Clear status flags on specified DMA channel
354 * @iobase: PCI base address for SGD channel registers
355 *
356 * Clear any pending status flags for the given
357 * DMA channel (derived from @iobase), if any
358 * flags are asserted.
359 *
360 * Note that @iobase is not the PCI base address,
361 * but the PCI base address plus an offset to
362 * one of three PCM channels supported by the chip.
363 *
364 */
365
366 static inline void via_chan_status_clear (int iobase)
367 {
368 u8 tmp = inb (iobase + VIA_PCM_STATUS);
369
370 if (tmp != 0)
371 outb (tmp, iobase + VIA_PCM_STATUS);
372 }
373
374
375 /**
376 * sg_begin - Begin recording or playback on a PCM channel
377 * @chan: Channel for which DMA operation shall begin
378 *
379 * Start scatter-gather DMA for the given channel.
380 *
381 */
382
383 static inline void sg_begin (struct via_channel *chan)
384 {
385 outb (VIA_SGD_START, chan->iobase + VIA_PCM_CONTROL);
386 }
387
388
389 /**
390 * via_chan_bufs_in_use - Number of buffers waiting to be consumed
391 * @chan: Channel for which DMA buffers will be counted
392 *
393 * Count the number of buffers waiting to be consumed. For a
394 * playback operation, this is the number of buffers which have
395 * yet to be sent to the DAC. For a recording operation, this
396 * is the number of buffers waiting to be consumed by software
397 * calling read() system call.
398 *
399 */
400
401 static inline int via_chan_bufs_in_use (struct via_channel *chan)
402 {
403 return atomic_read(&chan->next_buf) -
404 atomic_read(&chan->buf_in_use);
405 }
406
407
408 /**
409 * via_chan_full - Check for no-free-buffers condition
410 * @chan: Channel for which DMA full condition will be checked
411 *
412 * Count the number of buffers waiting to be consumed, and return
413 * true (non-zero) if no buffers are available to be filled on the
414 * given DMA channel.
415 *
416 */
417
418 static inline int via_chan_full (struct via_channel *chan)
419 {
420 return (via_chan_bufs_in_use (chan) == VIA_DMA_BUFFERS);
421 }
422
423
424 /**
425 * via_chan_empty - Check for no-buffers-in-use condition
426 * @chan: Channel for which DMA empty condition will be checked
427 *
428 * Count the number of buffers waiting to be consumed, and return
429 * true (non-zero) if no buffers are currently in use.
430 *
431 */
432
433 static inline int via_chan_empty (struct via_channel *chan)
434 {
435 return (atomic_read(&chan->next_buf) ==
436 atomic_read(&chan->buf_in_use));
437 }
438
439
440 /****************************************************************
441 *
442 * Miscellaneous debris
443 *
444 *
445 */
446
447
448 /**
449 * via_stop_everything - Stop all audio operations
450 * @card: Private info for specified board
451 *
452 * Stops all DMA operations and interrupts, and clear
453 * any pending status bits resulting from those operations.
454 */
455
456 static void via_stop_everything (struct via_info *card)
457 {
458 DPRINTK ("ENTER\n");
459
460 assert (card != NULL);
461
462 /*
463 * terminate any existing operations on audio read/write channels
464 */
465 via_chan_stop (card->baseaddr + VIA_BASE0_PCM_OUT_CHAN);
466 via_chan_stop (card->baseaddr + VIA_BASE0_PCM_IN_CHAN);
467 via_chan_stop (card->baseaddr + VIA_BASE0_FM_OUT_CHAN);
468
469 /*
470 * clear any existing stops / flags (sanity check mainly)
471 */
472 via_chan_status_clear (card->baseaddr + VIA_BASE0_PCM_OUT_CHAN);
473 via_chan_status_clear (card->baseaddr + VIA_BASE0_PCM_IN_CHAN);
474 via_chan_status_clear (card->baseaddr + VIA_BASE0_FM_OUT_CHAN);
475
476 /*
477 * clear any enabled interrupt bits, reset to 8-bit mono PCM mode
478 */
479 outb (0, card->baseaddr + VIA_BASE0_PCM_OUT_CHAN);
480 outb (0, card->baseaddr + VIA_BASE0_PCM_IN_CHAN);
481 outb (0, card->baseaddr + VIA_BASE0_FM_OUT_CHAN);
482 DPRINTK ("EXIT\n");
483 }
484
485
486 /**
487 * via_set_rate - Set PCM rate for given channel
488 * @card: Private info for specified board
489 * @rate: Desired PCM sample rate, in Khz
490 * @inhale_deeply: Boolean. If non-zero (true), the recording sample rate
491 * is set. If zero (false), the playback sample rate
492 * is set.
493 *
494 * Sets the PCM sample rate for a channel.
495 *
496 * Values for @rate are clamped to a range of 4000 Khz through 48000 Khz,
497 * due to hardware constraints.
498 *
499 * FIXME: @inhale_deeply argument is ignored, and %AC97_PCM_FRONT_DAC_RATE
500 * is the only rate which is really set. This needs to be fixed when
501 * recording support is added.
502 */
503
504 static int via_set_rate (struct via_info *card, unsigned rate, int inhale_deeply)
505 {
506
507 DPRINTK ("ENTER, rate = %d, inhale = %s\n",
508 rate, inhale_deeply ? "yes" : "no");
509
510 if (rate > 48000) rate = 48000;
511 if (rate < 4000) rate = 4000;
512
513 via_ac97_write_reg (&card->ac97, AC97_POWER_CONTROL,
514 (via_ac97_read_reg (&card->ac97, AC97_POWER_CONTROL) & ~0x0200) |
515 0x0200);
516 via_ac97_write_reg (&card->ac97, AC97_PCM_FRONT_DAC_RATE, rate);
517 via_ac97_write_reg (&card->ac97, AC97_POWER_CONTROL,
518 via_ac97_read_reg (&card->ac97, AC97_POWER_CONTROL) & ~0x0200);
519
520 DPRINTK ("EXIT, returning 0\n");
521 return rate;
522 }
523
524
525 /**
526 * via_set_adc_rate - Set PCM rate for recording channel
527 * @card: Private info for specified board
528 * @rate: Desired PCM sample rate, in Khz
529 *
530 * Sets the PCM sample rate for a recording channel.
531 *
532 * FIXME: @inhale_deeply argument to via_set_rate is ignored, and %AC97_PCM_FRONT_DAC_RATE
533 * is the only rate which is really set. Thus, this function will
534 * not work until via_set_rate is fixed.
535 */
536
537 static inline int via_set_adc_rate (struct via_info *card, int rate)
538 {
539 return via_set_rate (card, rate, 1);
540 }
541
542
543 /**
544 * via_set_dac_rate - Set PCM rate for playback channel
545 * @card: Private info for specified board
546 * @rate: Desired PCM sample rate, in Khz
547 *
548 * Sets the PCM sample rate for a playback channel.
549 */
550
551 static inline int via_set_dac_rate (struct via_info *card, int rate)
552 {
553 return via_set_rate (card, rate, 0);
554 }
555
556
557 /****************************************************************
558 *
559 * Channel-specific operations
560 *
561 *
562 */
563
564 /**
565 * via_chan_init - Initialize PCM channel
566 * @card: Private audio chip info
567 * @chan: Channel to be initialized
568 * @chan_ofs: Offset from PCI address, which determines the
569 * set of SGD registers to use.
570 *
571 * Performs all the preparations necessary to begin
572 * using a PCM channel.
573 *
574 * Currently the preparations include allocating the
575 * scatter-gather DMA table and buffers, setting the
576 * PCM channel to a known state, and passing the
577 * address of the DMA table to the hardware.
578 *
579 * Note that special care is taken when passing the
580 * DMA table address to hardware, because it was found
581 * during driver development that the hardware did not
582 * always "take" the address.
583 */
584
585 static int via_chan_init (struct via_info *card,
586 struct via_channel *chan, long chan_ofs)
587 {
588 int i;
589 unsigned long flags;
590
591 DPRINTK ("ENTER\n");
592
593 memset (chan, 0, sizeof (*chan));
594
595 /* alloc DMA-able memory for scatter-gather table */
596 chan->sgtable = pci_alloc_consistent (card->pdev,
597 (sizeof (struct via_sgd_table) * VIA_DMA_BUFFERS),
598 &chan->sgt_handle);
599 if (!chan->sgtable) {
600 printk (KERN_ERR PFX "DMA table alloc fail, aborting\n");
601 DPRINTK ("EXIT\n");
602 return -ENOMEM;
603 }
604
605 memset ((void*)chan->sgtable, 0,
606 (sizeof (struct via_sgd_table) * VIA_DMA_BUFFERS));
607
608 /* alloc DMA-able memory for scatter-gather buffers */
609 for (i = 0; i < VIA_DMA_BUFFERS; i++) {
610 chan->sgbuf[i].cpuaddr =
611 pci_alloc_consistent (card->pdev, VIA_DMA_BUF_SIZE,
612 &chan->sgbuf[i].handle);
613
614 if (!chan->sgbuf[i].cpuaddr)
615 goto err_out_nomem;
616
617 if (i < (VIA_DMA_BUFFERS - 1))
618 chan->sgtable[i].count = cpu_to_le32 (VIA_DMA_BUF_SIZE | VIA_FLAG);
619 else
620 chan->sgtable[i].count = cpu_to_le32 (VIA_DMA_BUF_SIZE | VIA_EOL);
621 chan->sgtable[i].addr = cpu_to_le32 (chan->sgbuf[i].handle);
622
623 #ifndef VIA_NDEBUG
624 memset (chan->sgbuf[i].cpuaddr, 0xBC, VIA_DMA_BUF_SIZE);
625 #endif
626
627 #if 1
628 DPRINTK ("dmabuf #%d (h=%lx, 32(h)=%lx, v2p=%lx, a=%p)\n",
629 i, (long)chan->sgbuf[i].handle,
630 (long)chan->sgtable[i].addr,
631 virt_to_phys(chan->sgbuf[i].cpuaddr),
632 chan->sgbuf[i].cpuaddr);
633 #endif
634 }
635
636 init_waitqueue_head (&chan->wait);
637
638 chan->pcm_fmt = VIA_PCM_FMT_MASK;
639 chan->iobase = card->baseaddr + chan_ofs;
640
641 spin_lock_irqsave (&card->lock, flags);
642
643 /* stop any existing channel output */
644 via_chan_clear (chan);
645 via_chan_status_clear (chan->iobase);
646 via_chan_pcm_fmt (card, chan, 1);
647
648 spin_unlock_irqrestore (&card->lock, flags);
649
650 /* set location of DMA-able scatter-gather info table */
651 DPRINTK("outl (0x%X, 0x%04lX)\n",
652 cpu_to_le32 (chan->sgt_handle),
653 card->baseaddr + chan_ofs + VIA_PCM_TABLE_ADDR);
654
655 via_ac97_wait_idle (card);
656 outl (cpu_to_le32 (chan->sgt_handle),
657 card->baseaddr + chan_ofs + VIA_PCM_TABLE_ADDR);
658 udelay (20);
659 via_ac97_wait_idle (card);
660
661 DPRINTK("inl (0x%lX) = %x\n",
662 chan->iobase + VIA_PCM_TABLE_ADDR,
663 inl(chan->iobase + VIA_PCM_TABLE_ADDR));
664
665 DPRINTK ("EXIT\n");
666 return 0;
667
668 err_out_nomem:
669 printk (KERN_ERR PFX "DMA buffer alloc fail, aborting\n");
670 via_chan_free (card, chan);
671 DPRINTK ("EXIT\n");
672 return -ENOMEM;
673 }
674
675
676 /**
677 * via_chan_free - Release a PCM channel
678 * @card: Private audio chip info
679 * @chan: Channel to be released
680 *
681 * Performs all the functions necessary to clean up
682 * an initialized channel.
683 *
684 * Currently these functions include disabled any
685 * active DMA operations, setting the PCM channel
686 * back to a known state, and releasing any allocated
687 * sound buffers.
688 */
689
690 static void via_chan_free (struct via_info *card, struct via_channel *chan)
691 {
692 int i;
693 unsigned long flags;
694
695 DPRINTK ("ENTER\n");
696
697 synchronize_irq();
698
699 spin_lock_irqsave (&card->lock, flags);
700
701 /* stop any existing channel output */
702 via_chan_stop (chan->iobase);
703 via_chan_status_clear (chan->iobase);
704 via_chan_pcm_fmt (card, chan, 1);
705
706 spin_unlock_irqrestore (&card->lock, flags);
707
708 /* zero location of DMA-able scatter-gather info table */
709 via_ac97_wait_idle(card);
710 outl (0, chan->iobase + VIA_PCM_TABLE_ADDR);
711
712 for (i = 0; i < VIA_DMA_BUFFERS; i++)
713 if (chan->sgbuf[i].cpuaddr) {
714 pci_free_consistent (card->pdev, VIA_DMA_BUF_SIZE,
715 (void*)chan->sgbuf[i].cpuaddr,
716 chan->sgbuf[i].handle);
717 chan->sgbuf[i].cpuaddr = NULL;
718 chan->sgbuf[i].handle = 0;
719 }
720
721 if (chan->sgtable) {
722 pci_free_consistent (card->pdev,
723 (sizeof (struct via_sgd_table) * VIA_DMA_BUFFERS),
724 (void*)chan->sgtable, chan->sgt_handle);
725 chan->sgtable = NULL;
726 }
727
728 DPRINTK ("EXIT\n");
729 }
730
731
732 /**
733 * via_chan_pcm_fmt - Update PCM channel settings
734 * @card: Private audio chip info
735 * @chan: Channel to be updated
736 * @reset: Boolean. If non-zero, channel will be reset
737 * to 8-bit mono mode.
738 *
739 * Stores the settings of the current PCM format,
740 * 8-bit or 16-bit, and mono/stereo, into the
741 * hardware settings for the specified channel.
742 * If @reset is non-zero, the channel is reset
743 * to 8-bit mono mode. Otherwise, the channel
744 * is set to the values stored in the channel
745 * information struct @chan.
746 */
747
748 static void via_chan_pcm_fmt (struct via_info *card,
749 struct via_channel *chan, int reset)
750 {
751 DPRINTK ("ENTER, pcm_fmt=0x%02X, reset=%s\n",
752 chan->pcm_fmt, reset ? "yes" : "no");
753
754 assert (card != NULL);
755 assert (chan != NULL);
756
757 if (reset)
758 /* reset to 8-bit mono mode */
759 chan->pcm_fmt = 0;
760
761 /* enable interrupts on FLAG and EOL */
762 chan->pcm_fmt |= VIA_CHAN_TYPE_MASK;
763
764 /* set interrupt select bits where applicable (PCM & FM out channels) */
765 if (chan == &card->ch_out)
766 chan->pcm_fmt |= VIA_CHAN_TYPE_INT_SELECT;
767
768 outb (chan->pcm_fmt, chan->iobase + 2);
769
770 DPRINTK ("EXIT, pcm_fmt = 0x%02X, reg = 0x%02X\n",
771 chan->pcm_fmt,
772 inb (chan->iobase + 2));
773 }
774
775
776 /**
777 * via_chan_clear - Stop DMA channel operation, and reset pointers
778 * @chan: Channel to be cleared
779 *
780 * Call via_chan_stop to halt DMA operations, and then resets
781 * all software pointers which track DMA operation.
782 */
783
784 static void via_chan_clear (struct via_channel *chan)
785 {
786 via_chan_stop (chan->iobase);
787 atomic_set (&chan->state, sgd_stopped);
788 atomic_set (&chan->buf_in_use, 0);
789 atomic_set (&chan->next_buf, 0);
790 }
791
792
793 /**
794 * via_chan_set_speed - Set PCM sample rate for given channel
795 * @card: Private info for specified board
796 * @chan: Channel whose sample rate will be adjusted
797 * @val: New sample rate, in Khz
798 *
799 * Helper function for the %SNDCTL_DSP_SPEED ioctl. OSS semantics
800 * demand that all audio operations halt (if they are not already
801 * halted) when the %SNDCTL_DSP_SPEED is given.
802 *
803 * This function halts all audio operations for the given channel
804 * @chan, and then calls via_set_rate to set the audio hardware
805 * to the new rate.
806 */
807
808 static int via_chan_set_speed (struct via_info *card,
809 struct via_channel *chan, int val)
810 {
811 DPRINTK ("ENTER, requested rate = %d\n", val);
812
813 via_chan_clear (chan);
814
815 val = via_set_rate (card, val, chan == &card->ch_in);
816
817 DPRINTK ("EXIT, returning %d\n", val);
818 return val;
819 }
820
821
822 /**
823 * via_chan_set_fmt - Set PCM sample size for given channel
824 * @card: Private info for specified board
825 * @chan: Channel whose sample size will be adjusted
826 * @val: New sample size, use the %AFMT_xxx constants
827 *
828 * Helper function for the %SNDCTL_DSP_SETFMT ioctl. OSS semantics
829 * demand that all audio operations halt (if they are not already
830 * halted) when the %SNDCTL_DSP_SETFMT is given.
831 *
832 * This function halts all audio operations for the given channel
833 * @chan, and then calls via_chan_pcm_fmt to set the audio hardware
834 * to the new sample size, either 8-bit or 16-bit.
835 */
836
837 static int via_chan_set_fmt (struct via_info *card,
838 struct via_channel *chan, int val)
839 {
840 DPRINTK ("ENTER, val=%s\n",
841 val == AFMT_U8 ? "AFMT_U8" :
842 val == AFMT_S16_LE ? "AFMT_S16_LE" :
843 "unknown");
844
845 via_chan_clear (chan);
846
847 switch (val) {
848 case AFMT_U8:
849 chan->pcm_fmt &= ~VIA_PCM_FMT_16BIT;
850 via_chan_pcm_fmt (card, chan, 0);
851 break;
852 case AFMT_S16_LE:
853 chan->pcm_fmt |= VIA_PCM_FMT_16BIT;
854 via_chan_pcm_fmt (card, chan, 0);
855 break;
856 default:
857 printk (KERN_WARNING PFX "unknown AFMT\n");
858 val = -EINVAL;
859 break;
860 }
861
862 DPRINTK ("EXIT, returning %d\n", val);
863 return val;
864 }
865
866
867 /**
868 * via_chan_set_stereo - Enable or disable stereo for a DMA channel
869 * @card: Private info for specified board
870 * @chan: Channel whose stereo setting will be adjusted
871 * @val: New sample size, use the %AFMT_xxx constants
872 *
873 * Helper function for the %SNDCTL_DSP_CHANNELS and %SNDCTL_DSP_STEREO ioctls. OSS semantics
874 * demand that all audio operations halt (if they are not already
875 * halted) when %SNDCTL_DSP_CHANNELS or SNDCTL_DSP_STEREO is given.
876 *
877 * This function halts all audio operations for the given channel
878 * @chan, and then calls via_chan_pcm_fmt to set the audio hardware
879 * to enable or disable stereo.
880 */
881
882 static int via_chan_set_stereo (struct via_info *card,
883 struct via_channel *chan, int val)
884 {
885 DPRINTK ("ENTER, channels = %d\n", val);
886
887 via_chan_clear (chan);
888
889 switch (val) {
890
891 /* mono */
892 case 1:
893 chan->pcm_fmt &= ~VIA_PCM_FMT_STEREO;
894 via_chan_pcm_fmt (card, chan, 0);
895 break;
896
897 /* stereo */
898 case 2:
899 chan->pcm_fmt |= VIA_PCM_FMT_STEREO;
900 via_chan_pcm_fmt (card, chan, 0);
901 break;
902
903 /* unknown */
904 default:
905 printk (KERN_WARNING PFX "unknown number of channels\n");
906 val = -EINVAL;
907 break;
908 }
909
910 DPRINTK ("EXIT, returning %d\n", val);
911 return val;
912 }
913
914
915 #if 0
916 /**
917 * via_chan_dump_bufs - Display DMA table contents
918 * @chan: Channel whose DMA table will be displayed
919 *
920 * Debugging function which displays the contents of the
921 * scatter-gather DMA table for the given channel @chan.
922 */
923
924 static void via_chan_dump_bufs (struct via_channel *chan)
925 {
926 int i;
927
928 for (i = 0; i < VIA_DMA_BUFFERS; i++) {
929 DPRINTK ("#%02d: addr=%x, count=%u, flag=%d, eol=%d\n",
930 i, chan->sgtable[i].addr,
931 chan->sgtable[i].count & 0x00FFFFFF,
932 chan->sgtable[i].count & VIA_FLAG ? 1 : 0,
933 chan->sgtable[i].count & VIA_EOL ? 1 : 0);
934 }
935 DPRINTK ("buf_in_use = %d, nextbuf = %d\n",
936 atomic_read (&chan->buf_in_use),
937 atomic_read (&chan->next_buf));
938 }
939 #endif
940
941
942 /****************************************************************
943 *
944 * Interface to ac97-codec module
945 *
946 *
947 */
948
949 /**
950 * via_ac97_wait_idle - Wait until AC97 codec is not busy
951 * @card: Private info for specified board
952 *
953 * Sleep until the AC97 codec is no longer busy.
954 * Returns the final value read from the SGD
955 * register being polled.
956 */
957
958 static u8 via_ac97_wait_idle (struct via_info *card)
959 {
960 u8 tmp8;
961 int counter = VIA_COUNTER_LIMIT;
962
963 DPRINTK ("ENTER/EXIT\n");
964
965 assert (card != NULL);
966 assert (card->pdev != NULL);
967
968 do {
969 if (current->need_resched)
970 schedule ();
971 else
972 udelay (10);
973
974 spin_lock_irq (&card->lock);
975 tmp8 = inb (card->baseaddr + 0x83);
976 spin_unlock_irq (&card->lock);
977 } while ((tmp8 & VIA_CR83_BUSY) && (counter-- > 0));
978
979 return tmp8;
980 }
981
982
983 /**
984 * via_ac97_read_reg - Read AC97 standard register
985 * @codec: Pointer to generic AC97 codec info
986 * @reg: Index of AC97 register to be read
987 *
988 * Read the value of a single AC97 codec register,
989 * as defined by the Intel AC97 specification.
990 *
991 * Defines the standard AC97 read-register operation
992 * required by the kernel's ac97_codec interface.
993 *
994 * Returns the 16-bit value stored in the specified
995 * register.
996 */
997
998 static u16 via_ac97_read_reg (struct ac97_codec *codec, u8 reg)
999 {
1000 u32 data;
1001 struct via_info *card;
1002 int counter;
1003
1004 DPRINTK ("ENTER\n");
1005
1006 assert (codec != NULL);
1007 assert (codec->private_data != NULL);
1008
1009 card = codec->private_data;
1010
1011 data = (reg << 16) | VIA_CR80_READ;
1012
1013 outl (data, card->baseaddr + VIA_BASE0_AC97_CTRL);
1014 udelay (20);
1015
1016 for (counter = VIA_COUNTER_LIMIT; counter > 0; counter--) {
1017 if (inl (card->baseaddr + 0x80) & VIA_CR80_VALID)
1018 goto out;
1019 udelay(10);
1020 if (current->need_resched)
1021 schedule ();
1022 }
1023
1024 printk (KERN_WARNING PFX "timeout while reading AC97 codec\n");
1025 goto err_out;
1026
1027 out:
1028 data = inl (card->baseaddr + 0x80);
1029 outb (0x02, card->baseaddr + 0x83);
1030
1031 if (((data & 0x007F0000) >> 16) == reg) {
1032 DPRINTK ("EXIT, success, data=0x%x, retval=0x%x\n",
1033 data, data & 0x0000FFFF);
1034 return data & 0x0000FFFF;
1035 }
1036
1037 DPRINTK ("WARNING: not our index: reg=0x%x, newreg=0x%x\n",
1038 reg, ((data & 0x007F0000) >> 16));
1039
1040 err_out:
1041 DPRINTK ("EXIT, returning 0\n");
1042 return 0;
1043 }
1044
1045
1046 /**
1047 * via_ac97_write_reg - Write AC97 standard register
1048 * @codec: Pointer to generic AC97 codec info
1049 * @reg: Index of AC97 register to be written
1050 * @value: Value to be written to AC97 register
1051 *
1052 * Write the value of a single AC97 codec register,
1053 * as defined by the Intel AC97 specification.
1054 *
1055 * Defines the standard AC97 write-register operation
1056 * required by the kernel's ac97_codec interface.
1057 */
1058
1059 static void via_ac97_write_reg (struct ac97_codec *codec, u8 reg, u16 value)
1060 {
1061 u32 data;
1062 struct via_info *card;
1063 int counter;
1064
1065 DPRINTK ("ENTER\n");
1066
1067 assert (codec != NULL);
1068 assert (codec->private_data != NULL);
1069
1070 card = codec->private_data;
1071
1072 data = (reg << 16) + value;
1073 outl (data, card->baseaddr + VIA_BASE0_AC97_CTRL);
1074 udelay (20);
1075
1076 for (counter = VIA_COUNTER_LIMIT; counter > 0; counter--) {
1077 if ((inb (card->baseaddr + 0x83) & VIA_CR83_BUSY) == 0)
1078 goto out;
1079 udelay(10);
1080 if (current->need_resched)
1081 schedule ();
1082 }
1083
1084 printk (KERN_WARNING PFX "timeout after AC97 codec write\n");
1085
1086 out:
1087 DPRINTK ("EXIT\n");
1088 }
1089
1090
1091 static int via_mixer_open (struct inode *inode, struct file *file)
1092 {
1093 int minor = MINOR(inode->i_rdev);
1094 struct via_info *card;
1095 struct pci_dev *pdev;
1096 struct pci_driver *drvr;
1097
1098 DPRINTK ("ENTER\n");
1099
1100 pci_for_each_dev(pdev) {
1101 drvr = pci_dev_driver (pdev);
1102 if (drvr == &via_driver) {
1103 assert (pdev->driver_data != NULL);
1104
1105 card = pdev->driver_data;
1106 if (card->ac97.dev_mixer == minor)
1107 goto match;
1108 }
1109 }
1110
1111 DPRINTK ("EXIT, returning -ENODEV\n");
1112 return -ENODEV;
1113
1114 match:
1115 file->private_data = &card->ac97;
1116
1117 DPRINTK ("EXIT, returning 0\n");
1118 return 0;
1119 }
1120
1121 static int via_mixer_ioctl (struct inode *inode, struct file *file, unsigned int cmd,
1122 unsigned long arg)
1123 {
1124 struct ac97_codec *codec = file->private_data;
1125 int rc;
1126
1127 assert (codec != NULL);
1128
1129 rc = codec->mixer_ioctl(codec, cmd, arg);
1130
1131 return rc;
1132 }
1133
1134
1135 static loff_t via_llseek(struct file *file, loff_t offset, int origin)
1136 {
1137 DPRINTK ("ENTER\n");
1138
1139 DPRINTK("EXIT, returning -ESPIPE\n");
1140 return -ESPIPE;
1141 }
1142
1143
1144 static struct file_operations via_mixer_fops = {
1145 owner: THIS_MODULE,
1146 open: via_mixer_open,
1147 llseek: via_llseek,
1148 ioctl: via_mixer_ioctl,
1149 };
1150
1151
1152 #if 0 /* values reasoned from debugging dumps of via's driver */
1153 static struct {
1154 u8 reg;
1155 u16 data;
1156 } mixer_init_vals[] __devinitdata = {
1157 { 0x2, 0x404 },
1158 { 0x4, 0x404 },
1159 { 0x6, 0x404 },
1160 { 0x18, 0x404 },
1161 { 0x10, 0x404 },
1162 { 0x1a, 0x404 },
1163 { 0x1c, 0x404 },
1164 { 0x1a, 0x404 },
1165 { 0x1c, 0xc0c },
1166 { 0x12, 0x808 },
1167 { 0x10, 0x808 },
1168 { 0xe, 0x2 },
1169 { 0x2, 0x808 },
1170 { 0x18, 0x808 },
1171 };
1172 #endif
1173
1174
1175 static int __init via_ac97_reset (struct via_info *card)
1176 {
1177 struct pci_dev *pdev = card->pdev;
1178 u8 tmp8;
1179 u16 tmp16;
1180
1181 DPRINTK ("ENTER\n");
1182
1183 assert (pdev != NULL);
1184
1185 #ifndef NDEBUG
1186 {
1187 u8 r40,r41,r42,r43,r44,r48;
1188 pci_read_config_byte (card->pdev, 0x40, &r40);
1189 pci_read_config_byte (card->pdev, 0x41, &r41);
1190 pci_read_config_byte (card->pdev, 0x42, &r42);
1191 pci_read_config_byte (card->pdev, 0x43, &r43);
1192 pci_read_config_byte (card->pdev, 0x44, &r44);
1193 pci_read_config_byte (card->pdev, 0x48, &r48);
1194 DPRINTK("PCI config: %02X %02X %02X %02X %02X %02X\n",
1195 r40,r41,r42,r43,r44,r48);
1196
1197 spin_lock_irq (&card->lock);
1198 DPRINTK ("regs==%02X %02X %02X %08X %08X %08X %08X\n",
1199 inb (card->baseaddr + 0x00),
1200 inb (card->baseaddr + 0x01),
1201 inb (card->baseaddr + 0x02),
1202 inl (card->baseaddr + 0x04),
1203 inl (card->baseaddr + 0x0C),
1204 inl (card->baseaddr + 0x80),
1205 inl (card->baseaddr + 0x84));
1206 spin_unlock_irq (&card->lock);
1207
1208 }
1209 #endif
1210
1211 /*
1212 * reset AC97 controller: enable, disable, enable
1213 * pause after each command for good luck
1214 */
1215 pci_write_config_byte (pdev, VIA_ACLINK_CTRL, VIA_CR41_AC97_ENABLE |
1216 VIA_CR41_AC97_RESET | VIA_CR41_AC97_WAKEUP);
1217 udelay (100);
1218
1219 pci_write_config_byte (pdev, VIA_ACLINK_CTRL, 0);
1220 udelay (100);
1221
1222 pci_write_config_byte (pdev, VIA_ACLINK_CTRL,
1223 VIA_CR41_AC97_ENABLE | VIA_CR41_PCM_ENABLE |
1224 VIA_CR41_VRA | VIA_CR41_AC97_RESET);
1225 udelay (100);
1226
1227 #if 0 /* this breaks on K7M */
1228 /* disable legacy stuff */
1229 pci_write_config_byte (pdev, 0x42, 0x00);
1230 udelay(10);
1231 #endif
1232
1233 /* route FM trap to IRQ, disable FM trap */
1234 pci_write_config_byte (pdev, 0x48, 0x05);
1235 udelay(10);
1236
1237 /* disable all codec GPI interrupts */
1238 outl (0, pci_resource_start (pdev, 0) + 0x8C);
1239
1240 /* enable variable rate */
1241 tmp16 = via_ac97_read_reg (&card->ac97, 0x2A);
1242 via_ac97_write_reg (&card->ac97, 0x2A, tmp16 | 0x01);
1243
1244 /* boost headphone vol if disabled */
1245 tmp16 = via_ac97_read_reg (&card->ac97, AC97_HEADPHONE_VOL);
1246 if (tmp16 == 0)
1247 via_ac97_write_reg (&card->ac97, AC97_HEADPHONE_VOL, 0x1F1F);
1248
1249 pci_read_config_byte (pdev, VIA_ACLINK_CTRL, &tmp8);
1250 if ((tmp8 & (VIA_CR41_AC97_ENABLE | VIA_CR41_AC97_RESET)) == 0) {
1251 printk (KERN_ERR PFX "cannot enable AC97 controller, aborting\n");
1252 DPRINTK ("EXIT, tmp8=%X, returning -ENODEV\n", tmp8);
1253 return -ENODEV;
1254 }
1255
1256 DPRINTK ("EXIT, returning 0\n");
1257 return 0;
1258 }
1259
1260
1261 static int __init via_ac97_init (struct via_info *card)
1262 {
1263 int rc;
1264 u16 tmp16;
1265
1266 DPRINTK ("ENTER\n");
1267
1268 assert (card != NULL);
1269
1270 memset (&card->ac97, 0, sizeof (card->ac97));
1271 card->ac97.private_data = card;
1272 card->ac97.codec_read = via_ac97_read_reg;
1273 card->ac97.codec_write = via_ac97_write_reg;
1274
1275 card->ac97.dev_mixer = register_sound_mixer (&via_mixer_fops, -1);
1276 if (card->ac97.dev_mixer < 0) {
1277 printk (KERN_ERR PFX "unable to register AC97 mixer, aborting\n");
1278 DPRINTK("EXIT, returning -EIO\n");
1279 return -EIO;
1280 }
1281
1282 rc = via_ac97_reset (card);
1283 if (rc) {
1284 printk (KERN_ERR PFX "unable to reset AC97 codec, aborting\n");
1285 goto err_out;
1286 }
1287
1288 if (ac97_probe_codec (&card->ac97) == 0) {
1289 printk (KERN_ERR PFX "unable to probe AC97 codec, aborting\n");
1290 rc = -EIO;
1291 goto err_out;
1292 }
1293
1294 tmp16 = via_ac97_read_reg (&card->ac97, 0x2A);
1295 via_ac97_write_reg (&card->ac97, 0x2A, tmp16 | 0x01);
1296
1297 DPRINTK ("EXIT, returning 0\n");
1298 return 0;
1299
1300 err_out:
1301 unregister_sound_mixer (card->ac97.dev_mixer);
1302 DPRINTK("EXIT, returning %d\n", rc);
1303 return rc;
1304 }
1305
1306
1307 static void via_ac97_cleanup (struct via_info *card)
1308 {
1309 DPRINTK("ENTER\n");
1310
1311 assert (card != NULL);
1312 assert (card->ac97.dev_mixer >= 0);
1313
1314 unregister_sound_mixer (card->ac97.dev_mixer);
1315
1316 DPRINTK("EXIT\n");
1317 }
1318
1319
1320
1321 /****************************************************************
1322 *
1323 * Interrupt-related code
1324 *
1325 */
1326
1327 static inline void via_interrupt_write (struct via_channel *chan)
1328 {
1329 assert (atomic_read(&chan->buf_in_use) <
1330 atomic_read(&chan->next_buf));
1331
1332 /* XXX sanity check: read h/w counter to
1333 * ensure no lost frames */
1334
1335 atomic_inc (&chan->buf_in_use);
1336
1337 /* if SG ptr catches up with userland ptr, stop playback */
1338 if (atomic_read(&chan->buf_in_use) == atomic_read(&chan->next_buf)) {
1339 atomic_set (&chan->state, sgd_stopped);
1340 via_chan_stop (chan->iobase);
1341 }
1342
1343 /* wake up anybody listening */
1344 if (waitqueue_active (&chan->wait))
1345 wake_up (&chan->wait);
1346 }
1347
1348
1349
1350 static void via_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1351 {
1352 struct via_info *card = dev_id;
1353 struct via_channel *chan;
1354 u8 status;
1355
1356 status = inb (card->baseaddr + 0x00);
1357 if (status) {
1358 assert (card->open_mode & FMODE_WRITE);
1359
1360 chan = &card->ch_out;
1361
1362 if (status & VIA_SGD_FLAG) {
1363 assert ((status & VIA_SGD_EOL) == 0);
1364 outb (VIA_SGD_FLAG, chan->iobase + 0x00);
1365 DPRINTK("FLAG intr, status=0x%02X\n", status);
1366 via_interrupt_write (chan);
1367 }
1368
1369 if (status & VIA_SGD_EOL) {
1370 assert ((status & VIA_SGD_FLAG) == 0);
1371 outb (VIA_SGD_EOL, chan->iobase + 0x00);
1372 DPRINTK("EOL intr, status=0x%02X\n", status);
1373 via_interrupt_write (chan);
1374 }
1375
1376 if (status & VIA_SGD_STOPPED) {
1377 outb (VIA_SGD_STOPPED, chan->iobase + 0x00);
1378 DPRINTK("STOPPED intr, status=0x%02X\n", status);
1379 }
1380
1381 #if 0
1382 via_chan_dump_bufs (&card->ch_out);
1383 #endif
1384 }
1385 }
1386
1387
1388 static void via_interrupt_disable (struct via_info *card)
1389 {
1390 u8 tmp8;
1391 unsigned long flags;
1392
1393 DPRINTK ("ENTER\n");
1394
1395 assert (card != NULL);
1396
1397 spin_lock_irqsave (&card->lock, flags);
1398
1399 pci_read_config_byte (card->pdev, VIA_FM_NMI_CTRL, &tmp8);
1400 if ((tmp8 & VIA_CR48_FM_TRAP_TO_NMI) == 0) {
1401 tmp8 |= VIA_CR48_FM_TRAP_TO_NMI;
1402 pci_write_config_byte (card->pdev, VIA_FM_NMI_CTRL, tmp8);
1403 }
1404
1405 outb (inb (card->baseaddr + VIA_BASE0_PCM_OUT_CHAN_TYPE) &
1406 VIA_INT_DISABLE_MASK,
1407 card->baseaddr + VIA_BASE0_PCM_OUT_CHAN_TYPE);
1408 outb (inb (card->baseaddr + VIA_BASE0_PCM_IN_CHAN_TYPE) &
1409 VIA_INT_DISABLE_MASK,
1410 card->baseaddr + VIA_BASE0_PCM_IN_CHAN_TYPE);
1411 outb (inb (card->baseaddr + VIA_BASE0_FM_OUT_CHAN_TYPE) &
1412 VIA_INT_DISABLE_MASK,
1413 card->baseaddr + VIA_BASE0_FM_OUT_CHAN_TYPE);
1414
1415 spin_unlock_irqrestore (&card->lock, flags);
1416
1417 DPRINTK ("EXIT\n");
1418 }
1419
1420
1421 static int via_interrupt_init (struct via_info *card)
1422 {
1423 DPRINTK ("ENTER\n");
1424
1425 assert (card != NULL);
1426 assert (card->pdev != NULL);
1427
1428 /* check for sane IRQ number. can this ever happen? */
1429 if (card->pdev->irq < 2) {
1430 printk (KERN_ERR PFX "insane IRQ %d, aborting\n",
1431 card->pdev->irq);
1432 DPRINTK ("EXIT, returning -EIO\n");
1433 return -EIO;
1434 }
1435
1436 if (request_irq (card->pdev->irq, via_interrupt, SA_SHIRQ, VIA_MODULE_NAME, card)) {
1437 printk (KERN_ERR PFX "unable to obtain IRQ %d, aborting\n",
1438 card->pdev->irq);
1439 DPRINTK ("EXIT, returning -EBUSY\n");
1440 return -EBUSY;
1441 }
1442
1443 /* we don't want interrupts until we're opened */
1444 via_interrupt_disable (card);
1445
1446 DPRINTK ("EXIT, returning 0\n");
1447 return 0;
1448 }
1449
1450
1451 static void via_interrupt_cleanup (struct via_info *card)
1452 {
1453 DPRINTK ("ENTER\n");
1454
1455 assert (card != NULL);
1456 assert (card->pdev != NULL);
1457
1458 via_interrupt_disable (card);
1459
1460 free_irq (card->pdev->irq, card);
1461
1462 DPRINTK ("EXIT\n");
1463 }
1464
1465
1466 /****************************************************************
1467 *
1468 * OSS DSP device
1469 *
1470 */
1471
1472 static struct file_operations via_dsp_fops = {
1473 owner: THIS_MODULE,
1474 open: via_dsp_open,
1475 release: via_dsp_release,
1476 read: via_dsp_read,
1477 write: via_dsp_write,
1478 poll: via_dsp_poll,
1479 llseek: via_llseek,
1480 ioctl: via_dsp_ioctl,
1481 };
1482
1483
1484 static int __init via_dsp_init (struct via_info *card)
1485 {
1486 u8 tmp8;
1487
1488 DPRINTK ("ENTER\n");
1489
1490 assert (card != NULL);
1491
1492 /* turn off legacy features, if not already */
1493 pci_read_config_byte (card->pdev, VIA_FUNC_ENABLE, &tmp8);
1494 tmp8 &= ~(VIA_CR42_SB_ENABLE | VIA_CR42_MIDI_ENABLE |
1495 VIA_CR42_FM_ENABLE);
1496 pci_write_config_byte (card->pdev, VIA_FUNC_ENABLE, tmp8);
1497
1498 via_stop_everything (card);
1499
1500 card->dev_dsp = register_sound_dsp (&via_dsp_fops, -1);
1501 if (card->dev_dsp < 0) {
1502 DPRINTK ("EXIT, returning -ENODEV\n");
1503 return -ENODEV;
1504 }
1505 DPRINTK ("EXIT, returning 0\n");
1506 return 0;
1507 }
1508
1509
1510 static void via_dsp_cleanup (struct via_info *card)
1511 {
1512 DPRINTK ("ENTER\n");
1513
1514 assert (card != NULL);
1515 assert (card->dev_dsp >= 0);
1516
1517 via_stop_everything (card);
1518
1519 unregister_sound_dsp (card->dev_dsp);
1520
1521 DPRINTK ("EXIT\n");
1522 }
1523
1524
1525 static ssize_t via_dsp_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
1526 {
1527 struct via_info *card;
1528
1529 DPRINTK ("ENTER\n");
1530
1531 assert (file != NULL);
1532 assert (buffer != NULL);
1533 card = file->private_data;
1534 assert (card != NULL);
1535
1536 DPRINTK("EXIT, returning -EINVAL\n");
1537 return -EINVAL;
1538 }
1539
1540
1541
1542 #define sgcount(n) (sgtable[(n)].count & 0x00FFFFFF)
1543 #define NEXTBUF (atomic_read(&chan->next_buf) % VIA_DMA_BUFFERS)
1544 #define BUF_IN_USE (atomic_read(&chan->buf_in_use) % VIA_DMA_BUFFERS)
1545 #define STATE_STOPPED (atomic_read (state) == sgd_stopped)
1546 #define STATE_STARTED (atomic_read (state) == sgd_in_progress)
1547 static ssize_t via_dsp_do_write (struct via_info *card,
1548 const char *userbuf, size_t count,
1549 int non_blocking)
1550 {
1551 const char *orig_userbuf = userbuf;
1552 struct via_channel *chan = &card->ch_out;
1553 volatile struct via_sgd_table *sgtable = chan->sgtable;
1554 atomic_t *state = &chan->state;
1555 size_t size;
1556 int nextbuf, prevbuf, n, realcount;
1557 ssize_t rc;
1558
1559 while (count > 0) {
1560 if (current->need_resched)
1561 schedule ();
1562
1563 spin_lock_irq (&card->lock);
1564 DPRINTK ("regs==%02X %02X %02X %08X %08X %08X %08X\n",
1565 inb (card->baseaddr + 0x00),
1566 inb (card->baseaddr + 0x01),
1567 inb (card->baseaddr + 0x02),
1568 inl (card->baseaddr + 0x04),
1569 inl (card->baseaddr + 0x0C),
1570 inl (card->baseaddr + 0x80),
1571 inl (card->baseaddr + 0x84));
1572 spin_unlock_irq (&card->lock);
1573
1574 size = (count < VIA_DMA_BUF_SIZE) ? count : VIA_DMA_BUF_SIZE;
1575
1576 /* case 1: SGD not active, list is ours for the mangling */
1577
1578 if (STATE_STOPPED) {
1579 DPRINTK ("case 1\n");
1580
1581 if (copy_from_user ((void*)chan->sgbuf[0].cpuaddr,
1582 userbuf, size))
1583 return -EFAULT;
1584
1585 assert (sgtable[0].addr == cpu_to_le32 (chan->sgbuf[0].handle));
1586 sgtable[0].count = size | VIA_FLAG;
1587
1588 atomic_set (state, sgd_in_progress);
1589 atomic_set (&chan->buf_in_use, 0);
1590 atomic_set (&chan->next_buf, 1);
1591
1592 count -= size;
1593 userbuf += size;
1594
1595 spin_lock_irq (&card->lock);
1596 sg_begin (chan);
1597 spin_unlock_irq (&card->lock);
1598
1599 continue;
1600 }
1601
1602 nextbuf = NEXTBUF;
1603 if (nextbuf)
1604 prevbuf = nextbuf - 1;
1605 else
1606 prevbuf = VIA_DMA_BUFFERS - 1;
1607
1608 /* case 2: if final buffer is (a) a fragment, and (b) not
1609 * currently being consumed by the SGD engine, then append
1610 * as much data as possible to the fragment. */
1611
1612 realcount = sgcount(prevbuf);
1613 if (STATE_STARTED && (prevbuf != BUF_IN_USE) &&
1614 (realcount < VIA_DMA_BUF_SIZE)) {
1615 DPRINTK ("case 2\n");
1616 DPRINTK ("st=%d, fb=%d -- nb=%d, pb=%d, n=%d, rc=%d\n",
1617 atomic_read (state),
1618 BUF_IN_USE,
1619 nextbuf,
1620 prevbuf,
1621 prevbuf /* n */,
1622 realcount);
1623
1624 n = prevbuf;
1625
1626 if ((VIA_DMA_BUF_SIZE - realcount) < size)
1627 size = VIA_DMA_BUF_SIZE - realcount;
1628
1629 if (copy_from_user ((void*)(chan->sgbuf[n].cpuaddr +
1630 realcount),
1631 userbuf, size))
1632 return -EFAULT;
1633
1634 /* slack way to try and prevent races */
1635 if (prevbuf == BUF_IN_USE || !STATE_STARTED)
1636 continue;
1637
1638 assert (sgtable[n].addr == cpu_to_le32 (chan->sgbuf[n].handle));
1639 if (n == (VIA_DMA_BUFFERS - 1))
1640 sgtable[n].count = (realcount + size) | VIA_EOL;
1641 else
1642 sgtable[n].count = (realcount + size) | VIA_FLAG;
1643
1644 count -= size;
1645 userbuf += size;
1646 continue;
1647 }
1648
1649 /* case 3: if there are buffers left, use one
1650 * XXX needs more review for possible races */
1651
1652 else if (STATE_STARTED && !via_chan_full (chan)) {
1653 DPRINTK ("case 3\n");
1654 DPRINTK ("st=%d, fb=%d -- nb=%d, pb=%d, n=%d\n",
1655 atomic_read (state),
1656 BUF_IN_USE,
1657 nextbuf,
1658 prevbuf,
1659 nextbuf /* n */);
1660
1661 n = nextbuf;
1662
1663 if (copy_from_user ((void*)chan->sgbuf[n].cpuaddr,
1664 userbuf, size))
1665 return -EFAULT;
1666
1667 if (n == (VIA_DMA_BUFFERS - 1))
1668 sgtable[n].count = size | VIA_EOL;
1669 else
1670 sgtable[n].count = size | VIA_FLAG;
1671
1672 /* if SGD stopped during data copy or SG table update,
1673 * then loop back to the beginning without updating
1674 * any pointers.
1675 * ie. slack way to prevent race */
1676 if (!STATE_STARTED)
1677 continue;
1678
1679 atomic_inc (&chan->next_buf);
1680
1681 count -= size;
1682 userbuf += size;
1683 continue;
1684 }
1685
1686 /* case 4, final SGT active case: no free buffers, wait for one */
1687
1688 else {
1689 DPRINTK ("case 4\n");
1690 DPRINTK ("st=%d, fb=%d -- nb=%d, pb=%d\n",
1691 atomic_read (state),
1692 BUF_IN_USE,
1693 nextbuf,
1694 prevbuf);
1695
1696 /* if playback stopped, no need to sleep */
1697 if (!STATE_STARTED)
1698 continue;
1699
1700 /* if buffer free, no need to sleep */
1701 if (!via_chan_full (chan))
1702 continue;
1703
1704 if (non_blocking) {
1705 rc = userbuf - orig_userbuf;
1706 if (rc == 0)
1707 rc = -EAGAIN;
1708 return rc;
1709 }
1710
1711 DPRINTK ("sleeping\n");
1712 interruptible_sleep_on (&chan->wait);
1713 if (signal_pending (current))
1714 return -ERESTARTSYS;
1715 }
1716 }
1717
1718 #if 0
1719 {
1720 u8 r40,r41,r42,r43,r44,r48;
1721 pci_read_config_byte (card->pdev, 0x40, &r40);
1722 pci_read_config_byte (card->pdev, 0x41, &r41);
1723 pci_read_config_byte (card->pdev, 0x42, &r42);
1724 pci_read_config_byte (card->pdev, 0x43, &r43);
1725 pci_read_config_byte (card->pdev, 0x44, &r44);
1726 pci_read_config_byte (card->pdev, 0x48, &r48);
1727 DPRINTK("PCI config: %02X %02X %02X %02X %02X %02X\n",
1728 r40,r41,r42,r43,r44,r48);
1729 }
1730 #endif
1731
1732 DPRINTK ("EXIT, returning %d\n",
1733 userbuf - orig_userbuf);
1734 return userbuf - orig_userbuf;
1735 }
1736 #undef sgcount
1737 #undef NEXTBUF
1738 #undef BUF_IN_USE
1739 #undef STATE_STOPPED
1740 #undef STATE_STARTED
1741
1742
1743 static ssize_t via_dsp_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
1744 {
1745 struct via_info *card;
1746 ssize_t rc;
1747
1748 DPRINTK ("ENTER, file=%p, buffer=%p, count=%u, ppos=%lu\n",
1749 file, buffer, count, ppos ? ((unsigned long)*ppos) : 0);
1750
1751 assert (file != NULL);
1752 assert (buffer != NULL);
1753 card = file->private_data;
1754 assert (card != NULL);
1755
1756 if (ppos != &file->f_pos) {
1757 DPRINTK ("EXIT, returning -ESPIPE\n");
1758 return -ESPIPE;
1759 }
1760
1761 rc = via_dsp_do_write (card, buffer, count, (file->f_flags & O_NONBLOCK));
1762
1763 DPRINTK("EXIT, returning %ld\n",(long) rc);
1764 return rc;
1765 }
1766
1767
1768 static unsigned int via_dsp_poll(struct file *file, struct poll_table_struct *wait)
1769 {
1770 struct via_info *card;
1771 unsigned int mask = 0;
1772
1773 DPRINTK ("ENTER\n");
1774
1775 assert (file != NULL);
1776 assert (wait != NULL);
1777 card = file->private_data;
1778 assert (card != NULL);
1779
1780 if ((file->f_mode & FMODE_WRITE) &&
1781 (atomic_read (&card->ch_out.state) != sgd_stopped)) {
1782 poll_wait(file, &card->ch_out.wait, wait);
1783
1784 /* XXX is this correct */
1785 if (atomic_read (&card->ch_out.buf_in_use) <
1786 atomic_read (&card->ch_out.next_buf))
1787 mask |= POLLOUT | POLLWRNORM;
1788 }
1789
1790 DPRINTK("EXIT, returning %u\n", mask);
1791 return mask;
1792 }
1793
1794
1795 static int via_dsp_drain_dac (struct via_info *card, int non_block)
1796 {
1797 DPRINTK ("ENTER, non_block = %d\n", non_block);
1798
1799 while (!via_chan_empty (&card->ch_out)) {
1800 if (non_block) {
1801 DPRINTK ("EXIT, returning -EBUSY\n");
1802 return -EBUSY;
1803 }
1804 if (signal_pending (current)) {
1805 DPRINTK ("EXIT, returning -ERESTARTSYS\n");
1806 return -ERESTARTSYS;
1807 }
1808
1809 #ifndef NDEBUG
1810 {
1811 u8 r40,r41,r42,r43,r44,r48;
1812 pci_read_config_byte (card->pdev, 0x40, &r40);
1813 pci_read_config_byte (card->pdev, 0x41, &r41);
1814 pci_read_config_byte (card->pdev, 0x42, &r42);
1815 pci_read_config_byte (card->pdev, 0x43, &r43);
1816 pci_read_config_byte (card->pdev, 0x44, &r44);
1817 pci_read_config_byte (card->pdev, 0x48, &r48);
1818 DPRINTK("PCI config: %02X %02X %02X %02X %02X %02X\n",
1819 r40,r41,r42,r43,r44,r48);
1820
1821 spin_lock_irq (&card->lock);
1822 DPRINTK ("regs==%02X %02X %02X %08X %08X %08X %08X\n",
1823 inb (card->baseaddr + 0x00),
1824 inb (card->baseaddr + 0x01),
1825 inb (card->baseaddr + 0x02),
1826 inl (card->baseaddr + 0x04),
1827 inl (card->baseaddr + 0x0C),
1828 inl (card->baseaddr + 0x80),
1829 inl (card->baseaddr + 0x84));
1830 spin_unlock_irq (&card->lock);
1831
1832 }
1833 #endif
1834
1835 DPRINTK ("sleeping\n");
1836 interruptible_sleep_on (&card->ch_out.wait);
1837 }
1838
1839 DPRINTK ("EXIT\n");
1840 return 0;
1841 }
1842
1843
1844 static int via_dsp_ioctl_space (struct via_info *card,
1845 struct via_channel *chan,
1846 void *arg)
1847 {
1848 audio_buf_info info;
1849 int n;
1850
1851 info.fragstotal = VIA_DMA_BUFFERS;
1852 info.fragsize = VIA_DMA_BUF_SIZE;
1853
1854 /* number of full fragments we can read without blocking */
1855 n = atomic_read (&chan->next_buf) - atomic_read (&chan->buf_in_use);
1856 info.fragments = VIA_DMA_BUFFERS - n;
1857
1858 /* number of bytes that can be read or written immediately
1859 * without blocking. FIXME: we are lazy and ignore partially-full
1860 * buffers.
1861 */
1862 info.bytes = info.fragments * VIA_DMA_BUF_SIZE;
1863
1864 DPRINTK ("EXIT, returning fragstotal=%d, fragsize=%d, fragments=%d, bytes=%d\n",
1865 info.fragstotal,
1866 info.fragsize,
1867 info.fragments,
1868 info.bytes);
1869
1870 return copy_to_user (arg, &info, sizeof (info));
1871 }
1872
1873
1874
1875 static int via_dsp_ioctl (struct inode *inode, struct file *file,
1876 unsigned int cmd, unsigned long arg)
1877 {
1878 int rc = -EINVAL, rd=0, wr=0, val=0;
1879 struct via_info *card;
1880
1881 DPRINTK ("ENTER, cmd = 0x%08X\n", cmd);
1882
1883 assert (file != NULL);
1884 card = file->private_data;
1885 assert (card != NULL);
1886
1887 if (file->f_mode & FMODE_WRITE)
1888 wr = 1;
1889 if (file->f_mode & FMODE_READ)
1890 rd = 1;
1891
1892 switch (cmd) {
1893
1894 /* OSS API version. XXX unverified */
1895 case OSS_GETVERSION:
1896 DPRINTK("EXIT, returning SOUND_VERSION\n");
1897 return put_user (SOUND_VERSION, (int *)arg);
1898
1899 /* list of supported PCM data formats */
1900 case SNDCTL_DSP_GETFMTS:
1901 DPRINTK("EXIT, returning AFMT U8|S16_LE\n");
1902 return put_user (AFMT_U8 | AFMT_S16_LE, (int *)arg);
1903
1904 /* query or set current channel's PCM data format */
1905 case SNDCTL_DSP_SETFMT:
1906 get_user_ret(val, (int *)arg, -EFAULT);
1907 if (val != AFMT_QUERY) {
1908 rc = 0;
1909
1910 spin_lock_irq (&card->lock);
1911 if (rc == 0 && rd)
1912 rc = via_chan_set_fmt (card, &card->ch_in, val);
1913 if (rc == 0 && wr)
1914 rc = via_chan_set_fmt (card, &card->ch_out, val);
1915 spin_unlock_irq (&card->lock);
1916
1917 if (rc <= 0)
1918 return rc ? rc : -EINVAL;
1919 val = rc;
1920 } else {
1921 spin_lock_irq (&card->lock);
1922 if ((rd && (card->ch_in.pcm_fmt & VIA_PCM_FMT_16BIT)) ||
1923 (wr && (card->ch_out.pcm_fmt & VIA_PCM_FMT_16BIT)))
1924 val = AFMT_S16_LE;
1925 else
1926 val = AFMT_U8;
1927 spin_unlock_irq (&card->lock);
1928 }
1929 DPRINTK("SETFMT EXIT, returning %d\n", val);
1930 return put_user (val, (int *)arg);
1931
1932 /* query or set number of channels (1=mono, 2=stereo) */
1933 case SNDCTL_DSP_CHANNELS:
1934 get_user_ret(val, (int *)arg, -EFAULT);
1935 if (val != 0) {
1936 rc = 0;
1937 spin_lock_irq (&card->lock);
1938 if (rc == 0 && rd)
1939 rc = via_chan_set_stereo (card, &card->ch_in, val);
1940 if (rc == 0 && wr)
1941 rc = via_chan_set_stereo (card, &card->ch_out, val);
1942 spin_unlock_irq (&card->lock);
1943 if (rc <= 0)
1944 return rc ? rc : -EINVAL;
1945 val = rc;
1946 } else {
1947 spin_lock_irq (&card->lock);
1948 if ((rd && (card->ch_in.pcm_fmt & VIA_PCM_FMT_STEREO)) ||
1949 (wr && (card->ch_out.pcm_fmt & VIA_PCM_FMT_STEREO)))
1950 val = 2;
1951 else
1952 val = 1;
1953 spin_unlock_irq (&card->lock);
1954 }
1955 DPRINTK("CHANNELS EXIT, returning %d\n", val);
1956 return put_user (val, (int *)arg);
1957
1958 /* enable (val is not zero) or disable (val == 0) stereo */
1959 case SNDCTL_DSP_STEREO:
1960 get_user_ret(val, (int *)arg, -EFAULT);
1961 rc = 0;
1962 spin_lock_irq (&card->lock);
1963 if (rc == 0 && rd)
1964 rc = via_chan_set_stereo (card, &card->ch_in, val ? 2 : 1);
1965 if (rc == 0 && wr)
1966 rc = via_chan_set_stereo (card, &card->ch_out, val ? 2 : 1);
1967 spin_unlock_irq (&card->lock);
1968 if (rc <= 0)
1969 return rc ? rc : -EINVAL;
1970 DPRINTK("STEREO EXIT, returning %d\n", val);
1971 return 0;
1972
1973 /* query or set sampling rate */
1974 case SNDCTL_DSP_SPEED:
1975 get_user_ret(val, (int *)arg, -EFAULT);
1976 if (val < 0)
1977 return -EINVAL;
1978 if (val > 0) {
1979 rc = 0;
1980 spin_lock_irq (&card->lock);
1981 if (rc == 0 && rd)
1982 rc = via_chan_set_speed (card, &card->ch_in, val);
1983 if (rc == 0 && wr)
1984 rc = via_chan_set_speed (card, &card->ch_out, val);
1985 spin_unlock_irq (&card->lock);
1986 if (rc <= 0)
1987 return rc ? rc : -EINVAL;
1988 val = rc;
1989 } else {
1990 spin_lock_irq (&card->lock);
1991 if (rd)
1992 val = card->ch_in.rate;
1993 else if (wr)
1994 val = card->ch_out.rate;
1995 else
1996 val = 0;
1997 spin_unlock_irq (&card->lock);
1998 }
1999 DPRINTK("SPEED EXIT, returning %d\n", val);
2000 return put_user (val, (int *)arg);
2001
2002 /* wait until all buffers have been played, and then stop device */
2003 case SNDCTL_DSP_SYNC:
2004 if (wr) {
2005 DPRINTK("SYNC EXIT (after calling via_dsp_drain_dac)\n");
2006 return via_dsp_drain_dac (card, file->f_flags & O_NONBLOCK);
2007 }
2008 break;
2009
2010 /* stop recording/playback immediately */
2011 case SNDCTL_DSP_RESET:
2012 spin_lock_irq (&card->lock);
2013 if (rd) {
2014 via_chan_clear (&card->ch_in);
2015 via_chan_pcm_fmt (card, &card->ch_in, 1);
2016 }
2017 if (wr) {
2018 via_chan_clear (&card->ch_out);
2019 via_chan_pcm_fmt (card, &card->ch_out, 1);
2020 }
2021 spin_unlock_irq (&card->lock);
2022 DPRINTK("RESET EXIT, returning 0\n");
2023 return 0;
2024
2025 /* obtain bitmask of device capabilities, such as mmap, full duplex, etc. */
2026 case SNDCTL_DSP_GETCAPS:
2027 DPRINTK("GETCAPS EXIT\n");
2028 return put_user(DSP_CAP_REVISION, (int *)arg);
2029
2030 /* obtain bitmask of device capabilities, such as mmap, full duplex, etc. */
2031 case SNDCTL_DSP_GETBLKSIZE:
2032 DPRINTK("GETBLKSIZE EXIT\n");
2033 return put_user(VIA_DMA_BUF_SIZE, (int *)arg);
2034
2035 /* obtain information about input buffering */
2036 case SNDCTL_DSP_GETISPACE:
2037 DPRINTK("GETISPACE EXIT\n");
2038 return via_dsp_ioctl_space (card, &card->ch_in, (void*) arg);
2039
2040 /* obtain information about output buffering */
2041 case SNDCTL_DSP_GETOSPACE:
2042 DPRINTK("GETOSPACE EXIT\n");
2043 return via_dsp_ioctl_space (card, &card->ch_out, (void*) arg);
2044
2045 /* return number of bytes remaining to be played by DMA engine */
2046 case SNDCTL_DSP_GETODELAY:
2047 {
2048 int n;
2049
2050 n = atomic_read (&card->ch_out.next_buf) -
2051 atomic_read (&card->ch_out.buf_in_use);
2052 assert (n >= 0);
2053
2054 if (n == 0)
2055 val = 0;
2056 else {
2057 val = (n - 1) * VIA_DMA_BUF_SIZE;
2058 val += inl (card->ch_out.iobase + VIA_BASE0_PCM_OUT_BLOCK_COUNT);
2059 }
2060
2061 DPRINTK("GETODELAY EXIT, val = %d bytes\n", val);
2062 return put_user (val, (int *)arg);
2063 }
2064
2065 /* set fragment size. implemented as a successful no-op for now */
2066 case SNDCTL_DSP_SETFRAGMENT:
2067 get_user_ret(val, (int *)arg, -EFAULT);
2068
2069 DPRINTK ("SNDCTL_DSP_SETFRAGMENT (fragshift==0x%04X (%d), maxfrags==0x%04X (%d))\n",
2070 val & 0xFFFF,
2071 val & 0xFFFF,
2072 (val >> 16) & 0xFFFF,
2073 (val >> 16) & 0xFFFF);
2074
2075 /* just to shut up some programs */
2076 return 0;
2077
2078 /* inform device of an upcoming pause in input (or output). not implemented */
2079 case SNDCTL_DSP_POST:
2080 DPRINTK("POST EXIT (null ioctl, returning -EINVAL)\n");
2081 return -EINVAL;
2082
2083 /* not implemented */
2084 default:
2085 DPRINTK ("unhandled ioctl\n");
2086 break;
2087 }
2088
2089 DPRINTK("EXIT, returning %d\n", rc);
2090 return rc;
2091 }
2092
2093
2094 static int via_dsp_open (struct inode *inode, struct file *file)
2095 {
2096 int open_mode, rc = -EINVAL, minor = MINOR(inode->i_rdev);
2097 int got_read_chan = 0, is_busy;
2098 struct via_info *card;
2099 struct pci_dev *pdev;
2100 struct pci_driver *drvr;
2101 unsigned long flags;
2102
2103 DPRINTK ("ENTER, minor=%d, file->f_mode=0x%x\n", minor, file->f_mode);
2104
2105 if (file->f_mode & FMODE_READ) /* no input ATM */
2106 goto err_out;
2107
2108 card = NULL;
2109 pci_for_each_dev(pdev) {
2110 drvr = pci_dev_driver (pdev);
2111 if (drvr == &via_driver) {
2112 assert (pdev->driver_data != NULL);
2113
2114 card = pdev->driver_data;
2115 DPRINTK ("dev_dsp = %d, minor = %d, assn = %d\n",
2116 card->dev_dsp, minor,
2117 (card->dev_dsp ^ minor) & ~0xf);
2118
2119 if (((card->dev_dsp ^ minor) & ~0xf) == 0)
2120 goto match;
2121 }
2122 }
2123
2124 DPRINTK ("no matching %s found\n", card ? "minor" : "driver");
2125 rc = -ENODEV;
2126 goto err_out;
2127
2128 match:
2129 file->private_data = card;
2130
2131 /* wait for device to become free */
2132 spin_lock_irqsave (&card->lock, flags);
2133 open_mode = card->open_mode;
2134 if (open_mode & file->f_mode)
2135 is_busy = 1;
2136 else {
2137 is_busy = 0;
2138 card->open_mode |= file->f_mode;
2139 open_mode = card->open_mode;
2140 }
2141 spin_unlock_irqrestore (&card->lock, flags);
2142 if (is_busy) {
2143 rc = -EBUSY;
2144 goto err_out;
2145 }
2146
2147 DPRINTK("open_mode now 0x%x\n", open_mode);
2148
2149 /* handle input from analog source */
2150 if (file->f_mode & FMODE_READ) {
2151 rc = via_chan_init (card, &card->ch_in, 0x10);
2152 if (rc)
2153 goto err_out_clear_mode;
2154
2155 got_read_chan = 1;
2156
2157 /* why is this forced to 16-bit stereo in all drivers? */
2158 card->ch_in.pcm_fmt =
2159 VIA_PCM_FMT_16BIT | VIA_PCM_FMT_STEREO;
2160
2161 spin_lock_irqsave (&card->lock, flags);
2162 via_chan_pcm_fmt (card, &card->ch_out, 0);
2163 spin_unlock_irqrestore (&card->lock, flags);
2164
2165 via_set_adc_rate (card, 8000);
2166 }
2167
2168 /* handle output to analog source */
2169 if (file->f_mode & FMODE_WRITE) {
2170 rc = via_chan_init (card, &card->ch_out, 0x00);
2171 if (rc)
2172 goto err_out_clear_mode;
2173
2174 if ((minor & 0xf) == SND_DEV_DSP16)
2175 card->ch_out.pcm_fmt |= VIA_PCM_FMT_16BIT;
2176
2177 spin_lock_irqsave (&card->lock, flags);
2178 via_chan_pcm_fmt (card, &card->ch_out, 0);
2179 spin_unlock_irqrestore (&card->lock, flags);
2180
2181 via_set_dac_rate (card, 8000);
2182 }
2183
2184 DPRINTK ("EXIT, returning 0\n");
2185 return 0;
2186
2187 err_out_clear_mode:
2188 if (got_read_chan)
2189 via_chan_free (card, &card->ch_in);
2190 spin_lock_irqsave (&card->lock, flags);
2191 card->open_mode &= ~file->f_mode;
2192 spin_unlock_irqrestore (&card->lock, flags);
2193 err_out:
2194 DPRINTK("ERROR EXIT, returning %d\n", rc);
2195 return rc;
2196 }
2197
2198
2199 static int via_dsp_release(struct inode *inode, struct file *file)
2200 {
2201 struct via_info *card;
2202 unsigned long flags;
2203
2204 DPRINTK ("ENTER\n");
2205
2206 assert (file != NULL);
2207 card = file->private_data;
2208 assert (card != NULL);
2209
2210 if (file->f_mode & FMODE_READ)
2211 via_chan_free (card, &card->ch_in);
2212
2213 if (file->f_mode & FMODE_WRITE) {
2214 via_dsp_drain_dac (card, file->f_flags & O_NONBLOCK);
2215 via_chan_free (card, &card->ch_out);
2216 }
2217
2218 spin_lock_irqsave (&card->lock, flags);
2219 card->open_mode &= ~(file->f_mode);
2220 spin_unlock_irqrestore (&card->lock, flags);
2221
2222 wake_up (&card->open_wait);
2223
2224 DPRINTK("EXIT, returning 0\n");
2225 return 0;
2226 }
2227
2228
2229 #ifdef VIA_PROC_FS
2230
2231 /****************************************************************
2232 *
2233 * /proc/driver/via/info
2234 *
2235 *
2236 */
2237
2238 static int via_info_read_proc (char *page, char **start, off_t off,
2239 int count, int *eof, void *data)
2240 {
2241 #define YN(val,bit) (((val) & (bit)) ? "yes" : "no")
2242 #define ED(val,bit) (((val) & (bit)) ? "enable" : "disable")
2243
2244 int len = 0;
2245 u8 r40, r41, r42, r44;
2246 struct via_info *card = data;
2247
2248 DPRINTK ("ENTER\n");
2249
2250 assert (card != NULL);
2251
2252 len += sprintf (page+len, VIA_CARD_NAME "\n\n");
2253
2254 pci_read_config_byte (card->pdev, 0x40, &r40);
2255 pci_read_config_byte (card->pdev, 0x41, &r41);
2256 pci_read_config_byte (card->pdev, 0x42, &r42);
2257 pci_read_config_byte (card->pdev, 0x44, &r44);
2258
2259 len += sprintf (page+len,
2260 "Via 82Cxxx PCI registers:\n"
2261 "\n"
2262 "40 Codec Ready: %s\n"
2263 " Codec Low-power: %s\n"
2264 " Secondary Codec Ready: %s\n"
2265 "\n"
2266 "41 Interface Enable: %s\n"
2267 " De-Assert Reset: %s\n"
2268 " Force SYNC high: %s\n"
2269 " Force SDO high: %s\n"
2270 " Variable Sample Rate On-Demand Mode: %s\n"
2271 " SGD Read Channel PCM Data Out: %s\n"
2272 " FM Channel PCM Data Out: %s\n"
2273 " SB PCM Data Out: %s\n"
2274 "\n"
2275 "42 Game port enabled: %s\n"
2276 " SoundBlaster enabled: %s\n"
2277 " FM enabled: %s\n"
2278 " MIDI enabled: %s\n"
2279 "\n"
2280 "44 AC-Link Interface Access: %s\n"
2281 " Secondary Codec Support: %s\n"
2282
2283 "\n",
2284
2285 YN (r40, VIA_CR40_AC97_READY),
2286 YN (r40, VIA_CR40_AC97_LOW_POWER),
2287 YN (r40, VIA_CR40_SECONDARY_READY),
2288
2289 ED (r41, VIA_CR41_AC97_ENABLE),
2290 YN (r41, (1 << 6)),
2291 YN (r41, (1 << 5)),
2292 YN (r41, (1 << 4)),
2293 ED (r41, (1 << 3)),
2294 ED (r41, (1 << 2)),
2295 ED (r41, (1 << 1)),
2296 ED (r41, (1 << 0)),
2297
2298 YN (r42, VIA_CR42_GAME_ENABLE),
2299 YN (r42, VIA_CR42_SB_ENABLE),
2300 YN (r42, VIA_CR42_FM_ENABLE),
2301 YN (r42, VIA_CR42_MIDI_ENABLE),
2302
2303 YN (r44, VIA_CR44_AC_LINK_ACCESS),
2304 YN (r44, VIA_CR44_SECOND_CODEC_SUPPORT)
2305
2306 );
2307
2308 DPRINTK("EXIT, returning %d\n", len);
2309 return len;
2310
2311 #undef YN
2312 #undef ED
2313 }
2314
2315
2316 /****************************************************************
2317 *
2318 * /proc/driver/via/... setup and cleanup
2319 *
2320 *
2321 */
2322
2323 static int __init via_init_proc (void)
2324 {
2325 DPRINTK ("ENTER\n");
2326
2327 if (!proc_mkdir ("driver/via", 0))
2328 return -EIO;
2329
2330 DPRINTK ("EXIT, returning 0\n");
2331 return 0;
2332 }
2333
2334
2335 static void via_cleanup_proc (void)
2336 {
2337 DPRINTK ("ENTER\n");
2338
2339 remove_proc_entry ("driver/via", NULL);
2340
2341 DPRINTK ("EXIT\n");
2342 }
2343
2344
2345 static int __init via_card_init_proc (struct via_info *card)
2346 {
2347 char s[32];
2348 int rc;
2349
2350 DPRINTK ("ENTER\n");
2351
2352 sprintf (s, "driver/via/%d", card->card_num);
2353 if (!proc_mkdir (s, 0)) {
2354 rc = -EIO;
2355 goto err_out_none;
2356 }
2357
2358 sprintf (s, "driver/via/%d/info", card->card_num);
2359 if (!create_proc_read_entry (s, 0, 0, via_info_read_proc, card)) {
2360 rc = -EIO;
2361 goto err_out_dir;
2362 }
2363
2364 sprintf (s, "driver/via/%d/ac97", card->card_num);
2365 if (!create_proc_read_entry (s, 0, 0, ac97_read_proc, &card->ac97)) {
2366 rc = -EIO;
2367 goto err_out_info;
2368 }
2369
2370 DPRINTK ("EXIT, returning 0\n");
2371 return 0;
2372
2373 err_out_info:
2374 sprintf (s, "driver/via/%d/info", card->card_num);
2375 remove_proc_entry (s, NULL);
2376
2377 err_out_dir:
2378 sprintf (s, "driver/via/%d", card->card_num);
2379 remove_proc_entry (s, NULL);
2380
2381 err_out_none:
2382 DPRINTK ("EXIT, returning %d\n", rc);
2383 return rc;
2384 }
2385
2386
2387 static void via_card_cleanup_proc (struct via_info *card)
2388 {
2389 char s[32];
2390
2391 DPRINTK ("ENTER\n");
2392
2393 sprintf (s, "driver/via/%d/ac97", card->card_num);
2394 remove_proc_entry (s, NULL);
2395
2396 sprintf (s, "driver/via/%d/info", card->card_num);
2397 remove_proc_entry (s, NULL);
2398
2399 sprintf (s, "driver/via/%d", card->card_num);
2400 remove_proc_entry (s, NULL);
2401
2402 DPRINTK ("EXIT\n");
2403 }
2404
2405
2406 #else
2407
2408 static inline int via_init_proc (void) { return 0; }
2409 static inline void via_cleanup_proc (void) {}
2410 static inline int via_card_init_proc (struct via_info *card) { return 0; }
2411 static inline void via_card_cleanup_proc (struct via_info *card) {}
2412
2413 #endif /* VIA_PROC_FS */
2414
2415
2416 /****************************************************************
2417 *
2418 * Chip setup and kernel registration
2419 *
2420 *
2421 */
2422
2423 static int __init via_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
2424 {
2425 int rc;
2426 struct via_info *card;
2427 u8 tmp;
2428 static int printed_version = 0;
2429
2430 DPRINTK ("ENTER\n");
2431
2432 if (printed_version++ == 0)
2433 printk (KERN_INFO "Via 686a audio driver " VIA_VERSION "\n");
2434
2435 if (!request_region (pci_resource_start (pdev, 0),
2436 pci_resource_len (pdev, 0),
2437 VIA_MODULE_NAME)) {
2438 printk (KERN_ERR PFX "unable to obtain I/O resources, aborting\n");
2439 rc = -EBUSY;
2440 goto err_out;
2441 }
2442
2443 if (pci_enable_device (pdev)) {
2444 rc = -EIO;
2445 goto err_out_none;
2446 }
2447
2448 card = kmalloc (sizeof (*card), GFP_KERNEL);
2449 if (!card) {
2450 printk (KERN_ERR PFX "out of memory, aborting\n");
2451 rc = -ENOMEM;
2452 goto err_out_none;
2453 }
2454
2455 pdev->driver_data = card;
2456
2457 memset (card, 0, sizeof (*card));
2458 card->pdev = pdev;
2459 card->baseaddr = pci_resource_start (pdev, 0);
2460 card->card_num = via_num_cards++;
2461 spin_lock_init (&card->lock);
2462 init_waitqueue_head(&card->open_wait);
2463
2464 /* if BAR 2 is present, chip is Rev H or later,
2465 * which means it has a few extra features */
2466 if (pci_resource_start (pdev, 2) > 0)
2467 card->rev_h = 1;
2468
2469 if (pdev->irq < 1) {
2470 printk (KERN_ERR PFX "invalid PCI IRQ %d, aborting\n", pdev->irq);
2471 rc = -ENODEV;
2472 goto err_out_kfree;
2473 }
2474
2475 if (!(pci_resource_flags (pdev, 0) & IORESOURCE_IO)) {
2476 printk (KERN_ERR PFX "unable to locate I/O resources, aborting\n");
2477 rc = -ENODEV;
2478 goto err_out_kfree;
2479 }
2480
2481 /*
2482 * init AC97 mixer and codec
2483 */
2484 rc = via_ac97_init (card);
2485 if (rc) {
2486 printk (KERN_ERR PFX "AC97 init failed, aborting\n");
2487 goto err_out_kfree;
2488 }
2489
2490 /*
2491 * init DSP device
2492 */
2493 rc = via_dsp_init (card);
2494 if (rc) {
2495 printk (KERN_ERR PFX "DSP device init failed, aborting\n");
2496 goto err_out_have_mixer;
2497 }
2498
2499 /*
2500 * per-card /proc info
2501 */
2502 rc = via_card_init_proc (card);
2503 if (rc) {
2504 printk (KERN_ERR PFX "card-specific /proc init failed, aborting\n");
2505 goto err_out_have_dsp;
2506 }
2507
2508 /*
2509 * init and turn on interrupts, as the last thing we do
2510 */
2511 rc = via_interrupt_init (card);
2512 if (rc) {
2513 printk (KERN_ERR PFX "interrupt init failed, aborting\n");
2514 goto err_out_have_proc;
2515 }
2516
2517 pci_read_config_byte (pdev, 0x3C, &tmp);
2518 if ((tmp & 0x0F) != pdev->irq) {
2519 printk (KERN_WARNING PFX "IRQ fixup, 0x3C==0x%02X\n", tmp);
2520 tmp &= 0xF0;
2521 tmp |= pdev->irq;
2522 pci_write_config_byte (pdev, 0x3C, tmp);
2523 DPRINTK("new 0x3c==0x%02x\n", tmp);
2524 } else {
2525 DPRINTK("IRQ reg 0x3c==0x%02x, irq==%d\n",
2526 tmp, tmp & 0x0F);
2527 }
2528
2529 printk (KERN_INFO PFX "board #%d at 0x%04lX, IRQ %d\n",
2530 card->card_num + 1, card->baseaddr, pdev->irq);
2531
2532 DPRINTK ("EXIT, returning 0\n");
2533 return 0;
2534
2535 err_out_have_proc:
2536 via_card_cleanup_proc (card);
2537
2538 err_out_have_dsp:
2539 via_dsp_cleanup (card);
2540
2541 err_out_have_mixer:
2542 via_ac97_cleanup (card);
2543
2544 err_out_kfree:
2545 #ifndef VIA_NDEBUG
2546 memset (card, 0xAB, sizeof (*card)); /* poison memory */
2547 #endif
2548 kfree (card);
2549
2550 err_out_none:
2551 release_region (pci_resource_start (pdev, 0), pci_resource_len (pdev, 0));
2552 err_out:
2553 pdev->driver_data = NULL;
2554 DPRINTK ("EXIT - returning %d\n", rc);
2555 return rc;
2556 }
2557
2558
2559 static void __exit via_remove_one (struct pci_dev *pdev)
2560 {
2561 struct via_info *card;
2562
2563 DPRINTK ("ENTER\n");
2564
2565 assert (pdev != NULL);
2566 card = pdev->driver_data;
2567 assert (card != NULL);
2568
2569 via_interrupt_cleanup (card);
2570 via_card_cleanup_proc (card);
2571 via_dsp_cleanup (card);
2572 via_ac97_cleanup (card);
2573
2574 release_region (pci_resource_start (pdev, 0), pci_resource_len (pdev, 0));
2575
2576 #ifndef VIA_NDEBUG
2577 memset (card, 0xAB, sizeof (*card)); /* poison memory */
2578 #endif
2579 kfree (card);
2580
2581 pdev->driver_data = NULL;
2582
2583 pci_set_power_state (pdev, 3); /* ...zzzzzz */
2584
2585 DPRINTK ("EXIT\n");
2586 return;
2587 }
2588
2589
2590 /****************************************************************
2591 *
2592 * Driver initialization and cleanup
2593 *
2594 *
2595 */
2596
2597 static int __init init_via82cxxx_audio(void)
2598 {
2599 int rc;
2600
2601 DPRINTK ("ENTER\n");
2602
2603 rc = via_init_proc ();
2604 if (rc) {
2605 DPRINTK ("EXIT, returning %d\n", rc);
2606 return rc;
2607 }
2608
2609 rc = pci_register_driver (&via_driver);
2610 if (rc < 1) {
2611 if (rc == 0)
2612 pci_unregister_driver (&via_driver);
2613 via_cleanup_proc ();
2614 DPRINTK ("EXIT, returning -ENODEV\n");
2615 return -ENODEV;
2616 }
2617
2618 DPRINTK ("EXIT, returning 0\n");
2619 return 0;
2620 }
2621
2622
2623 static void __exit cleanup_via82cxxx_audio(void)
2624 {
2625 DPRINTK("ENTER\n");
2626
2627 pci_unregister_driver (&via_driver);
2628 via_cleanup_proc ();
2629
2630 DPRINTK("EXIT\n");
2631 }
2632
2633
2634 module_init(init_via82cxxx_audio);
2635 module_exit(cleanup_via82cxxx_audio);
Mirror of the linux-mips.org kernel tree