?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[NETFILTER]: ip6table_mangle: reroute when nfmark changes in NF_IP6_LOCAL_OUT
[hh.org.git] / sound / oss / i810_audio.c
blobddcddc2347f7ec3450624b296f6e385b0013575a
1 /*
2 * Intel i810 and friends ICH driver for Linux
3 * Alan Cox <alan@redhat.com>
4 *
5 * Built from:
6 * Low level code: Zach Brown (original nonworking i810 OSS driver)
7 * Jaroslav Kysela <perex@suse.cz> (working ALSA driver)
8 *
9 * Framework: Thomas Sailer <sailer@ife.ee.ethz.ch>
10 * Extended by: Zach Brown <zab@redhat.com>
11 * and others..
12 *
13 * Hardware Provided By:
14 * Analog Devices (A major AC97 codec maker)
15 * Intel Corp (you've probably heard of them already)
16 *
17 * AC97 clues and assistance provided by
18 * Analog Devices
19 * Zach 'Fufu' Brown
20 * Jeff Garzik
21 *
22 * This program is free software; you can redistribute it and/or modify
23 * it under the terms of the GNU General Public License as published by
24 * the Free Software Foundation; either version 2 of the License, or
25 * (at your option) any later version.
26 *
27 * This program is distributed in the hope that it will be useful,
28 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 * GNU General Public License for more details.
31 *
32 * You should have received a copy of the GNU General Public License
33 * along with this program; if not, write to the Free Software
34 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
35 *
36 *
37 * Intel 810 theory of operation
38 *
39 * The chipset provides three DMA channels that talk to an AC97
40 * CODEC (AC97 is a digital/analog mixer standard). At its simplest
41 * you get 48Khz audio with basic volume and mixer controls. At the
42 * best you get rate adaption in the codec. We set the card up so
43 * that we never take completion interrupts but instead keep the card
44 * chasing its tail around a ring buffer. This is needed for mmap
45 * mode audio and happens to work rather well for non-mmap modes too.
46 *
47 * The board has one output channel for PCM audio (supported) and
48 * a stereo line in and mono microphone input. Again these are normally
49 * locked to 48Khz only. Right now recording is not finished.
50 *
51 * There is no midi support, no synth support. Use timidity. To get
52 * esd working you need to use esd -r 48000 as it won't probe 48KHz
53 * by default. mpg123 can't handle 48Khz only audio so use xmms.
54 *
55 * Fix The Sound On Dell
56 *
57 * Not everyone uses 48KHz. We know of no way to detect this reliably
58 * and certainly not to get the right data. If your i810 audio sounds
59 * stupid you may need to investigate other speeds. According to Analog
60 * they tend to use a 14.318MHz clock which gives you a base rate of
61 * 41194Hz.
62 *
63 * This is available via the 'ftsodell=1' option.
64 *
65 * If you need to force a specific rate set the clocking= option
66 *
67 * This driver is cursed. (Ben LaHaise)
68 *
69 * ICH 3 caveats
70 * Intel errata #7 for ICH3 IO. We need to disable SMI stuff
71 * when codec probing. [Not Yet Done]
72 *
73 * ICH 4 caveats
74 *
75 * The ICH4 has the feature, that the codec ID doesn't have to be
76 * congruent with the IO connection.
77 *
78 * Therefore, from driver version 0.23 on, there is a "codec ID" <->
79 * "IO register base offset" mapping (card->ac97_id_map) field.
80 *
81 * Juergen "George" Sawinski (jsaw)
82 */
83
84 #include <linux/module.h>
85 #include <linux/string.h>
86 #include <linux/ctype.h>
87 #include <linux/ioport.h>
88 #include <linux/sched.h>
89 #include <linux/delay.h>
90 #include <linux/sound.h>
91 #include <linux/slab.h>
92 #include <linux/soundcard.h>
93 #include <linux/pci.h>
94 #include <linux/interrupt.h>
95 #include <asm/io.h>
96 #include <asm/dma.h>
97 #include <linux/init.h>
98 #include <linux/poll.h>
99 #include <linux/spinlock.h>
100 #include <linux/smp_lock.h>
101 #include <linux/ac97_codec.h>
102 #include <linux/bitops.h>
103 #include <linux/mutex.h>
104
105 #include <asm/uaccess.h>
106
107 #define DRIVER_VERSION "1.01"
108
109 #define MODULOP2(a, b) ((a) & ((b) - 1))
110 #define MASKP2(a, b) ((a) & ~((b) - 1))
111
112 static int ftsodell;
113 static int strict_clocking;
114 static unsigned int clocking;
115 static int spdif_locked;
116 static int ac97_quirk = AC97_TUNE_DEFAULT;
117
118 //#define DEBUG
119 //#define DEBUG2
120 //#define DEBUG_INTERRUPTS
121 //#define DEBUG_MMAP
122 //#define DEBUG_MMIO
123
124 #define ADC_RUNNING 1
125 #define DAC_RUNNING 2
126
127 #define I810_FMT_16BIT 1
128 #define I810_FMT_STEREO 2
129 #define I810_FMT_MASK 3
130
131 #define SPDIF_ON 0x0004
132 #define SURR_ON 0x0010
133 #define CENTER_LFE_ON 0x0020
134 #define VOL_MUTED 0x8000
135
136 /* the 810's array of pointers to data buffers */
137
138 struct sg_item {
139 #define BUSADDR_MASK 0xFFFFFFFE
140 u32 busaddr;
141 #define CON_IOC 0x80000000 /* interrupt on completion */
142 #define CON_BUFPAD 0x40000000 /* pad underrun with last sample, else 0 */
143 #define CON_BUFLEN_MASK 0x0000ffff /* buffer length in samples */
144 u32 control;
145 };
146
147 /* an instance of the i810 channel */
148 #define SG_LEN 32
149 struct i810_channel
150 {
151 /* these sg guys should probably be allocated
152 separately as nocache. Must be 8 byte aligned */
153 struct sg_item sg[SG_LEN]; /* 32*8 */
154 u32 offset; /* 4 */
155 u32 port; /* 4 */
156 u32 used;
157 u32 num;
158 };
159
160 /*
161 * we have 3 separate dma engines. pcm in, pcm out, and mic.
162 * each dma engine has controlling registers. These goofy
163 * names are from the datasheet, but make it easy to write
164 * code while leafing through it.
165 *
166 * ICH4 has 6 dma engines, pcm in, pcm out, mic, pcm in 2,
167 * mic in 2, s/pdif. Of special interest is the fact that
168 * the upper 3 DMA engines on the ICH4 *must* be accessed
169 * via mmio access instead of pio access.
170 */
171
172 #define ENUM_ENGINE(PRE,DIG) \
173 enum { \
174 PRE##_BASE = 0x##DIG##0, /* Base Address */ \
175 PRE##_BDBAR = 0x##DIG##0, /* Buffer Descriptor list Base Address */ \
176 PRE##_CIV = 0x##DIG##4, /* Current Index Value */ \
177 PRE##_LVI = 0x##DIG##5, /* Last Valid Index */ \
178 PRE##_SR = 0x##DIG##6, /* Status Register */ \
179 PRE##_PICB = 0x##DIG##8, /* Position In Current Buffer */ \
180 PRE##_PIV = 0x##DIG##a, /* Prefetched Index Value */ \
181 PRE##_CR = 0x##DIG##b /* Control Register */ \
182 }
183
184 ENUM_ENGINE(OFF,0); /* Offsets */
185 ENUM_ENGINE(PI,0); /* PCM In */
186 ENUM_ENGINE(PO,1); /* PCM Out */
187 ENUM_ENGINE(MC,2); /* Mic In */
188
189 enum {
190 GLOB_CNT = 0x2c, /* Global Control */
191 GLOB_STA = 0x30, /* Global Status */
192 CAS = 0x34 /* Codec Write Semaphore Register */
193 };
194
195 ENUM_ENGINE(MC2,4); /* Mic In 2 */
196 ENUM_ENGINE(PI2,5); /* PCM In 2 */
197 ENUM_ENGINE(SP,6); /* S/PDIF */
198
199 enum {
200 SDM = 0x80 /* SDATA_IN Map Register */
201 };
202
203 /* interrupts for a dma engine */
204 #define DMA_INT_FIFO (1<<4) /* fifo under/over flow */
205 #define DMA_INT_COMPLETE (1<<3) /* buffer read/write complete and ioc set */
206 #define DMA_INT_LVI (1<<2) /* last valid done */
207 #define DMA_INT_CELV (1<<1) /* last valid is current */
208 #define DMA_INT_DCH (1) /* DMA Controller Halted (happens on LVI interrupts) */
209 #define DMA_INT_MASK (DMA_INT_FIFO|DMA_INT_COMPLETE|DMA_INT_LVI)
210
211 /* interrupts for the whole chip */
212 #define INT_SEC (1<<11)
213 #define INT_PRI (1<<10)
214 #define INT_MC (1<<7)
215 #define INT_PO (1<<6)
216 #define INT_PI (1<<5)
217 #define INT_MO (1<<2)
218 #define INT_NI (1<<1)
219 #define INT_GPI (1<<0)
220 #define INT_MASK (INT_SEC|INT_PRI|INT_MC|INT_PO|INT_PI|INT_MO|INT_NI|INT_GPI)
221
222 /* magic numbers to protect our data structures */
223 #define I810_CARD_MAGIC 0x5072696E /* "Prin" */
224 #define I810_STATE_MAGIC 0x63657373 /* "cess" */
225 #define I810_DMA_MASK 0xffffffff /* DMA buffer mask for pci_alloc_consist */
226 #define NR_HW_CH 3
227
228 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
229 #define NR_AC97 4
230
231 /* Please note that an 8bit mono stream is not valid on this card, you must have a 16bit */
232 /* stream at a minimum for this card to be happy */
233 static const unsigned sample_size[] = { 1, 2, 2, 4 };
234 /* Samples are 16bit values, so we are shifting to a word, not to a byte, hence shift */
235 /* values are one less than might be expected */
236 static const unsigned sample_shift[] = { -1, 0, 0, 1 };
237
238 enum {
239 ICH82801AA = 0,
240 ICH82901AB,
241 INTEL440MX,
242 INTELICH2,
243 INTELICH3,
244 INTELICH4,
245 INTELICH5,
246 SI7012,
247 NVIDIA_NFORCE,
248 AMD768,
249 AMD8111
250 };
251
252 static char * card_names[] = {
253 "Intel ICH 82801AA",
254 "Intel ICH 82901AB",
255 "Intel 440MX",
256 "Intel ICH2",
257 "Intel ICH3",
258 "Intel ICH4",
259 "Intel ICH5",
260 "SiS 7012",
261 "NVIDIA nForce Audio",
262 "AMD 768",
263 "AMD-8111 IOHub"
264 };
265
266 /* These are capabilities (and bugs) the chipsets _can_ have */
267 static struct {
268 int16_t nr_ac97;
269 #define CAP_MMIO 0x0001
270 #define CAP_20BIT_AUDIO_SUPPORT 0x0002
271 u_int16_t flags;
272 } card_cap[] = {
273 { 1, 0x0000 }, /* ICH82801AA */
274 { 1, 0x0000 }, /* ICH82901AB */
275 { 1, 0x0000 }, /* INTEL440MX */
276 { 1, 0x0000 }, /* INTELICH2 */
277 { 2, 0x0000 }, /* INTELICH3 */
278 { 3, 0x0003 }, /* INTELICH4 */
279 { 3, 0x0003 }, /* INTELICH5 */
280 /*@FIXME to be verified*/ { 2, 0x0000 }, /* SI7012 */
281 /*@FIXME to be verified*/ { 2, 0x0000 }, /* NVIDIA_NFORCE */
282 /*@FIXME to be verified*/ { 2, 0x0000 }, /* AMD768 */
283 /*@FIXME to be verified*/ { 3, 0x0001 }, /* AMD8111 */
284 };
285
286 static struct pci_device_id i810_pci_tbl [] = {
287 {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_5,
288 PCI_ANY_ID, PCI_ANY_ID, 0, 0, ICH82801AA},
289 {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_5,
290 PCI_ANY_ID, PCI_ANY_ID, 0, 0, ICH82901AB},
291 {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_440MX,
292 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTEL440MX},
293 {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_4,
294 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTELICH2},
295 {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_5,
296 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTELICH3},
297 {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_5,
298 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTELICH4},
299 {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_5,
300 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTELICH5},
301 {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_7012,
302 PCI_ANY_ID, PCI_ANY_ID, 0, 0, SI7012},
303 {PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_MCP1_AUDIO,
304 PCI_ANY_ID, PCI_ANY_ID, 0, 0, NVIDIA_NFORCE},
305 {PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_MCP2_AUDIO,
306 PCI_ANY_ID, PCI_ANY_ID, 0, 0, NVIDIA_NFORCE},
307 {PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_MCP3_AUDIO,
308 PCI_ANY_ID, PCI_ANY_ID, 0, 0, NVIDIA_NFORCE},
309 {PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_OPUS_7445,
310 PCI_ANY_ID, PCI_ANY_ID, 0, 0, AMD768},
311 {PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8111_AUDIO,
312 PCI_ANY_ID, PCI_ANY_ID, 0, 0, AMD8111},
313 {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_5,
314 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTELICH4},
315 {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_18,
316 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTELICH4},
317 {PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_CK804_AUDIO,
318 PCI_ANY_ID, PCI_ANY_ID, 0, 0, NVIDIA_NFORCE},
319 {0,}
320 };
321
322 MODULE_DEVICE_TABLE (pci, i810_pci_tbl);
323
324 #ifdef CONFIG_PM
325 #define PM_SUSPENDED(card) (card->pm_suspended)
326 #else
327 #define PM_SUSPENDED(card) (0)
328 #endif
329
330 /* "software" or virtual channel, an instance of opened /dev/dsp */
331 struct i810_state {
332 unsigned int magic;
333 struct i810_card *card; /* Card info */
334
335 /* single open lock mechanism, only used for recording */
336 struct mutex open_mutex;
337 wait_queue_head_t open_wait;
338
339 /* file mode */
340 mode_t open_mode;
341
342 /* virtual channel number */
343 int virt;
344
345 #ifdef CONFIG_PM
346 unsigned int pm_saved_dac_rate,pm_saved_adc_rate;
347 #endif
348 struct dmabuf {
349 /* wave sample stuff */
350 unsigned int rate;
351 unsigned char fmt, enable, trigger;
352
353 /* hardware channel */
354 struct i810_channel *read_channel;
355 struct i810_channel *write_channel;
356
357 /* OSS buffer management stuff */
358 void *rawbuf;
359 dma_addr_t dma_handle;
360 unsigned buforder;
361 unsigned numfrag;
362 unsigned fragshift;
363
364 /* our buffer acts like a circular ring */
365 unsigned hwptr; /* where dma last started, updated by update_ptr */
366 unsigned swptr; /* where driver last clear/filled, updated by read/write */
367 int count; /* bytes to be consumed or been generated by dma machine */
368 unsigned total_bytes; /* total bytes dmaed by hardware */
369
370 unsigned error; /* number of over/underruns */
371 wait_queue_head_t wait; /* put process on wait queue when no more space in buffer */
372
373 /* redundant, but makes calculations easier */
374 /* what the hardware uses */
375 unsigned dmasize;
376 unsigned fragsize;
377 unsigned fragsamples;
378
379 /* what we tell the user to expect */
380 unsigned userfrags;
381 unsigned userfragsize;
382
383 /* OSS stuff */
384 unsigned mapped:1;
385 unsigned ready:1;
386 unsigned update_flag;
387 unsigned ossfragsize;
388 unsigned ossmaxfrags;
389 unsigned subdivision;
390 } dmabuf;
391 };
392
393
394 struct i810_card {
395 unsigned int magic;
396
397 /* We keep i810 cards in a linked list */
398 struct i810_card *next;
399
400 /* The i810 has a certain amount of cross channel interaction
401 so we use a single per card lock */
402 spinlock_t lock;
403
404 /* Control AC97 access serialization */
405 spinlock_t ac97_lock;
406
407 /* PCI device stuff */
408 struct pci_dev * pci_dev;
409 u16 pci_id;
410 u16 pci_id_internal; /* used to access card_cap[] */
411 #ifdef CONFIG_PM
412 u16 pm_suspended;
413 int pm_saved_mixer_settings[SOUND_MIXER_NRDEVICES][NR_AC97];
414 #endif
415 /* soundcore stuff */
416 int dev_audio;
417
418 /* structures for abstraction of hardware facilities, codecs, banks and channels*/
419 u16 ac97_id_map[NR_AC97];
420 struct ac97_codec *ac97_codec[NR_AC97];
421 struct i810_state *states[NR_HW_CH];
422 struct i810_channel *channel; /* 1:1 to states[] but diff. lifetime */
423 dma_addr_t chandma;
424
425 u16 ac97_features;
426 u16 ac97_status;
427 u16 channels;
428
429 /* hardware resources */
430 unsigned long ac97base;
431 unsigned long iobase;
432 u32 irq;
433
434 unsigned long ac97base_mmio_phys;
435 unsigned long iobase_mmio_phys;
436 u_int8_t __iomem *ac97base_mmio;
437 u_int8_t __iomem *iobase_mmio;
438
439 int use_mmio;
440
441 /* Function support */
442 struct i810_channel *(*alloc_pcm_channel)(struct i810_card *);
443 struct i810_channel *(*alloc_rec_pcm_channel)(struct i810_card *);
444 struct i810_channel *(*alloc_rec_mic_channel)(struct i810_card *);
445 void (*free_pcm_channel)(struct i810_card *, int chan);
446
447 /* We have a *very* long init time possibly, so use this to block */
448 /* attempts to open our devices before we are ready (stops oops'es) */
449 int initializing;
450 };
451
452 /* extract register offset from codec struct */
453 #define IO_REG_OFF(codec) (((struct i810_card *) codec->private_data)->ac97_id_map[codec->id])
454
455 #define I810_IOREAD(size, type, card, off) \
456 ({ \
457 type val; \
458 if (card->use_mmio) \
459 val=read##size(card->iobase_mmio+off); \
460 else \
461 val=in##size(card->iobase+off); \
462 val; \
463 })
464
465 #define I810_IOREADL(card, off) I810_IOREAD(l, u32, card, off)
466 #define I810_IOREADW(card, off) I810_IOREAD(w, u16, card, off)
467 #define I810_IOREADB(card, off) I810_IOREAD(b, u8, card, off)
468
469 #define I810_IOWRITE(size, val, card, off) \
470 ({ \
471 if (card->use_mmio) \
472 write##size(val, card->iobase_mmio+off); \
473 else \
474 out##size(val, card->iobase+off); \
475 })
476
477 #define I810_IOWRITEL(val, card, off) I810_IOWRITE(l, val, card, off)
478 #define I810_IOWRITEW(val, card, off) I810_IOWRITE(w, val, card, off)
479 #define I810_IOWRITEB(val, card, off) I810_IOWRITE(b, val, card, off)
480
481 #define GET_CIV(card, port) MODULOP2(I810_IOREADB((card), (port) + OFF_CIV), SG_LEN)
482 #define GET_LVI(card, port) MODULOP2(I810_IOREADB((card), (port) + OFF_LVI), SG_LEN)
483
484 /* set LVI from CIV */
485 #define CIV_TO_LVI(card, port, off) \
486 I810_IOWRITEB(MODULOP2(GET_CIV((card), (port)) + (off), SG_LEN), (card), (port) + OFF_LVI)
487
488 static struct ac97_quirk ac97_quirks[] __devinitdata = {
489 {
490 .vendor = 0x0e11,
491 .device = 0x00b8,
492 .name = "Compaq Evo D510C",
493 .type = AC97_TUNE_HP_ONLY
494 },
495 {
496 .vendor = 0x1028,
497 .device = 0x00d8,
498 .name = "Dell Precision 530", /* AD1885 */
499 .type = AC97_TUNE_HP_ONLY
500 },
501 {
502 .vendor = 0x1028,
503 .device = 0x0126,
504 .name = "Dell Optiplex GX260", /* AD1981A */
505 .type = AC97_TUNE_HP_ONLY
506 },
507 {
508 .vendor = 0x1028,
509 .device = 0x012d,
510 .name = "Dell Precision 450", /* AD1981B*/
511 .type = AC97_TUNE_HP_ONLY
512 },
513 { /* FIXME: which codec? */
514 .vendor = 0x103c,
515 .device = 0x00c3,
516 .name = "Hewlett-Packard onboard",
517 .type = AC97_TUNE_HP_ONLY
518 },
519 {
520 .vendor = 0x103c,
521 .device = 0x12f1,
522 .name = "HP xw8200", /* AD1981B*/
523 .type = AC97_TUNE_HP_ONLY
524 },
525 {
526 .vendor = 0x103c,
527 .device = 0x3008,
528 .name = "HP xw4200", /* AD1981B*/
529 .type = AC97_TUNE_HP_ONLY
530 },
531 {
532 .vendor = 0x10f1,
533 .device = 0x2665,
534 .name = "Fujitsu-Siemens Celsius", /* AD1981? */
535 .type = AC97_TUNE_HP_ONLY
536 },
537 {
538 .vendor = 0x10f1,
539 .device = 0x2885,
540 .name = "AMD64 Mobo", /* ALC650 */
541 .type = AC97_TUNE_HP_ONLY
542 },
543 {
544 .vendor = 0x110a,
545 .device = 0x0056,
546 .name = "Fujitsu-Siemens Scenic", /* AD1981? */
547 .type = AC97_TUNE_HP_ONLY
548 },
549 {
550 .vendor = 0x11d4,
551 .device = 0x5375,
552 .name = "ADI AD1985 (discrete)",
553 .type = AC97_TUNE_HP_ONLY
554 },
555 {
556 .vendor = 0x1462,
557 .device = 0x5470,
558 .name = "MSI P4 ATX 645 Ultra",
559 .type = AC97_TUNE_HP_ONLY
560 },
561 {
562 .vendor = 0x1734,
563 .device = 0x0088,
564 .name = "Fujitsu-Siemens D1522", /* AD1981 */
565 .type = AC97_TUNE_HP_ONLY
566 },
567 {
568 .vendor = 0x8086,
569 .device = 0x4856,
570 .name = "Intel D845WN (82801BA)",
571 .type = AC97_TUNE_SWAP_HP
572 },
573 {
574 .vendor = 0x8086,
575 .device = 0x4d44,
576 .name = "Intel D850EMV2", /* AD1885 */
577 .type = AC97_TUNE_HP_ONLY
578 },
579 {
580 .vendor = 0x8086,
581 .device = 0x4d56,
582 .name = "Intel ICH/AD1885",
583 .type = AC97_TUNE_HP_ONLY
584 },
585 {
586 .vendor = 0x1028,
587 .device = 0x012d,
588 .name = "Dell Precision 450", /* AD1981B*/
589 .type = AC97_TUNE_HP_ONLY
590 },
591 {
592 .vendor = 0x103c,
593 .device = 0x3008,
594 .name = "HP xw4200", /* AD1981B*/
595 .type = AC97_TUNE_HP_ONLY
596 },
597 {
598 .vendor = 0x103c,
599 .device = 0x12f1,
600 .name = "HP xw8200", /* AD1981B*/
601 .type = AC97_TUNE_HP_ONLY
602 },
603 { } /* terminator */
604 };
605
606 static struct i810_card *devs = NULL;
607
608 static int i810_open_mixdev(struct inode *inode, struct file *file);
609 static int i810_ioctl_mixdev(struct inode *inode, struct file *file,
610 unsigned int cmd, unsigned long arg);
611 static u16 i810_ac97_get(struct ac97_codec *dev, u8 reg);
612 static void i810_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
613 static u16 i810_ac97_get_mmio(struct ac97_codec *dev, u8 reg);
614 static void i810_ac97_set_mmio(struct ac97_codec *dev, u8 reg, u16 data);
615 static u16 i810_ac97_get_io(struct ac97_codec *dev, u8 reg);
616 static void i810_ac97_set_io(struct ac97_codec *dev, u8 reg, u16 data);
617
618 static struct i810_channel *i810_alloc_pcm_channel(struct i810_card *card)
619 {
620 if(card->channel[1].used==1)
621 return NULL;
622 card->channel[1].used=1;
623 return &card->channel[1];
624 }
625
626 static struct i810_channel *i810_alloc_rec_pcm_channel(struct i810_card *card)
627 {
628 if(card->channel[0].used==1)
629 return NULL;
630 card->channel[0].used=1;
631 return &card->channel[0];
632 }
633
634 static struct i810_channel *i810_alloc_rec_mic_channel(struct i810_card *card)
635 {
636 if(card->channel[2].used==1)
637 return NULL;
638 card->channel[2].used=1;
639 return &card->channel[2];
640 }
641
642 static void i810_free_pcm_channel(struct i810_card *card, int channel)
643 {
644 card->channel[channel].used=0;
645 }
646
647 static int i810_valid_spdif_rate ( struct ac97_codec *codec, int rate )
648 {
649 unsigned long id = 0L;
650
651 id = (i810_ac97_get(codec, AC97_VENDOR_ID1) << 16);
652 id |= i810_ac97_get(codec, AC97_VENDOR_ID2) & 0xffff;
653 #ifdef DEBUG
654 printk ( "i810_audio: codec = %s, codec_id = 0x%08lx\n", codec->name, id);
655 #endif
656 switch ( id ) {
657 case 0x41445361: /* AD1886 */
658 if (rate == 48000) {
659 return 1;
660 }
661 break;
662 default: /* all other codecs, until we know otherwiae */
663 if (rate == 48000 || rate == 44100 || rate == 32000) {
664 return 1;
665 }
666 break;
667 }
668 return (0);
669 }
670
671 /* i810_set_spdif_output
672 *
673 * Configure the S/PDIF output transmitter. When we turn on
674 * S/PDIF, we turn off the analog output. This may not be
675 * the right thing to do.
676 *
677 * Assumptions:
678 * The DSP sample rate must already be set to a supported
679 * S/PDIF rate (32kHz, 44.1kHz, or 48kHz) or we abort.
680 */
681 static int i810_set_spdif_output(struct i810_state *state, int slots, int rate)
682 {
683 int vol;
684 int aud_reg;
685 int r = 0;
686 struct ac97_codec *codec = state->card->ac97_codec[0];
687
688 if(!codec->codec_ops->digital) {
689 state->card->ac97_status &= ~SPDIF_ON;
690 } else {
691 if ( slots == -1 ) { /* Turn off S/PDIF */
692 codec->codec_ops->digital(codec, 0, 0, 0);
693 /* If the volume wasn't muted before we turned on S/PDIF, unmute it */
694 if ( !(state->card->ac97_status & VOL_MUTED) ) {
695 aud_reg = i810_ac97_get(codec, AC97_MASTER_VOL_STEREO);
696 i810_ac97_set(codec, AC97_MASTER_VOL_STEREO, (aud_reg & ~VOL_MUTED));
697 }
698 state->card->ac97_status &= ~(VOL_MUTED | SPDIF_ON);
699 return 0;
700 }
701
702 vol = i810_ac97_get(codec, AC97_MASTER_VOL_STEREO);
703 state->card->ac97_status = vol & VOL_MUTED;
704
705 r = codec->codec_ops->digital(codec, slots, rate, 0);
706
707 if(r)
708 state->card->ac97_status |= SPDIF_ON;
709 else
710 state->card->ac97_status &= ~SPDIF_ON;
711
712 /* Mute the analog output */
713 /* Should this only mute the PCM volume??? */
714 i810_ac97_set(codec, AC97_MASTER_VOL_STEREO, (vol | VOL_MUTED));
715 }
716 return r;
717 }
718
719 /* i810_set_dac_channels
720 *
721 * Configure the codec's multi-channel DACs
722 *
723 * The logic is backwards. Setting the bit to 1 turns off the DAC.
724 *
725 * What about the ICH? We currently configure it using the
726 * SNDCTL_DSP_CHANNELS ioctl. If we're turnning on the DAC,
727 * does that imply that we want the ICH set to support
728 * these channels?
729 *
730 * TODO:
731 * vailidate that the codec really supports these DACs
732 * before turning them on.
733 */
734 static void i810_set_dac_channels(struct i810_state *state, int channel)
735 {
736 int aud_reg;
737 struct ac97_codec *codec = state->card->ac97_codec[0];
738
739 /* No codec, no setup */
740
741 if(codec == NULL)
742 return;
743
744 aud_reg = i810_ac97_get(codec, AC97_EXTENDED_STATUS);
745 aud_reg |= AC97_EA_PRI | AC97_EA_PRJ | AC97_EA_PRK;
746 state->card->ac97_status &= ~(SURR_ON | CENTER_LFE_ON);
747
748 switch ( channel ) {
749 case 2: /* always enabled */
750 break;
751 case 4:
752 aud_reg &= ~AC97_EA_PRJ;
753 state->card->ac97_status |= SURR_ON;
754 break;
755 case 6:
756 aud_reg &= ~(AC97_EA_PRJ | AC97_EA_PRI | AC97_EA_PRK);
757 state->card->ac97_status |= SURR_ON | CENTER_LFE_ON;
758 break;
759 default:
760 break;
761 }
762 i810_ac97_set(codec, AC97_EXTENDED_STATUS, aud_reg);
763
764 }
765
766
767 /* set playback sample rate */
768 static unsigned int i810_set_dac_rate(struct i810_state * state, unsigned int rate)
769 {
770 struct dmabuf *dmabuf = &state->dmabuf;
771 u32 new_rate;
772 struct ac97_codec *codec=state->card->ac97_codec[0];
773
774 if(!(state->card->ac97_features&0x0001))
775 {
776 dmabuf->rate = clocking;
777 #ifdef DEBUG
778 printk("Asked for %d Hz, but ac97_features says we only do %dHz. Sorry!\n",
779 rate,clocking);
780 #endif
781 return clocking;
782 }
783
784 if (rate > 48000)
785 rate = 48000;
786 if (rate < 8000)
787 rate = 8000;
788 dmabuf->rate = rate;
789
790 /*
791 * Adjust for misclocked crap
792 */
793 rate = ( rate * clocking)/48000;
794 if(strict_clocking && rate < 8000) {
795 rate = 8000;
796 dmabuf->rate = (rate * 48000)/clocking;
797 }
798
799 new_rate=ac97_set_dac_rate(codec, rate);
800 if(new_rate != rate) {
801 dmabuf->rate = (new_rate * 48000)/clocking;
802 }
803 #ifdef DEBUG
804 printk("i810_audio: called i810_set_dac_rate : asked for %d, got %d\n", rate, dmabuf->rate);
805 #endif
806 rate = new_rate;
807 return dmabuf->rate;
808 }
809
810 /* set recording sample rate */
811 static unsigned int i810_set_adc_rate(struct i810_state * state, unsigned int rate)
812 {
813 struct dmabuf *dmabuf = &state->dmabuf;
814 u32 new_rate;
815 struct ac97_codec *codec=state->card->ac97_codec[0];
816
817 if(!(state->card->ac97_features&0x0001))
818 {
819 dmabuf->rate = clocking;
820 return clocking;
821 }
822
823 if (rate > 48000)
824 rate = 48000;
825 if (rate < 8000)
826 rate = 8000;
827 dmabuf->rate = rate;
828
829 /*
830 * Adjust for misclocked crap
831 */
832
833 rate = ( rate * clocking)/48000;
834 if(strict_clocking && rate < 8000) {
835 rate = 8000;
836 dmabuf->rate = (rate * 48000)/clocking;
837 }
838
839 new_rate = ac97_set_adc_rate(codec, rate);
840
841 if(new_rate != rate) {
842 dmabuf->rate = (new_rate * 48000)/clocking;
843 rate = new_rate;
844 }
845 #ifdef DEBUG
846 printk("i810_audio: called i810_set_adc_rate : rate = %d/%d\n", dmabuf->rate, rate);
847 #endif
848 return dmabuf->rate;
849 }
850
851 /* get current playback/recording dma buffer pointer (byte offset from LBA),
852 called with spinlock held! */
853
854 static inline unsigned i810_get_dma_addr(struct i810_state *state, int rec)
855 {
856 struct dmabuf *dmabuf = &state->dmabuf;
857 unsigned int civ, offset, port, port_picb, bytes = 2;
858
859 if (!dmabuf->enable)
860 return 0;
861
862 if (rec)
863 port = dmabuf->read_channel->port;
864 else
865 port = dmabuf->write_channel->port;
866
867 if(state->card->pci_id == PCI_DEVICE_ID_SI_7012) {
868 port_picb = port + OFF_SR;
869 bytes = 1;
870 } else
871 port_picb = port + OFF_PICB;
872
873 do {
874 civ = GET_CIV(state->card, port);
875 offset = I810_IOREADW(state->card, port_picb);
876 /* Must have a delay here! */
877 if(offset == 0)
878 udelay(1);
879 /* Reread both registers and make sure that that total
880 * offset from the first reading to the second is 0.
881 * There is an issue with SiS hardware where it will count
882 * picb down to 0, then update civ to the next value,
883 * then set the new picb to fragsize bytes. We can catch
884 * it between the civ update and the picb update, making
885 * it look as though we are 1 fragsize ahead of where we
886 * are. The next to we get the address though, it will
887 * be back in the right place, and we will suddenly think
888 * we just went forward dmasize - fragsize bytes, causing
889 * totally stupid *huge* dma overrun messages. We are
890 * assuming that the 1us delay is more than long enough
891 * that we won't have to worry about the chip still being
892 * out of sync with reality ;-)
893 */
894 } while (civ != GET_CIV(state->card, port) || offset != I810_IOREADW(state->card, port_picb));
895
896 return (((civ + 1) * dmabuf->fragsize - (bytes * offset))
897 % dmabuf->dmasize);
898 }
899
900 /* Stop recording (lock held) */
901 static inline void __stop_adc(struct i810_state *state)
902 {
903 struct dmabuf *dmabuf = &state->dmabuf;
904 struct i810_card *card = state->card;
905
906 dmabuf->enable &= ~ADC_RUNNING;
907 I810_IOWRITEB(0, card, PI_CR);
908 // wait for the card to acknowledge shutdown
909 while( I810_IOREADB(card, PI_CR) != 0 ) ;
910 // now clear any latent interrupt bits (like the halt bit)
911 if(card->pci_id == PCI_DEVICE_ID_SI_7012)
912 I810_IOWRITEB( I810_IOREADB(card, PI_PICB), card, PI_PICB );
913 else
914 I810_IOWRITEB( I810_IOREADB(card, PI_SR), card, PI_SR );
915 I810_IOWRITEL( I810_IOREADL(card, GLOB_STA) & INT_PI, card, GLOB_STA);
916 }
917
918 static void stop_adc(struct i810_state *state)
919 {
920 struct i810_card *card = state->card;
921 unsigned long flags;
922
923 spin_lock_irqsave(&card->lock, flags);
924 __stop_adc(state);
925 spin_unlock_irqrestore(&card->lock, flags);
926 }
927
928 static inline void __start_adc(struct i810_state *state)
929 {
930 struct dmabuf *dmabuf = &state->dmabuf;
931
932 if (dmabuf->count < dmabuf->dmasize && dmabuf->ready && !dmabuf->enable &&
933 (dmabuf->trigger & PCM_ENABLE_INPUT)) {
934 dmabuf->enable |= ADC_RUNNING;
935 // Interrupt enable, LVI enable, DMA enable
936 I810_IOWRITEB(0x10 | 0x04 | 0x01, state->card, PI_CR);
937 }
938 }
939
940 static void start_adc(struct i810_state *state)
941 {
942 struct i810_card *card = state->card;
943 unsigned long flags;
944
945 spin_lock_irqsave(&card->lock, flags);
946 __start_adc(state);
947 spin_unlock_irqrestore(&card->lock, flags);
948 }
949
950 /* stop playback (lock held) */
951 static inline void __stop_dac(struct i810_state *state)
952 {
953 struct dmabuf *dmabuf = &state->dmabuf;
954 struct i810_card *card = state->card;
955
956 dmabuf->enable &= ~DAC_RUNNING;
957 I810_IOWRITEB(0, card, PO_CR);
958 // wait for the card to acknowledge shutdown
959 while( I810_IOREADB(card, PO_CR) != 0 ) ;
960 // now clear any latent interrupt bits (like the halt bit)
961 if(card->pci_id == PCI_DEVICE_ID_SI_7012)
962 I810_IOWRITEB( I810_IOREADB(card, PO_PICB), card, PO_PICB );
963 else
964 I810_IOWRITEB( I810_IOREADB(card, PO_SR), card, PO_SR );
965 I810_IOWRITEL( I810_IOREADL(card, GLOB_STA) & INT_PO, card, GLOB_STA);
966 }
967
968 static void stop_dac(struct i810_state *state)
969 {
970 struct i810_card *card = state->card;
971 unsigned long flags;
972
973 spin_lock_irqsave(&card->lock, flags);
974 __stop_dac(state);
975 spin_unlock_irqrestore(&card->lock, flags);
976 }
977
978 static inline void __start_dac(struct i810_state *state)
979 {
980 struct dmabuf *dmabuf = &state->dmabuf;
981
982 if (dmabuf->count > 0 && dmabuf->ready && !dmabuf->enable &&
983 (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
984 dmabuf->enable |= DAC_RUNNING;
985 // Interrupt enable, LVI enable, DMA enable
986 I810_IOWRITEB(0x10 | 0x04 | 0x01, state->card, PO_CR);
987 }
988 }
989 static void start_dac(struct i810_state *state)
990 {
991 struct i810_card *card = state->card;
992 unsigned long flags;
993
994 spin_lock_irqsave(&card->lock, flags);
995 __start_dac(state);
996 spin_unlock_irqrestore(&card->lock, flags);
997 }
998
999 #define DMABUF_DEFAULTORDER (16-PAGE_SHIFT)
1000 #define DMABUF_MINORDER 1
1001
1002 /* allocate DMA buffer, playback and recording buffer should be allocated separately */
1003 static int alloc_dmabuf(struct i810_state *state)
1004 {
1005 struct dmabuf *dmabuf = &state->dmabuf;
1006 void *rawbuf= NULL;
1007 int order, size;
1008 struct page *page, *pend;
1009
1010 /* If we don't have any oss frag params, then use our default ones */
1011 if(dmabuf->ossmaxfrags == 0)
1012 dmabuf->ossmaxfrags = 4;
1013 if(dmabuf->ossfragsize == 0)
1014 dmabuf->ossfragsize = (PAGE_SIZE<<DMABUF_DEFAULTORDER)/dmabuf->ossmaxfrags;
1015 size = dmabuf->ossfragsize * dmabuf->ossmaxfrags;
1016
1017 if(dmabuf->rawbuf && (PAGE_SIZE << dmabuf->buforder) == size)
1018 return 0;
1019 /* alloc enough to satisfy the oss params */
1020 for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
1021 if ( (PAGE_SIZE<<order) > size )
1022 continue;
1023 if ((rawbuf = pci_alloc_consistent(state->card->pci_dev,
1024 PAGE_SIZE << order,
1025 &dmabuf->dma_handle)))
1026 break;
1027 }
1028 if (!rawbuf)
1029 return -ENOMEM;
1030
1031
1032 #ifdef DEBUG
1033 printk("i810_audio: allocated %ld (order = %d) bytes at %p\n",
1034 PAGE_SIZE << order, order, rawbuf);
1035 #endif
1036
1037 dmabuf->ready = dmabuf->mapped = 0;
1038 dmabuf->rawbuf = rawbuf;
1039 dmabuf->buforder = order;
1040
1041 /* now mark the pages as reserved; otherwise remap_pfn_range doesn't do what we want */
1042 pend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
1043 for (page = virt_to_page(rawbuf); page <= pend; page++)
1044 SetPageReserved(page);
1045
1046 return 0;
1047 }
1048
1049 /* free DMA buffer */
1050 static void dealloc_dmabuf(struct i810_state *state)
1051 {
1052 struct dmabuf *dmabuf = &state->dmabuf;
1053 struct page *page, *pend;
1054
1055 if (dmabuf->rawbuf) {
1056 /* undo marking the pages as reserved */
1057 pend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
1058 for (page = virt_to_page(dmabuf->rawbuf); page <= pend; page++)
1059 ClearPageReserved(page);
1060 pci_free_consistent(state->card->pci_dev, PAGE_SIZE << dmabuf->buforder,
1061 dmabuf->rawbuf, dmabuf->dma_handle);
1062 }
1063 dmabuf->rawbuf = NULL;
1064 dmabuf->mapped = dmabuf->ready = 0;
1065 }
1066
1067 static int prog_dmabuf(struct i810_state *state, unsigned rec)
1068 {
1069 struct dmabuf *dmabuf = &state->dmabuf;
1070 struct i810_channel *c;
1071 struct sg_item *sg;
1072 unsigned long flags;
1073 int ret;
1074 unsigned fragint;
1075 int i;
1076
1077 spin_lock_irqsave(&state->card->lock, flags);
1078 if(dmabuf->enable & DAC_RUNNING)
1079 __stop_dac(state);
1080 if(dmabuf->enable & ADC_RUNNING)
1081 __stop_adc(state);
1082 dmabuf->total_bytes = 0;
1083 dmabuf->count = dmabuf->error = 0;
1084 dmabuf->swptr = dmabuf->hwptr = 0;
1085 spin_unlock_irqrestore(&state->card->lock, flags);
1086
1087 /* allocate DMA buffer, let alloc_dmabuf determine if we are already
1088 * allocated well enough or if we should replace the current buffer
1089 * (assuming one is already allocated, if it isn't, then allocate it).
1090 */
1091 if ((ret = alloc_dmabuf(state)))
1092 return ret;
1093
1094 /* FIXME: figure out all this OSS fragment stuff */
1095 /* I did, it now does what it should according to the OSS API. DL */
1096 /* We may not have realloced our dmabuf, but the fragment size to
1097 * fragment number ratio may have changed, so go ahead and reprogram
1098 * things
1099 */
1100 dmabuf->dmasize = PAGE_SIZE << dmabuf->buforder;
1101 dmabuf->numfrag = SG_LEN;
1102 dmabuf->fragsize = dmabuf->dmasize/dmabuf->numfrag;
1103 dmabuf->fragsamples = dmabuf->fragsize >> 1;
1104 dmabuf->fragshift = ffs(dmabuf->fragsize) - 1;
1105 dmabuf->userfragsize = dmabuf->ossfragsize;
1106 dmabuf->userfrags = dmabuf->dmasize/dmabuf->ossfragsize;
1107
1108 memset(dmabuf->rawbuf, 0, dmabuf->dmasize);
1109
1110 if(dmabuf->ossmaxfrags == 4) {
1111 fragint = 8;
1112 } else if (dmabuf->ossmaxfrags == 8) {
1113 fragint = 4;
1114 } else if (dmabuf->ossmaxfrags == 16) {
1115 fragint = 2;
1116 } else {
1117 fragint = 1;
1118 }
1119 /*
1120 * Now set up the ring
1121 */
1122 if(dmabuf->read_channel)
1123 c = dmabuf->read_channel;
1124 else
1125 c = dmabuf->write_channel;
1126 while(c != NULL) {
1127 sg=&c->sg[0];
1128 /*
1129 * Load up 32 sg entries and take an interrupt at half
1130 * way (we might want more interrupts later..)
1131 */
1132
1133 for(i=0;i<dmabuf->numfrag;i++)
1134 {
1135 sg->busaddr=(u32)dmabuf->dma_handle+dmabuf->fragsize*i;
1136 // the card will always be doing 16bit stereo
1137 sg->control=dmabuf->fragsamples;
1138 if(state->card->pci_id == PCI_DEVICE_ID_SI_7012)
1139 sg->control <<= 1;
1140 sg->control|=CON_BUFPAD;
1141 // set us up to get IOC interrupts as often as needed to
1142 // satisfy numfrag requirements, no more
1143 if( ((i+1) % fragint) == 0) {
1144 sg->control|=CON_IOC;
1145 }
1146 sg++;
1147 }
1148 spin_lock_irqsave(&state->card->lock, flags);
1149 I810_IOWRITEB(2, state->card, c->port+OFF_CR); /* reset DMA machine */
1150 while( I810_IOREADB(state->card, c->port+OFF_CR) & 0x02 ) ;
1151 I810_IOWRITEL((u32)state->card->chandma +
1152 c->num*sizeof(struct i810_channel),
1153 state->card, c->port+OFF_BDBAR);
1154 CIV_TO_LVI(state->card, c->port, 0);
1155
1156 spin_unlock_irqrestore(&state->card->lock, flags);
1157
1158 if(c != dmabuf->write_channel)
1159 c = dmabuf->write_channel;
1160 else
1161 c = NULL;
1162 }
1163
1164 /* set the ready flag for the dma buffer */
1165 dmabuf->ready = 1;
1166
1167 #ifdef DEBUG
1168 printk("i810_audio: prog_dmabuf, sample rate = %d, format = %d,\n\tnumfrag = %d, "
1169 "fragsize = %d dmasize = %d\n",
1170 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1171 dmabuf->fragsize, dmabuf->dmasize);
1172 #endif
1173
1174 return 0;
1175 }
1176
1177 static void __i810_update_lvi(struct i810_state *state, int rec)
1178 {
1179 struct dmabuf *dmabuf = &state->dmabuf;
1180 int x, port;
1181 int trigger;
1182 int count, fragsize;
1183 void (*start)(struct i810_state *);
1184
1185 count = dmabuf->count;
1186 if (rec) {
1187 port = dmabuf->read_channel->port;
1188 trigger = PCM_ENABLE_INPUT;
1189 start = __start_adc;
1190 count = dmabuf->dmasize - count;
1191 } else {
1192 port = dmabuf->write_channel->port;
1193 trigger = PCM_ENABLE_OUTPUT;
1194 start = __start_dac;
1195 }
1196
1197 /* Do not process partial fragments. */
1198 fragsize = dmabuf->fragsize;
1199 if (count < fragsize)
1200 return;
1201
1202 /* if we are currently stopped, then our CIV is actually set to our
1203 * *last* sg segment and we are ready to wrap to the next. However,
1204 * if we set our LVI to the last sg segment, then it won't wrap to
1205 * the next sg segment, it won't even get a start. So, instead, when
1206 * we are stopped, we set both the LVI value and also we increment
1207 * the CIV value to the next sg segment to be played so that when
1208 * we call start, things will operate properly. Since the CIV can't
1209 * be written to directly for this purpose, we set the LVI to CIV + 1
1210 * temporarily. Once the engine has started we set the LVI to its
1211 * final value.
1212 */
1213 if (!dmabuf->enable && dmabuf->ready) {
1214 if (!(dmabuf->trigger & trigger))
1215 return;
1216
1217 CIV_TO_LVI(state->card, port, 1);
1218
1219 start(state);
1220 while (!(I810_IOREADB(state->card, port + OFF_CR) & ((1<<4) | (1<<2))))
1221 ;
1222 }
1223
1224 /* MASKP2(swptr, fragsize) - 1 is the tail of our transfer */
1225 x = MODULOP2(MASKP2(dmabuf->swptr, fragsize) - 1, dmabuf->dmasize);
1226 x >>= dmabuf->fragshift;
1227 I810_IOWRITEB(x, state->card, port + OFF_LVI);
1228 }
1229
1230 static void i810_update_lvi(struct i810_state *state, int rec)
1231 {
1232 struct dmabuf *dmabuf = &state->dmabuf;
1233 unsigned long flags;
1234
1235 if(!dmabuf->ready)
1236 return;
1237 spin_lock_irqsave(&state->card->lock, flags);
1238 __i810_update_lvi(state, rec);
1239 spin_unlock_irqrestore(&state->card->lock, flags);
1240 }
1241
1242 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
1243 static void i810_update_ptr(struct i810_state *state)
1244 {
1245 struct dmabuf *dmabuf = &state->dmabuf;
1246 unsigned hwptr;
1247 unsigned fragmask, dmamask;
1248 int diff;
1249
1250 fragmask = MASKP2(~0, dmabuf->fragsize);
1251 dmamask = MODULOP2(~0, dmabuf->dmasize);
1252
1253 /* error handling and process wake up for ADC */
1254 if (dmabuf->enable == ADC_RUNNING) {
1255 /* update hardware pointer */
1256 hwptr = i810_get_dma_addr(state, 1) & fragmask;
1257 diff = (hwptr - dmabuf->hwptr) & dmamask;
1258 #if defined(DEBUG_INTERRUPTS) || defined(DEBUG_MMAP)
1259 printk("ADC HWP %d,%d,%d\n", hwptr, dmabuf->hwptr, diff);
1260 #endif
1261 dmabuf->hwptr = hwptr;
1262 dmabuf->total_bytes += diff;
1263 dmabuf->count += diff;
1264 if (dmabuf->count > dmabuf->dmasize) {
1265 /* buffer underrun or buffer overrun */
1266 /* this is normal for the end of a read */
1267 /* only give an error if we went past the */
1268 /* last valid sg entry */
1269 if (GET_CIV(state->card, PI_BASE) !=
1270 GET_LVI(state->card, PI_BASE)) {
1271 printk(KERN_WARNING "i810_audio: DMA overrun on read\n");
1272 dmabuf->error++;
1273 }
1274 }
1275 if (diff)
1276 wake_up(&dmabuf->wait);
1277 }
1278 /* error handling and process wake up for DAC */
1279 if (dmabuf->enable == DAC_RUNNING) {
1280 /* update hardware pointer */
1281 hwptr = i810_get_dma_addr(state, 0) & fragmask;
1282 diff = (hwptr - dmabuf->hwptr) & dmamask;
1283 #if defined(DEBUG_INTERRUPTS) || defined(DEBUG_MMAP)
1284 printk("DAC HWP %d,%d,%d\n", hwptr, dmabuf->hwptr, diff);
1285 #endif
1286 dmabuf->hwptr = hwptr;
1287 dmabuf->total_bytes += diff;
1288 dmabuf->count -= diff;
1289 if (dmabuf->count < 0) {
1290 /* buffer underrun or buffer overrun */
1291 /* this is normal for the end of a write */
1292 /* only give an error if we went past the */
1293 /* last valid sg entry */
1294 if (GET_CIV(state->card, PO_BASE) !=
1295 GET_LVI(state->card, PO_BASE)) {
1296 printk(KERN_WARNING "i810_audio: DMA overrun on write\n");
1297 printk("i810_audio: CIV %d, LVI %d, hwptr %x, "
1298 "count %d\n",
1299 GET_CIV(state->card, PO_BASE),
1300 GET_LVI(state->card, PO_BASE),
1301 dmabuf->hwptr, dmabuf->count);
1302 dmabuf->error++;
1303 }
1304 }
1305 if (diff)
1306 wake_up(&dmabuf->wait);
1307 }
1308 }
1309
1310 static inline int i810_get_free_write_space(struct i810_state *state)
1311 {
1312 struct dmabuf *dmabuf = &state->dmabuf;
1313 int free;
1314
1315 i810_update_ptr(state);
1316 // catch underruns during playback
1317 if (dmabuf->count < 0) {
1318 dmabuf->count = 0;
1319 dmabuf->swptr = dmabuf->hwptr;
1320 }
1321 free = dmabuf->dmasize - dmabuf->count;
1322 if(free < 0)
1323 return(0);
1324 return(free);
1325 }
1326
1327 static inline int i810_get_available_read_data(struct i810_state *state)
1328 {
1329 struct dmabuf *dmabuf = &state->dmabuf;
1330 int avail;
1331
1332 i810_update_ptr(state);
1333 // catch overruns during record
1334 if (dmabuf->count > dmabuf->dmasize) {
1335 dmabuf->count = dmabuf->dmasize;
1336 dmabuf->swptr = dmabuf->hwptr;
1337 }
1338 avail = dmabuf->count;
1339 if(avail < 0)
1340 return(0);
1341 return(avail);
1342 }
1343
1344 static inline void fill_partial_frag(struct dmabuf *dmabuf)
1345 {
1346 unsigned fragsize;
1347 unsigned swptr, len;
1348
1349 fragsize = dmabuf->fragsize;
1350 swptr = dmabuf->swptr;
1351 len = fragsize - MODULOP2(dmabuf->swptr, fragsize);
1352 if (len == fragsize)
1353 return;
1354
1355 memset(dmabuf->rawbuf + swptr, '\0', len);
1356 dmabuf->swptr = MODULOP2(swptr + len, dmabuf->dmasize);
1357 dmabuf->count += len;
1358 }
1359
1360 static int drain_dac(struct i810_state *state, int signals_allowed)
1361 {
1362 DECLARE_WAITQUEUE(wait, current);
1363 struct dmabuf *dmabuf = &state->dmabuf;
1364 unsigned long flags;
1365 unsigned long tmo;
1366 int count;
1367
1368 if (!dmabuf->ready)
1369 return 0;
1370 if(dmabuf->mapped) {
1371 stop_dac(state);
1372 return 0;
1373 }
1374
1375 spin_lock_irqsave(&state->card->lock, flags);
1376
1377 fill_partial_frag(dmabuf);
1378
1379 /*
1380 * This will make sure that our LVI is correct, that our
1381 * pointer is updated, and that the DAC is running. We
1382 * have to force the setting of dmabuf->trigger to avoid
1383 * any possible deadlocks.
1384 */
1385 dmabuf->trigger = PCM_ENABLE_OUTPUT;
1386 __i810_update_lvi(state, 0);
1387
1388 spin_unlock_irqrestore(&state->card->lock, flags);
1389
1390 add_wait_queue(&dmabuf->wait, &wait);
1391 for (;;) {
1392
1393 spin_lock_irqsave(&state->card->lock, flags);
1394 i810_update_ptr(state);
1395 count = dmabuf->count;
1396
1397 /* It seems that we have to set the current state to
1398 * TASK_INTERRUPTIBLE every time to make the process
1399 * really go to sleep. This also has to be *after* the
1400 * update_ptr() call because update_ptr is likely to
1401 * do a wake_up() which will unset this before we ever
1402 * try to sleep, resuling in a tight loop in this code
1403 * instead of actually sleeping and waiting for an
1404 * interrupt to wake us up!
1405 */
1406 __set_current_state(signals_allowed ?
1407 TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
1408 spin_unlock_irqrestore(&state->card->lock, flags);
1409
1410 if (count <= 0)
1411 break;
1412
1413 if (signal_pending(current) && signals_allowed) {
1414 break;
1415 }
1416
1417 /*
1418 * set the timeout to significantly longer than it *should*
1419 * take for the DAC to drain the DMA buffer
1420 */
1421 tmo = (count * HZ) / (dmabuf->rate);
1422 if (!schedule_timeout(tmo >= 2 ? tmo : 2)){
1423 printk(KERN_ERR "i810_audio: drain_dac, dma timeout?\n");
1424 count = 0;
1425 break;
1426 }
1427 }
1428 set_current_state(TASK_RUNNING);
1429 remove_wait_queue(&dmabuf->wait, &wait);
1430 if(count > 0 && signal_pending(current) && signals_allowed)
1431 return -ERESTARTSYS;
1432 stop_dac(state);
1433 return 0;
1434 }
1435
1436 static void i810_channel_interrupt(struct i810_card *card)
1437 {
1438 int i, count;
1439
1440 #ifdef DEBUG_INTERRUPTS
1441 printk("CHANNEL ");
1442 #endif
1443 for(i=0;i<NR_HW_CH;i++)
1444 {
1445 struct i810_state *state = card->states[i];
1446 struct i810_channel *c;
1447 struct dmabuf *dmabuf;
1448 unsigned long port;
1449 u16 status;
1450
1451 if(!state)
1452 continue;
1453 if(!state->dmabuf.ready)
1454 continue;
1455 dmabuf = &state->dmabuf;
1456 if(dmabuf->enable & DAC_RUNNING) {
1457 c=dmabuf->write_channel;
1458 } else if(dmabuf->enable & ADC_RUNNING) {
1459 c=dmabuf->read_channel;
1460 } else /* This can occur going from R/W to close */
1461 continue;
1462
1463 port = c->port;
1464
1465 if(card->pci_id == PCI_DEVICE_ID_SI_7012)
1466 status = I810_IOREADW(card, port + OFF_PICB);
1467 else
1468 status = I810_IOREADW(card, port + OFF_SR);
1469
1470 #ifdef DEBUG_INTERRUPTS
1471 printk("NUM %d PORT %X IRQ ( ST%d ", c->num, c->port, status);
1472 #endif
1473 if(status & DMA_INT_COMPLETE)
1474 {
1475 /* only wake_up() waiters if this interrupt signals
1476 * us being beyond a userfragsize of data open or
1477 * available, and i810_update_ptr() does that for
1478 * us
1479 */
1480 i810_update_ptr(state);
1481 #ifdef DEBUG_INTERRUPTS
1482 printk("COMP %d ", dmabuf->hwptr /
1483 dmabuf->fragsize);
1484 #endif
1485 }
1486 if(status & (DMA_INT_LVI | DMA_INT_DCH))
1487 {
1488 /* wake_up() unconditionally on LVI and DCH */
1489 i810_update_ptr(state);
1490 wake_up(&dmabuf->wait);
1491 #ifdef DEBUG_INTERRUPTS
1492 if(status & DMA_INT_LVI)
1493 printk("LVI ");
1494 if(status & DMA_INT_DCH)
1495 printk("DCH -");
1496 #endif
1497 count = dmabuf->count;
1498 if(dmabuf->enable & ADC_RUNNING)
1499 count = dmabuf->dmasize - count;
1500 if (count >= (int)dmabuf->fragsize) {
1501 I810_IOWRITEB(I810_IOREADB(card, port+OFF_CR) | 1, card, port+OFF_CR);
1502 #ifdef DEBUG_INTERRUPTS
1503 printk(" CONTINUE ");
1504 #endif
1505 } else {
1506 if (dmabuf->enable & DAC_RUNNING)
1507 __stop_dac(state);
1508 if (dmabuf->enable & ADC_RUNNING)
1509 __stop_adc(state);
1510 dmabuf->enable = 0;
1511 #ifdef DEBUG_INTERRUPTS
1512 printk(" STOP ");
1513 #endif
1514 }
1515 }
1516 if(card->pci_id == PCI_DEVICE_ID_SI_7012)
1517 I810_IOWRITEW(status & DMA_INT_MASK, card, port + OFF_PICB);
1518 else
1519 I810_IOWRITEW(status & DMA_INT_MASK, card, port + OFF_SR);
1520 }
1521 #ifdef DEBUG_INTERRUPTS
1522 printk(")\n");
1523 #endif
1524 }
1525
1526 static irqreturn_t i810_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1527 {
1528 struct i810_card *card = (struct i810_card *)dev_id;
1529 u32 status;
1530
1531 spin_lock(&card->lock);
1532
1533 status = I810_IOREADL(card, GLOB_STA);
1534
1535 if(!(status & INT_MASK))
1536 {
1537 spin_unlock(&card->lock);
1538 return IRQ_NONE; /* not for us */
1539 }
1540
1541 if(status & (INT_PO|INT_PI|INT_MC))
1542 i810_channel_interrupt(card);
1543
1544 /* clear 'em */
1545 I810_IOWRITEL(status & INT_MASK, card, GLOB_STA);
1546 spin_unlock(&card->lock);
1547 return IRQ_HANDLED;
1548 }
1549
1550 /* in this loop, dmabuf.count signifies the amount of data that is
1551 waiting to be copied to the user's buffer. It is filled by the dma
1552 machine and drained by this loop. */
1553
1554 static ssize_t i810_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
1555 {
1556 struct i810_state *state = (struct i810_state *)file->private_data;
1557 struct i810_card *card=state ? state->card : NULL;
1558 struct dmabuf *dmabuf = &state->dmabuf;
1559 ssize_t ret;
1560 unsigned long flags;
1561 unsigned int swptr;
1562 int cnt;
1563 int pending;
1564 DECLARE_WAITQUEUE(waita, current);
1565
1566 #ifdef DEBUG2
1567 printk("i810_audio: i810_read called, count = %d\n", count);
1568 #endif
1569
1570 if (dmabuf->mapped)
1571 return -ENXIO;
1572 if (dmabuf->enable & DAC_RUNNING)
1573 return -ENODEV;
1574 if (!dmabuf->read_channel) {
1575 dmabuf->ready = 0;
1576 dmabuf->read_channel = card->alloc_rec_pcm_channel(card);
1577 if (!dmabuf->read_channel) {
1578 return -EBUSY;
1579 }
1580 }
1581 if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
1582 return ret;
1583 if (!access_ok(VERIFY_WRITE, buffer, count))
1584 return -EFAULT;
1585 ret = 0;
1586
1587 pending = 0;
1588
1589 add_wait_queue(&dmabuf->wait, &waita);
1590 while (count > 0) {
1591 set_current_state(TASK_INTERRUPTIBLE);
1592 spin_lock_irqsave(&card->lock, flags);
1593 if (PM_SUSPENDED(card)) {
1594 spin_unlock_irqrestore(&card->lock, flags);
1595 schedule();
1596 if (signal_pending(current)) {
1597 if (!ret) ret = -EAGAIN;
1598 break;
1599 }
1600 continue;
1601 }
1602 cnt = i810_get_available_read_data(state);
1603 swptr = dmabuf->swptr;
1604 // this is to make the copy_to_user simpler below
1605 if(cnt > (dmabuf->dmasize - swptr))
1606 cnt = dmabuf->dmasize - swptr;
1607 spin_unlock_irqrestore(&card->lock, flags);
1608
1609 if (cnt > count)
1610 cnt = count;
1611 if (cnt <= 0) {
1612 unsigned long tmo;
1613 /*
1614 * Don't let us deadlock. The ADC won't start if
1615 * dmabuf->trigger isn't set. A call to SETTRIGGER
1616 * could have turned it off after we set it to on
1617 * previously.
1618 */
1619 dmabuf->trigger = PCM_ENABLE_INPUT;
1620 /*
1621 * This does three things. Updates LVI to be correct,
1622 * makes sure the ADC is running, and updates the
1623 * hwptr.
1624 */
1625 i810_update_lvi(state,1);
1626 if (file->f_flags & O_NONBLOCK) {
1627 if (!ret) ret = -EAGAIN;
1628 goto done;
1629 }
1630 /* Set the timeout to how long it would take to fill
1631 * two of our buffers. If we haven't been woke up
1632 * by then, then we know something is wrong.
1633 */
1634 tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
1635 /* There are two situations when sleep_on_timeout returns, one is when
1636 the interrupt is serviced correctly and the process is waked up by
1637 ISR ON TIME. Another is when timeout is expired, which means that
1638 either interrupt is NOT serviced correctly (pending interrupt) or it
1639 is TOO LATE for the process to be scheduled to run (scheduler latency)
1640 which results in a (potential) buffer overrun. And worse, there is
1641 NOTHING we can do to prevent it. */
1642 if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1643 #ifdef DEBUG
1644 printk(KERN_ERR "i810_audio: recording schedule timeout, "
1645 "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1646 dmabuf->dmasize, dmabuf->fragsize, dmabuf->count,
1647 dmabuf->hwptr, dmabuf->swptr);
1648 #endif
1649 /* a buffer overrun, we delay the recovery until next time the
1650 while loop begin and we REALLY have space to record */
1651 }
1652 if (signal_pending(current)) {
1653 ret = ret ? ret : -ERESTARTSYS;
1654 goto done;
1655 }
1656 continue;
1657 }
1658
1659 if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
1660 if (!ret) ret = -EFAULT;
1661 goto done;
1662 }
1663
1664 swptr = MODULOP2(swptr + cnt, dmabuf->dmasize);
1665
1666 spin_lock_irqsave(&card->lock, flags);
1667
1668 if (PM_SUSPENDED(card)) {
1669 spin_unlock_irqrestore(&card->lock, flags);
1670 continue;
1671 }
1672 dmabuf->swptr = swptr;
1673 pending = dmabuf->count -= cnt;
1674 spin_unlock_irqrestore(&card->lock, flags);
1675
1676 count -= cnt;
1677 buffer += cnt;
1678 ret += cnt;
1679 }
1680 done:
1681 pending = dmabuf->dmasize - pending;
1682 if (dmabuf->enable || pending >= dmabuf->userfragsize)
1683 i810_update_lvi(state, 1);
1684 set_current_state(TASK_RUNNING);
1685 remove_wait_queue(&dmabuf->wait, &waita);
1686
1687 return ret;
1688 }
1689
1690 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
1691 the soundcard. it is drained by the dma machine and filled by this loop. */
1692 static ssize_t i810_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
1693 {
1694 struct i810_state *state = (struct i810_state *)file->private_data;
1695 struct i810_card *card=state ? state->card : NULL;
1696 struct dmabuf *dmabuf = &state->dmabuf;
1697 ssize_t ret;
1698 unsigned long flags;
1699 unsigned int swptr = 0;
1700 int pending;
1701 int cnt;
1702 DECLARE_WAITQUEUE(waita, current);
1703
1704 #ifdef DEBUG2
1705 printk("i810_audio: i810_write called, count = %d\n", count);
1706 #endif
1707
1708 if (dmabuf->mapped)
1709 return -ENXIO;
1710 if (dmabuf->enable & ADC_RUNNING)
1711 return -ENODEV;
1712 if (!dmabuf->write_channel) {
1713 dmabuf->ready = 0;
1714 dmabuf->write_channel = card->alloc_pcm_channel(card);
1715 if(!dmabuf->write_channel)
1716 return -EBUSY;
1717 }
1718 if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
1719 return ret;
1720 if (!access_ok(VERIFY_READ, buffer, count))
1721 return -EFAULT;
1722 ret = 0;
1723
1724 pending = 0;
1725
1726 add_wait_queue(&dmabuf->wait, &waita);
1727 while (count > 0) {
1728 set_current_state(TASK_INTERRUPTIBLE);
1729 spin_lock_irqsave(&state->card->lock, flags);
1730 if (PM_SUSPENDED(card)) {
1731 spin_unlock_irqrestore(&card->lock, flags);
1732 schedule();
1733 if (signal_pending(current)) {
1734 if (!ret) ret = -EAGAIN;
1735 break;
1736 }
1737 continue;
1738 }
1739
1740 cnt = i810_get_free_write_space(state);
1741 swptr = dmabuf->swptr;
1742 /* Bound the maximum size to how much we can copy to the
1743 * dma buffer before we hit the end. If we have more to
1744 * copy then it will get done in a second pass of this
1745 * loop starting from the beginning of the buffer.
1746 */
1747 if(cnt > (dmabuf->dmasize - swptr))
1748 cnt = dmabuf->dmasize - swptr;
1749 spin_unlock_irqrestore(&state->card->lock, flags);
1750
1751 #ifdef DEBUG2
1752 printk(KERN_INFO "i810_audio: i810_write: %d bytes available space\n", cnt);
1753 #endif
1754 if (cnt > count)
1755 cnt = count;
1756 if (cnt <= 0) {
1757 unsigned long tmo;
1758 // There is data waiting to be played
1759 /*
1760 * Force the trigger setting since we would
1761 * deadlock with it set any other way
1762 */
1763 dmabuf->trigger = PCM_ENABLE_OUTPUT;
1764 i810_update_lvi(state,0);
1765 if (file->f_flags & O_NONBLOCK) {
1766 if (!ret) ret = -EAGAIN;
1767 goto ret;
1768 }
1769 /* Not strictly correct but works */
1770 tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
1771 /* There are two situations when sleep_on_timeout returns, one is when
1772 the interrupt is serviced correctly and the process is waked up by
1773 ISR ON TIME. Another is when timeout is expired, which means that
1774 either interrupt is NOT serviced correctly (pending interrupt) or it
1775 is TOO LATE for the process to be scheduled to run (scheduler latency)
1776 which results in a (potential) buffer underrun. And worse, there is
1777 NOTHING we can do to prevent it. */
1778 if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1779 #ifdef DEBUG
1780 printk(KERN_ERR "i810_audio: playback schedule timeout, "
1781 "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1782 dmabuf->dmasize, dmabuf->fragsize, dmabuf->count,
1783 dmabuf->hwptr, dmabuf->swptr);
1784 #endif
1785 /* a buffer underrun, we delay the recovery until next time the
1786 while loop begin and we REALLY have data to play */
1787 //return ret;
1788 }
1789 if (signal_pending(current)) {
1790 if (!ret) ret = -ERESTARTSYS;
1791 goto ret;
1792 }
1793 continue;
1794 }
1795 if (copy_from_user(dmabuf->rawbuf+swptr,buffer,cnt)) {
1796 if (!ret) ret = -EFAULT;
1797 goto ret;
1798 }
1799
1800 swptr = MODULOP2(swptr + cnt, dmabuf->dmasize);
1801
1802 spin_lock_irqsave(&state->card->lock, flags);
1803 if (PM_SUSPENDED(card)) {
1804 spin_unlock_irqrestore(&card->lock, flags);
1805 continue;
1806 }
1807
1808 dmabuf->swptr = swptr;
1809 pending = dmabuf->count += cnt;
1810
1811 count -= cnt;
1812 buffer += cnt;
1813 ret += cnt;
1814 spin_unlock_irqrestore(&state->card->lock, flags);
1815 }
1816 ret:
1817 if (dmabuf->enable || pending >= dmabuf->userfragsize)
1818 i810_update_lvi(state, 0);
1819 set_current_state(TASK_RUNNING);
1820 remove_wait_queue(&dmabuf->wait, &waita);
1821
1822 return ret;
1823 }
1824
1825 /* No kernel lock - we have our own spinlock */
1826 static unsigned int i810_poll(struct file *file, struct poll_table_struct *wait)
1827 {
1828 struct i810_state *state = (struct i810_state *)file->private_data;
1829 struct dmabuf *dmabuf = &state->dmabuf;
1830 unsigned long flags;
1831 unsigned int mask = 0;
1832
1833 if(!dmabuf->ready)
1834 return 0;
1835 poll_wait(file, &dmabuf->wait, wait);
1836 spin_lock_irqsave(&state->card->lock, flags);
1837 if (dmabuf->enable & ADC_RUNNING ||
1838 dmabuf->trigger & PCM_ENABLE_INPUT) {
1839 if (i810_get_available_read_data(state) >=
1840 (signed)dmabuf->userfragsize)
1841 mask |= POLLIN | POLLRDNORM;
1842 }
1843 if (dmabuf->enable & DAC_RUNNING ||
1844 dmabuf->trigger & PCM_ENABLE_OUTPUT) {
1845 if (i810_get_free_write_space(state) >=
1846 (signed)dmabuf->userfragsize)
1847 mask |= POLLOUT | POLLWRNORM;
1848 }
1849 spin_unlock_irqrestore(&state->card->lock, flags);
1850 return mask;
1851 }
1852
1853 static int i810_mmap(struct file *file, struct vm_area_struct *vma)
1854 {
1855 struct i810_state *state = (struct i810_state *)file->private_data;
1856 struct dmabuf *dmabuf = &state->dmabuf;
1857 int ret = -EINVAL;
1858 unsigned long size;
1859
1860 lock_kernel();
1861 if (vma->vm_flags & VM_WRITE) {
1862 if (!dmabuf->write_channel &&
1863 (dmabuf->write_channel =
1864 state->card->alloc_pcm_channel(state->card)) == NULL) {
1865 ret = -EBUSY;
1866 goto out;
1867 }
1868 }
1869 if (vma->vm_flags & VM_READ) {
1870 if (!dmabuf->read_channel &&
1871 (dmabuf->read_channel =
1872 state->card->alloc_rec_pcm_channel(state->card)) == NULL) {
1873 ret = -EBUSY;
1874 goto out;
1875 }
1876 }
1877 if ((ret = prog_dmabuf(state, 0)) != 0)
1878 goto out;
1879
1880 ret = -EINVAL;
1881 if (vma->vm_pgoff != 0)
1882 goto out;
1883 size = vma->vm_end - vma->vm_start;
1884 if (size > (PAGE_SIZE << dmabuf->buforder))
1885 goto out;
1886 ret = -EAGAIN;
1887 if (remap_pfn_range(vma, vma->vm_start,
1888 virt_to_phys(dmabuf->rawbuf) >> PAGE_SHIFT,
1889 size, vma->vm_page_prot))
1890 goto out;
1891 dmabuf->mapped = 1;
1892 dmabuf->trigger = 0;
1893 ret = 0;
1894 #ifdef DEBUG_MMAP
1895 printk("i810_audio: mmap'ed %ld bytes of data space\n", size);
1896 #endif
1897 out:
1898 unlock_kernel();
1899 return ret;
1900 }
1901
1902 static int i810_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1903 {
1904 struct i810_state *state = (struct i810_state *)file->private_data;
1905 struct i810_channel *c = NULL;
1906 struct dmabuf *dmabuf = &state->dmabuf;
1907 unsigned long flags;
1908 audio_buf_info abinfo;
1909 count_info cinfo;
1910 unsigned int i_glob_cnt;
1911 int val = 0, ret;
1912 struct ac97_codec *codec = state->card->ac97_codec[0];
1913 void __user *argp = (void __user *)arg;
1914 int __user *p = argp;
1915
1916 #ifdef DEBUG
1917 printk("i810_audio: i810_ioctl, arg=0x%x, cmd=", arg ? *p : 0);
1918 #endif
1919
1920 switch (cmd)
1921 {
1922 case OSS_GETVERSION:
1923 #ifdef DEBUG
1924 printk("OSS_GETVERSION\n");
1925 #endif
1926 return put_user(SOUND_VERSION, p);
1927
1928 case SNDCTL_DSP_RESET:
1929 #ifdef DEBUG
1930 printk("SNDCTL_DSP_RESET\n");
1931 #endif
1932 spin_lock_irqsave(&state->card->lock, flags);
1933 if (dmabuf->enable == DAC_RUNNING) {
1934 c = dmabuf->write_channel;
1935 __stop_dac(state);
1936 }
1937 if (dmabuf->enable == ADC_RUNNING) {
1938 c = dmabuf->read_channel;
1939 __stop_adc(state);
1940 }
1941 if (c != NULL) {
1942 I810_IOWRITEB(2, state->card, c->port+OFF_CR); /* reset DMA machine */
1943 while ( I810_IOREADB(state->card, c->port+OFF_CR) & 2 )
1944 cpu_relax();
1945 I810_IOWRITEL((u32)state->card->chandma +
1946 c->num*sizeof(struct i810_channel),
1947 state->card, c->port+OFF_BDBAR);
1948 CIV_TO_LVI(state->card, c->port, 0);
1949 }
1950
1951 spin_unlock_irqrestore(&state->card->lock, flags);
1952 synchronize_irq(state->card->pci_dev->irq);
1953 dmabuf->ready = 0;
1954 dmabuf->swptr = dmabuf->hwptr = 0;
1955 dmabuf->count = dmabuf->total_bytes = 0;
1956 return 0;
1957
1958 case SNDCTL_DSP_SYNC:
1959 #ifdef DEBUG
1960 printk("SNDCTL_DSP_SYNC\n");
1961 #endif
1962 if (dmabuf->enable != DAC_RUNNING || file->f_flags & O_NONBLOCK)
1963 return 0;
1964 if((val = drain_dac(state, 1)))
1965 return val;
1966 dmabuf->total_bytes = 0;
1967 return 0;
1968
1969 case SNDCTL_DSP_SPEED: /* set smaple rate */
1970 #ifdef DEBUG
1971 printk("SNDCTL_DSP_SPEED\n");
1972 #endif
1973 if (get_user(val, p))
1974 return -EFAULT;
1975 if (val >= 0) {
1976 if (file->f_mode & FMODE_WRITE) {
1977 if ( (state->card->ac97_status & SPDIF_ON) ) { /* S/PDIF Enabled */
1978 /* AD1886 only supports 48000, need to check that */
1979 if ( i810_valid_spdif_rate ( codec, val ) ) {
1980 /* Set DAC rate */
1981 i810_set_spdif_output ( state, -1, 0 );
1982 stop_dac(state);
1983 dmabuf->ready = 0;
1984 spin_lock_irqsave(&state->card->lock, flags);
1985 i810_set_dac_rate(state, val);
1986 spin_unlock_irqrestore(&state->card->lock, flags);
1987 /* Set S/PDIF transmitter rate. */
1988 i810_set_spdif_output ( state, AC97_EA_SPSA_3_4, val );
1989 if ( ! (state->card->ac97_status & SPDIF_ON) ) {
1990 val = dmabuf->rate;
1991 }
1992 } else { /* Not a valid rate for S/PDIF, ignore it */
1993 val = dmabuf->rate;
1994 }
1995 } else {
1996 stop_dac(state);
1997 dmabuf->ready = 0;
1998 spin_lock_irqsave(&state->card->lock, flags);
1999 i810_set_dac_rate(state, val);
2000 spin_unlock_irqrestore(&state->card->lock, flags);
2001 }
2002 }
2003 if (file->f_mode & FMODE_READ) {
2004 stop_adc(state);
2005 dmabuf->ready = 0;
2006 spin_lock_irqsave(&state->card->lock, flags);
2007 i810_set_adc_rate(state, val);
2008 spin_unlock_irqrestore(&state->card->lock, flags);
2009 }
2010 }
2011 return put_user(dmabuf->rate, p);
2012
2013 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2014 #ifdef DEBUG
2015 printk("SNDCTL_DSP_STEREO\n");
2016 #endif
2017 if (dmabuf->enable & DAC_RUNNING) {
2018 stop_dac(state);
2019 }
2020 if (dmabuf->enable & ADC_RUNNING) {
2021 stop_adc(state);
2022 }
2023 return put_user(1, p);
2024
2025 case SNDCTL_DSP_GETBLKSIZE:
2026 if (file->f_mode & FMODE_WRITE) {
2027 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)))
2028 return val;
2029 }
2030 if (file->f_mode & FMODE_READ) {
2031 if (!dmabuf->ready && (val = prog_dmabuf(state, 1)))
2032 return val;
2033 }
2034 #ifdef DEBUG
2035 printk("SNDCTL_DSP_GETBLKSIZE %d\n", dmabuf->userfragsize);
2036 #endif
2037 return put_user(dmabuf->userfragsize, p);
2038
2039 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
2040 #ifdef DEBUG
2041 printk("SNDCTL_DSP_GETFMTS\n");
2042 #endif
2043 return put_user(AFMT_S16_LE, p);
2044
2045 case SNDCTL_DSP_SETFMT: /* Select sample format */
2046 #ifdef DEBUG
2047 printk("SNDCTL_DSP_SETFMT\n");
2048 #endif
2049 return put_user(AFMT_S16_LE, p);
2050
2051 case SNDCTL_DSP_CHANNELS:
2052 #ifdef DEBUG
2053 printk("SNDCTL_DSP_CHANNELS\n");
2054 #endif
2055 if (get_user(val, p))
2056 return -EFAULT;
2057
2058 if (val > 0) {
2059 if (dmabuf->enable & DAC_RUNNING) {
2060 stop_dac(state);
2061 }
2062 if (dmabuf->enable & ADC_RUNNING) {
2063 stop_adc(state);
2064 }
2065 } else {
2066 return put_user(state->card->channels, p);
2067 }
2068
2069 /* ICH and ICH0 only support 2 channels */
2070 if ( state->card->pci_id == PCI_DEVICE_ID_INTEL_82801AA_5
2071 || state->card->pci_id == PCI_DEVICE_ID_INTEL_82801AB_5)
2072 return put_user(2, p);
2073
2074 /* Multi-channel support was added with ICH2. Bits in */
2075 /* Global Status and Global Control register are now */
2076 /* used to indicate this. */
2077
2078 i_glob_cnt = I810_IOREADL(state->card, GLOB_CNT);
2079
2080 /* Current # of channels enabled */
2081 if ( i_glob_cnt & 0x0100000 )
2082 ret = 4;
2083 else if ( i_glob_cnt & 0x0200000 )
2084 ret = 6;
2085 else
2086 ret = 2;
2087
2088 switch ( val ) {
2089 case 2: /* 2 channels is always supported */
2090 I810_IOWRITEL(i_glob_cnt & 0xffcfffff,
2091 state->card, GLOB_CNT);
2092 /* Do we need to change mixer settings???? */
2093 break;
2094 case 4: /* Supported on some chipsets, better check first */
2095 if ( state->card->channels >= 4 ) {
2096 I810_IOWRITEL((i_glob_cnt & 0xffcfffff) | 0x100000,
2097 state->card, GLOB_CNT);
2098 /* Do we need to change mixer settings??? */
2099 } else {
2100 val = ret;
2101 }
2102 break;
2103 case 6: /* Supported on some chipsets, better check first */
2104 if ( state->card->channels >= 6 ) {
2105 I810_IOWRITEL((i_glob_cnt & 0xffcfffff) | 0x200000,
2106 state->card, GLOB_CNT);
2107 /* Do we need to change mixer settings??? */
2108 } else {
2109 val = ret;
2110 }
2111 break;
2112 default: /* nothing else is ever supported by the chipset */
2113 val = ret;
2114 break;
2115 }
2116
2117 return put_user(val, p);
2118
2119 case SNDCTL_DSP_POST: /* the user has sent all data and is notifying us */
2120 /* we update the swptr to the end of the last sg segment then return */
2121 #ifdef DEBUG
2122 printk("SNDCTL_DSP_POST\n");
2123 #endif
2124 if(!dmabuf->ready || (dmabuf->enable != DAC_RUNNING))
2125 return 0;
2126 if((dmabuf->swptr % dmabuf->fragsize) != 0) {
2127 val = dmabuf->fragsize - (dmabuf->swptr % dmabuf->fragsize);
2128 dmabuf->swptr += val;
2129 dmabuf->count += val;
2130 }
2131 return 0;
2132
2133 case SNDCTL_DSP_SUBDIVIDE:
2134 if (dmabuf->subdivision)
2135 return -EINVAL;
2136 if (get_user(val, p))
2137 return -EFAULT;
2138 if (val != 1 && val != 2 && val != 4)
2139 return -EINVAL;
2140 #ifdef DEBUG
2141 printk("SNDCTL_DSP_SUBDIVIDE %d\n", val);
2142 #endif
2143 dmabuf->subdivision = val;
2144 dmabuf->ready = 0;
2145 return 0;
2146
2147 case SNDCTL_DSP_SETFRAGMENT:
2148 if (get_user(val, p))
2149 return -EFAULT;
2150
2151 dmabuf->ossfragsize = 1<<(val & 0xffff);
2152 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2153 if (!dmabuf->ossfragsize || !dmabuf->ossmaxfrags)
2154 return -EINVAL;
2155 /*
2156 * Bound the frag size into our allowed range of 256 - 4096
2157 */
2158 if (dmabuf->ossfragsize < 256)
2159 dmabuf->ossfragsize = 256;
2160 else if (dmabuf->ossfragsize > 4096)
2161 dmabuf->ossfragsize = 4096;
2162 /*
2163 * The numfrags could be something reasonable, or it could
2164 * be 0xffff meaning "Give me as much as possible". So,
2165 * we check the numfrags * fragsize doesn't exceed our
2166 * 64k buffer limit, nor is it less than our 8k minimum.
2167 * If it fails either one of these checks, then adjust the
2168 * number of fragments, not the size of them. It's OK if
2169 * our number of fragments doesn't equal 32 or anything
2170 * like our hardware based number now since we are using
2171 * a different frag count for the hardware. Before we get
2172 * into this though, bound the maxfrags to avoid overflow
2173 * issues. A reasonable bound would be 64k / 256 since our
2174 * maximum buffer size is 64k and our minimum frag size is
2175 * 256. On the other end, our minimum buffer size is 8k and
2176 * our maximum frag size is 4k, so the lower bound should
2177 * be 2.
2178 */
2179
2180 if(dmabuf->ossmaxfrags > 256)
2181 dmabuf->ossmaxfrags = 256;
2182 else if (dmabuf->ossmaxfrags < 2)
2183 dmabuf->ossmaxfrags = 2;
2184
2185 val = dmabuf->ossfragsize * dmabuf->ossmaxfrags;
2186 while (val < 8192) {
2187 val <<= 1;
2188 dmabuf->ossmaxfrags <<= 1;
2189 }
2190 while (val > 65536) {
2191 val >>= 1;
2192 dmabuf->ossmaxfrags >>= 1;
2193 }
2194 dmabuf->ready = 0;
2195 #ifdef DEBUG
2196 printk("SNDCTL_DSP_SETFRAGMENT 0x%x, %d, %d\n", val,
2197 dmabuf->ossfragsize, dmabuf->ossmaxfrags);
2198 #endif
2199
2200 return 0;
2201
2202 case SNDCTL_DSP_GETOSPACE:
2203 if (!(file->f_mode & FMODE_WRITE))
2204 return -EINVAL;
2205 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2206 return val;
2207 spin_lock_irqsave(&state->card->lock, flags);
2208 i810_update_ptr(state);
2209 abinfo.fragsize = dmabuf->userfragsize;
2210 abinfo.fragstotal = dmabuf->userfrags;
2211 if (dmabuf->mapped)
2212 abinfo.bytes = dmabuf->dmasize;
2213 else
2214 abinfo.bytes = i810_get_free_write_space(state);
2215 abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
2216 spin_unlock_irqrestore(&state->card->lock, flags);
2217 #if defined(DEBUG) || defined(DEBUG_MMAP)
2218 printk("SNDCTL_DSP_GETOSPACE %d, %d, %d, %d\n", abinfo.bytes,
2219 abinfo.fragsize, abinfo.fragments, abinfo.fragstotal);
2220 #endif
2221 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2222
2223 case SNDCTL_DSP_GETOPTR:
2224 if (!(file->f_mode & FMODE_WRITE))
2225 return -EINVAL;
2226 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2227 return val;
2228 spin_lock_irqsave(&state->card->lock, flags);
2229 val = i810_get_free_write_space(state);
2230 cinfo.bytes = dmabuf->total_bytes;
2231 cinfo.ptr = dmabuf->hwptr;
2232 cinfo.blocks = val/dmabuf->userfragsize;
2233 if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
2234 dmabuf->count += val;
2235 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2236 __i810_update_lvi(state, 0);
2237 }
2238 spin_unlock_irqrestore(&state->card->lock, flags);
2239 #if defined(DEBUG) || defined(DEBUG_MMAP)
2240 printk("SNDCTL_DSP_GETOPTR %d, %d, %d, %d\n", cinfo.bytes,
2241 cinfo.blocks, cinfo.ptr, dmabuf->count);
2242 #endif
2243 return copy_to_user(argp, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
2244
2245 case SNDCTL_DSP_GETISPACE:
2246 if (!(file->f_mode & FMODE_READ))
2247 return -EINVAL;
2248 if (!dmabuf->ready && (val = prog_dmabuf(state, 1)) != 0)
2249 return val;
2250 spin_lock_irqsave(&state->card->lock, flags);
2251 abinfo.bytes = i810_get_available_read_data(state);
2252 abinfo.fragsize = dmabuf->userfragsize;
2253 abinfo.fragstotal = dmabuf->userfrags;
2254 abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
2255 spin_unlock_irqrestore(&state->card->lock, flags);
2256 #if defined(DEBUG) || defined(DEBUG_MMAP)
2257 printk("SNDCTL_DSP_GETISPACE %d, %d, %d, %d\n", abinfo.bytes,
2258 abinfo.fragsize, abinfo.fragments, abinfo.fragstotal);
2259 #endif
2260 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2261
2262 case SNDCTL_DSP_GETIPTR:
2263 if (!(file->f_mode & FMODE_READ))
2264 return -EINVAL;
2265 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2266 return val;
2267 spin_lock_irqsave(&state->card->lock, flags);
2268 val = i810_get_available_read_data(state);
2269 cinfo.bytes = dmabuf->total_bytes;
2270 cinfo.blocks = val/dmabuf->userfragsize;
2271 cinfo.ptr = dmabuf->hwptr;
2272 if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
2273 dmabuf->count -= val;
2274 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2275 __i810_update_lvi(state, 1);
2276 }
2277 spin_unlock_irqrestore(&state->card->lock, flags);
2278 #if defined(DEBUG) || defined(DEBUG_MMAP)
2279 printk("SNDCTL_DSP_GETIPTR %d, %d, %d, %d\n", cinfo.bytes,
2280 cinfo.blocks, cinfo.ptr, dmabuf->count);
2281 #endif
2282 return copy_to_user(argp, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
2283
2284 case SNDCTL_DSP_NONBLOCK:
2285 #ifdef DEBUG
2286 printk("SNDCTL_DSP_NONBLOCK\n");
2287 #endif
2288 file->f_flags |= O_NONBLOCK;
2289 return 0;
2290
2291 case SNDCTL_DSP_GETCAPS:
2292 #ifdef DEBUG
2293 printk("SNDCTL_DSP_GETCAPS\n");
2294 #endif
2295 return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP|DSP_CAP_BIND,
2296 p);
2297
2298 case SNDCTL_DSP_GETTRIGGER:
2299 val = 0;
2300 #ifdef DEBUG
2301 printk("SNDCTL_DSP_GETTRIGGER 0x%x\n", dmabuf->trigger);
2302 #endif
2303 return put_user(dmabuf->trigger, p);
2304
2305 case SNDCTL_DSP_SETTRIGGER:
2306 if (get_user(val, p))
2307 return -EFAULT;
2308 #if defined(DEBUG) || defined(DEBUG_MMAP)
2309 printk("SNDCTL_DSP_SETTRIGGER 0x%x\n", val);
2310 #endif
2311 /* silently ignore invalid PCM_ENABLE_xxx bits,
2312 * like the other drivers do
2313 */
2314 if (!(file->f_mode & FMODE_READ ))
2315 val &= ~PCM_ENABLE_INPUT;
2316 if (!(file->f_mode & FMODE_WRITE ))
2317 val &= ~PCM_ENABLE_OUTPUT;
2318 if((file->f_mode & FMODE_READ) && !(val & PCM_ENABLE_INPUT) && dmabuf->enable == ADC_RUNNING) {
2319 stop_adc(state);
2320 }
2321 if((file->f_mode & FMODE_WRITE) && !(val & PCM_ENABLE_OUTPUT) && dmabuf->enable == DAC_RUNNING) {
2322 stop_dac(state);
2323 }
2324 dmabuf->trigger = val;
2325 if((val & PCM_ENABLE_OUTPUT) && !(dmabuf->enable & DAC_RUNNING)) {
2326 if (!dmabuf->write_channel) {
2327 dmabuf->ready = 0;
2328 dmabuf->write_channel = state->card->alloc_pcm_channel(state->card);
2329 if (!dmabuf->write_channel)
2330 return -EBUSY;
2331 }
2332 if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
2333 return ret;
2334 if (dmabuf->mapped) {
2335 spin_lock_irqsave(&state->card->lock, flags);
2336 i810_update_ptr(state);
2337 dmabuf->count = 0;
2338 dmabuf->swptr = dmabuf->hwptr;
2339 dmabuf->count = i810_get_free_write_space(state);
2340 dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
2341 spin_unlock_irqrestore(&state->card->lock, flags);
2342 }
2343 i810_update_lvi(state, 0);
2344 start_dac(state);
2345 }
2346 if((val & PCM_ENABLE_INPUT) && !(dmabuf->enable & ADC_RUNNING)) {
2347 if (!dmabuf->read_channel) {
2348 dmabuf->ready = 0;
2349 dmabuf->read_channel = state->card->alloc_rec_pcm_channel(state->card);
2350 if (!dmabuf->read_channel)
2351 return -EBUSY;
2352 }
2353 if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
2354 return ret;
2355 if (dmabuf->mapped) {
2356 spin_lock_irqsave(&state->card->lock, flags);
2357 i810_update_ptr(state);
2358 dmabuf->swptr = dmabuf->hwptr;
2359 dmabuf->count = 0;
2360 spin_unlock_irqrestore(&state->card->lock, flags);
2361 }
2362 i810_update_lvi(state, 1);
2363 start_adc(state);
2364 }
2365 return 0;
2366
2367 case SNDCTL_DSP_SETDUPLEX:
2368 #ifdef DEBUG
2369 printk("SNDCTL_DSP_SETDUPLEX\n");
2370 #endif
2371 return -EINVAL;
2372
2373 case SNDCTL_DSP_GETODELAY:
2374 if (!(file->f_mode & FMODE_WRITE))
2375 return -EINVAL;
2376 spin_lock_irqsave(&state->card->lock, flags);
2377 i810_update_ptr(state);
2378 val = dmabuf->count;
2379 spin_unlock_irqrestore(&state->card->lock, flags);
2380 #ifdef DEBUG
2381 printk("SNDCTL_DSP_GETODELAY %d\n", dmabuf->count);
2382 #endif
2383 return put_user(val, p);
2384
2385 case SOUND_PCM_READ_RATE:
2386 #ifdef DEBUG
2387 printk("SOUND_PCM_READ_RATE %d\n", dmabuf->rate);
2388 #endif
2389 return put_user(dmabuf->rate, p);
2390
2391 case SOUND_PCM_READ_CHANNELS:
2392 #ifdef DEBUG
2393 printk("SOUND_PCM_READ_CHANNELS\n");
2394 #endif
2395 return put_user(2, p);
2396
2397 case SOUND_PCM_READ_BITS:
2398 #ifdef DEBUG
2399 printk("SOUND_PCM_READ_BITS\n");
2400 #endif
2401 return put_user(AFMT_S16_LE, p);
2402
2403 case SNDCTL_DSP_SETSPDIF: /* Set S/PDIF Control register */
2404 #ifdef DEBUG
2405 printk("SNDCTL_DSP_SETSPDIF\n");
2406 #endif
2407 if (get_user(val, p))
2408 return -EFAULT;
2409
2410 /* Check to make sure the codec supports S/PDIF transmitter */
2411
2412 if((state->card->ac97_features & 4)) {
2413 /* mask out the transmitter speed bits so the user can't set them */
2414 val &= ~0x3000;
2415
2416 /* Add the current transmitter speed bits to the passed value */
2417 ret = i810_ac97_get(codec, AC97_SPDIF_CONTROL);
2418 val |= (ret & 0x3000);
2419
2420 i810_ac97_set(codec, AC97_SPDIF_CONTROL, val);
2421 if(i810_ac97_get(codec, AC97_SPDIF_CONTROL) != val ) {
2422 printk(KERN_ERR "i810_audio: Unable to set S/PDIF configuration to 0x%04x.\n", val);
2423 return -EFAULT;
2424 }
2425 }
2426 #ifdef DEBUG
2427 else
2428 printk(KERN_WARNING "i810_audio: S/PDIF transmitter not avalible.\n");
2429 #endif
2430 return put_user(val, p);
2431
2432 case SNDCTL_DSP_GETSPDIF: /* Get S/PDIF Control register */
2433 #ifdef DEBUG
2434 printk("SNDCTL_DSP_GETSPDIF\n");
2435 #endif
2436 if (get_user(val, p))
2437 return -EFAULT;
2438
2439 /* Check to make sure the codec supports S/PDIF transmitter */
2440
2441 if(!(state->card->ac97_features & 4)) {
2442 #ifdef DEBUG
2443 printk(KERN_WARNING "i810_audio: S/PDIF transmitter not avalible.\n");
2444 #endif
2445 val = 0;
2446 } else {
2447 val = i810_ac97_get(codec, AC97_SPDIF_CONTROL);
2448 }
2449 //return put_user((val & 0xcfff), p);
2450 return put_user(val, p);
2451
2452 case SNDCTL_DSP_GETCHANNELMASK:
2453 #ifdef DEBUG
2454 printk("SNDCTL_DSP_GETCHANNELMASK\n");
2455 #endif
2456 if (get_user(val, p))
2457 return -EFAULT;
2458
2459 /* Based on AC'97 DAC support, not ICH hardware */
2460 val = DSP_BIND_FRONT;
2461 if ( state->card->ac97_features & 0x0004 )
2462 val |= DSP_BIND_SPDIF;
2463
2464 if ( state->card->ac97_features & 0x0080 )
2465 val |= DSP_BIND_SURR;
2466 if ( state->card->ac97_features & 0x0140 )
2467 val |= DSP_BIND_CENTER_LFE;
2468
2469 return put_user(val, p);
2470
2471 case SNDCTL_DSP_BIND_CHANNEL:
2472 #ifdef DEBUG
2473 printk("SNDCTL_DSP_BIND_CHANNEL\n");
2474 #endif
2475 if (get_user(val, p))
2476 return -EFAULT;
2477 if ( val == DSP_BIND_QUERY ) {
2478 val = DSP_BIND_FRONT; /* Always report this as being enabled */
2479 if ( state->card->ac97_status & SPDIF_ON )
2480 val |= DSP_BIND_SPDIF;
2481 else {
2482 if ( state->card->ac97_status & SURR_ON )
2483 val |= DSP_BIND_SURR;
2484 if ( state->card->ac97_status & CENTER_LFE_ON )
2485 val |= DSP_BIND_CENTER_LFE;
2486 }
2487 } else { /* Not a query, set it */
2488 if (!(file->f_mode & FMODE_WRITE))
2489 return -EINVAL;
2490 if ( dmabuf->enable == DAC_RUNNING ) {
2491 stop_dac(state);
2492 }
2493 if ( val & DSP_BIND_SPDIF ) { /* Turn on SPDIF */
2494 /* Ok, this should probably define what slots
2495 * to use. For now, we'll only set it to the
2496 * defaults:
2497 *
2498 * non multichannel codec maps to slots 3&4
2499 * 2 channel codec maps to slots 7&8
2500 * 4 channel codec maps to slots 6&9
2501 * 6 channel codec maps to slots 10&11
2502 *
2503 * there should be some way for the app to
2504 * select the slot assignment.
2505 */
2506
2507 i810_set_spdif_output ( state, AC97_EA_SPSA_3_4, dmabuf->rate );
2508 if ( !(state->card->ac97_status & SPDIF_ON) )
2509 val &= ~DSP_BIND_SPDIF;
2510 } else {
2511 int mask;
2512 int channels;
2513
2514 /* Turn off S/PDIF if it was on */
2515 if ( state->card->ac97_status & SPDIF_ON )
2516 i810_set_spdif_output ( state, -1, 0 );
2517
2518 mask = val & (DSP_BIND_FRONT | DSP_BIND_SURR | DSP_BIND_CENTER_LFE);
2519 switch (mask) {
2520 case DSP_BIND_FRONT:
2521 channels = 2;
2522 break;
2523 case DSP_BIND_FRONT|DSP_BIND_SURR:
2524 channels = 4;
2525 break;
2526 case DSP_BIND_FRONT|DSP_BIND_SURR|DSP_BIND_CENTER_LFE:
2527 channels = 6;
2528 break;
2529 default:
2530 val = DSP_BIND_FRONT;
2531 channels = 2;
2532 break;
2533 }
2534 i810_set_dac_channels ( state, channels );
2535
2536 /* check that they really got turned on */
2537 if (!(state->card->ac97_status & SURR_ON))
2538 val &= ~DSP_BIND_SURR;
2539 if (!(state->card->ac97_status & CENTER_LFE_ON))
2540 val &= ~DSP_BIND_CENTER_LFE;
2541 }
2542 }
2543 return put_user(val, p);
2544
2545 case SNDCTL_DSP_MAPINBUF:
2546 case SNDCTL_DSP_MAPOUTBUF:
2547 case SNDCTL_DSP_SETSYNCRO:
2548 case SOUND_PCM_WRITE_FILTER:
2549 case SOUND_PCM_READ_FILTER:
2550 #ifdef DEBUG
2551 printk("SNDCTL_* -EINVAL\n");
2552 #endif
2553 return -EINVAL;
2554 }
2555 return -EINVAL;
2556 }
2557
2558 static int i810_open(struct inode *inode, struct file *file)
2559 {
2560 int i = 0;
2561 struct i810_card *card = devs;
2562 struct i810_state *state = NULL;
2563 struct dmabuf *dmabuf = NULL;
2564
2565 /* find an avaiable virtual channel (instance of /dev/dsp) */
2566 while (card != NULL) {
2567 /*
2568 * If we are initializing and then fail, card could go
2569 * away unuexpectedly while we are in the for() loop.
2570 * So, check for card on each iteration before we check
2571 * for card->initializing to avoid a possible oops.
2572 * This usually only matters for times when the driver is
2573 * autoloaded by kmod.
2574 */
2575 for (i = 0; i < 50 && card && card->initializing; i++) {
2576 set_current_state(TASK_UNINTERRUPTIBLE);
2577 schedule_timeout(HZ/20);
2578 }
2579 for (i = 0; i < NR_HW_CH && card && !card->initializing; i++) {
2580 if (card->states[i] == NULL) {
2581 state = card->states[i] = (struct i810_state *)
2582 kmalloc(sizeof(struct i810_state), GFP_KERNEL);
2583 if (state == NULL)
2584 return -ENOMEM;
2585 memset(state, 0, sizeof(struct i810_state));
2586 dmabuf = &state->dmabuf;
2587 goto found_virt;
2588 }
2589 }
2590 card = card->next;
2591 }
2592 /* no more virtual channel avaiable */
2593 if (!state)
2594 return -ENODEV;
2595
2596 found_virt:
2597 /* initialize the virtual channel */
2598 state->virt = i;
2599 state->card = card;
2600 state->magic = I810_STATE_MAGIC;
2601 init_waitqueue_head(&dmabuf->wait);
2602 mutex_init(&state->open_mutex);
2603 file->private_data = state;
2604 dmabuf->trigger = 0;
2605
2606 /* allocate hardware channels */
2607 if(file->f_mode & FMODE_READ) {
2608 if((dmabuf->read_channel = card->alloc_rec_pcm_channel(card)) == NULL) {
2609 kfree (card->states[i]);
2610 card->states[i] = NULL;
2611 return -EBUSY;
2612 }
2613 dmabuf->trigger |= PCM_ENABLE_INPUT;
2614 i810_set_adc_rate(state, 8000);
2615 }
2616 if(file->f_mode & FMODE_WRITE) {
2617 if((dmabuf->write_channel = card->alloc_pcm_channel(card)) == NULL) {
2618 /* make sure we free the record channel allocated above */
2619 if(file->f_mode & FMODE_READ)
2620 card->free_pcm_channel(card,dmabuf->read_channel->num);
2621 kfree (card->states[i]);
2622 card->states[i] = NULL;
2623 return -EBUSY;
2624 }
2625 /* Initialize to 8kHz? What if we don't support 8kHz? */
2626 /* Let's change this to check for S/PDIF stuff */
2627
2628 dmabuf->trigger |= PCM_ENABLE_OUTPUT;
2629 if ( spdif_locked ) {
2630 i810_set_dac_rate(state, spdif_locked);
2631 i810_set_spdif_output(state, AC97_EA_SPSA_3_4, spdif_locked);
2632 } else {
2633 i810_set_dac_rate(state, 8000);
2634 /* Put the ACLink in 2 channel mode by default */
2635 i = I810_IOREADL(card, GLOB_CNT);
2636 I810_IOWRITEL(i & 0xffcfffff, card, GLOB_CNT);
2637 }
2638 }
2639
2640 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
2641 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
2642 /dev/dspW will accept 16-bits sample, but we don't support those so we
2643 set it immediately to stereo and 16bit, which is all we do support */
2644 dmabuf->fmt |= I810_FMT_16BIT | I810_FMT_STEREO;
2645 dmabuf->ossfragsize = 0;
2646 dmabuf->ossmaxfrags = 0;
2647 dmabuf->subdivision = 0;
2648
2649 state->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2650
2651 return nonseekable_open(inode, file);
2652 }
2653
2654 static int i810_release(struct inode *inode, struct file *file)
2655 {
2656 struct i810_state *state = (struct i810_state *)file->private_data;
2657 struct i810_card *card = state->card;
2658 struct dmabuf *dmabuf = &state->dmabuf;
2659 unsigned long flags;
2660
2661 lock_kernel();
2662
2663 /* stop DMA state machine and free DMA buffers/channels */
2664 if(dmabuf->trigger & PCM_ENABLE_OUTPUT) {
2665 drain_dac(state, 0);
2666 }
2667 if(dmabuf->trigger & PCM_ENABLE_INPUT) {
2668 stop_adc(state);
2669 }
2670 spin_lock_irqsave(&card->lock, flags);
2671 dealloc_dmabuf(state);
2672 if (file->f_mode & FMODE_WRITE) {
2673 state->card->free_pcm_channel(state->card, dmabuf->write_channel->num);
2674 }
2675 if (file->f_mode & FMODE_READ) {
2676 state->card->free_pcm_channel(state->card, dmabuf->read_channel->num);
2677 }
2678
2679 state->card->states[state->virt] = NULL;
2680 kfree(state);
2681 spin_unlock_irqrestore(&card->lock, flags);
2682 unlock_kernel();
2683
2684 return 0;
2685 }
2686
2687 static /*const*/ struct file_operations i810_audio_fops = {
2688 .owner = THIS_MODULE,
2689 .llseek = no_llseek,
2690 .read = i810_read,
2691 .write = i810_write,
2692 .poll = i810_poll,
2693 .ioctl = i810_ioctl,
2694 .mmap = i810_mmap,
2695 .open = i810_open,
2696 .release = i810_release,
2697 };
2698
2699 /* Write AC97 codec registers */
2700
2701 static u16 i810_ac97_get_mmio(struct ac97_codec *dev, u8 reg)
2702 {
2703 struct i810_card *card = dev->private_data;
2704 int count = 100;
2705 u16 reg_set = IO_REG_OFF(dev) | (reg&0x7f);
2706
2707 while(count-- && (readb(card->iobase_mmio + CAS) & 1))
2708 udelay(1);
2709
2710 #ifdef DEBUG_MMIO
2711 {
2712 u16 ans = readw(card->ac97base_mmio + reg_set);
2713 printk(KERN_DEBUG "i810_audio: ac97_get_mmio(%d) -> 0x%04X\n", ((int) reg_set) & 0xffff, (u32) ans);
2714 return ans;
2715 }
2716 #else
2717 return readw(card->ac97base_mmio + reg_set);
2718 #endif
2719 }
2720
2721 static u16 i810_ac97_get_io(struct ac97_codec *dev, u8 reg)
2722 {
2723 struct i810_card *card = dev->private_data;
2724 int count = 100;
2725 u16 reg_set = IO_REG_OFF(dev) | (reg&0x7f);
2726
2727 while(count-- && (I810_IOREADB(card, CAS) & 1))
2728 udelay(1);
2729
2730 return inw(card->ac97base + reg_set);
2731 }
2732
2733 static void i810_ac97_set_mmio(struct ac97_codec *dev, u8 reg, u16 data)
2734 {
2735 struct i810_card *card = dev->private_data;
2736 int count = 100;
2737 u16 reg_set = IO_REG_OFF(dev) | (reg&0x7f);
2738
2739 while(count-- && (readb(card->iobase_mmio + CAS) & 1))
2740 udelay(1);
2741
2742 writew(data, card->ac97base_mmio + reg_set);
2743
2744 #ifdef DEBUG_MMIO
2745 printk(KERN_DEBUG "i810_audio: ac97_set_mmio(0x%04X, %d)\n", (u32) data, ((int) reg_set) & 0xffff);
2746 #endif
2747 }
2748
2749 static void i810_ac97_set_io(struct ac97_codec *dev, u8 reg, u16 data)
2750 {
2751 struct i810_card *card = dev->private_data;
2752 int count = 100;
2753 u16 reg_set = IO_REG_OFF(dev) | (reg&0x7f);
2754
2755 while(count-- && (I810_IOREADB(card, CAS) & 1))
2756 udelay(1);
2757
2758 outw(data, card->ac97base + reg_set);
2759 }
2760
2761 static u16 i810_ac97_get(struct ac97_codec *dev, u8 reg)
2762 {
2763 struct i810_card *card = dev->private_data;
2764 u16 ret;
2765
2766 spin_lock(&card->ac97_lock);
2767 if (card->use_mmio) {
2768 ret = i810_ac97_get_mmio(dev, reg);
2769 }
2770 else {
2771 ret = i810_ac97_get_io(dev, reg);
2772 }
2773 spin_unlock(&card->ac97_lock);
2774
2775 return ret;
2776 }
2777
2778 static void i810_ac97_set(struct ac97_codec *dev, u8 reg, u16 data)
2779 {
2780 struct i810_card *card = dev->private_data;
2781
2782 spin_lock(&card->ac97_lock);
2783 if (card->use_mmio) {
2784 i810_ac97_set_mmio(dev, reg, data);
2785 }
2786 else {
2787 i810_ac97_set_io(dev, reg, data);
2788 }
2789 spin_unlock(&card->ac97_lock);
2790 }
2791
2792
2793 /* OSS /dev/mixer file operation methods */
2794
2795 static int i810_open_mixdev(struct inode *inode, struct file *file)
2796 {
2797 int i;
2798 int minor = iminor(inode);
2799 struct i810_card *card = devs;
2800
2801 for (card = devs; card != NULL; card = card->next) {
2802 /*
2803 * If we are initializing and then fail, card could go
2804 * away unuexpectedly while we are in the for() loop.
2805 * So, check for card on each iteration before we check
2806 * for card->initializing to avoid a possible oops.
2807 * This usually only matters for times when the driver is
2808 * autoloaded by kmod.
2809 */
2810 for (i = 0; i < 50 && card && card->initializing; i++) {
2811 set_current_state(TASK_UNINTERRUPTIBLE);
2812 schedule_timeout(HZ/20);
2813 }
2814 for (i = 0; i < NR_AC97 && card && !card->initializing; i++)
2815 if (card->ac97_codec[i] != NULL &&
2816 card->ac97_codec[i]->dev_mixer == minor) {
2817 file->private_data = card->ac97_codec[i];
2818 return nonseekable_open(inode, file);
2819 }
2820 }
2821 return -ENODEV;
2822 }
2823
2824 static int i810_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
2825 unsigned long arg)
2826 {
2827 struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
2828
2829 return codec->mixer_ioctl(codec, cmd, arg);
2830 }
2831
2832 static /*const*/ struct file_operations i810_mixer_fops = {
2833 .owner = THIS_MODULE,
2834 .llseek = no_llseek,
2835 .ioctl = i810_ioctl_mixdev,
2836 .open = i810_open_mixdev,
2837 };
2838
2839 /* AC97 codec initialisation. These small functions exist so we don't
2840 duplicate code between module init and apm resume */
2841
2842 static inline int i810_ac97_exists(struct i810_card *card, int ac97_number)
2843 {
2844 u32 reg = I810_IOREADL(card, GLOB_STA);
2845 switch (ac97_number) {
2846 case 0:
2847 return reg & (1<<8);
2848 case 1:
2849 return reg & (1<<9);
2850 case 2:
2851 return reg & (1<<28);
2852 }
2853 return 0;
2854 }
2855
2856 static inline int i810_ac97_enable_variable_rate(struct ac97_codec *codec)
2857 {
2858 i810_ac97_set(codec, AC97_EXTENDED_STATUS, 9);
2859 i810_ac97_set(codec,AC97_EXTENDED_STATUS,
2860 i810_ac97_get(codec, AC97_EXTENDED_STATUS)|0xE800);
2861
2862 return (i810_ac97_get(codec, AC97_EXTENDED_STATUS)&1);
2863 }
2864
2865
2866 static int i810_ac97_probe_and_powerup(struct i810_card *card,struct ac97_codec *codec)
2867 {
2868 /* Returns 0 on failure */
2869 int i;
2870
2871 if (ac97_probe_codec(codec) == 0) return 0;
2872
2873 /* power it all up */
2874 i810_ac97_set(codec, AC97_POWER_CONTROL,
2875 i810_ac97_get(codec, AC97_POWER_CONTROL) & ~0x7f00);
2876
2877 /* wait for analog ready */
2878 for (i=100; i && ((i810_ac97_get(codec, AC97_POWER_CONTROL) & 0xf) != 0xf); i--)
2879 {
2880 set_current_state(TASK_UNINTERRUPTIBLE);
2881 schedule_timeout(HZ/20);
2882 }
2883 return i;
2884 }
2885
2886 static int is_new_ich(u16 pci_id)
2887 {
2888 switch (pci_id) {
2889 case PCI_DEVICE_ID_INTEL_82801DB_5:
2890 case PCI_DEVICE_ID_INTEL_82801EB_5:
2891 case PCI_DEVICE_ID_INTEL_ESB_5:
2892 case PCI_DEVICE_ID_INTEL_ICH6_18:
2893 return 1;
2894 default:
2895 break;
2896 }
2897
2898 return 0;
2899 }
2900
2901 static inline int ich_use_mmio(struct i810_card *card)
2902 {
2903 return is_new_ich(card->pci_id) && card->use_mmio;
2904 }
2905
2906 /**
2907 * i810_ac97_power_up_bus - bring up AC97 link
2908 * @card : ICH audio device to power up
2909 *
2910 * Bring up the ACLink AC97 codec bus
2911 */
2912
2913 static int i810_ac97_power_up_bus(struct i810_card *card)
2914 {
2915 u32 reg = I810_IOREADL(card, GLOB_CNT);
2916 int i;
2917 int primary_codec_id = 0;
2918
2919 if((reg&2)==0) /* Cold required */
2920 reg|=2;
2921 else
2922 reg|=4; /* Warm */
2923
2924 reg&=~8; /* ACLink on */
2925
2926 /* At this point we deassert AC_RESET # */
2927 I810_IOWRITEL(reg , card, GLOB_CNT);
2928
2929 /* We must now allow time for the Codec initialisation.
2930 600mS is the specified time */
2931
2932 for(i=0;i<10;i++)
2933 {
2934 if((I810_IOREADL(card, GLOB_CNT)&4)==0)
2935 break;
2936
2937 set_current_state(TASK_UNINTERRUPTIBLE);
2938 schedule_timeout(HZ/20);
2939 }
2940 if(i==10)
2941 {
2942 printk(KERN_ERR "i810_audio: AC'97 reset failed.\n");
2943 return 0;
2944 }
2945
2946 set_current_state(TASK_UNINTERRUPTIBLE);
2947 schedule_timeout(HZ/2);
2948
2949 /*
2950 * See if the primary codec comes ready. This must happen
2951 * before we start doing DMA stuff
2952 */
2953 /* see i810_ac97_init for the next 10 lines (jsaw) */
2954 if (card->use_mmio)
2955 readw(card->ac97base_mmio);
2956 else
2957 inw(card->ac97base);
2958 if (ich_use_mmio(card)) {
2959 primary_codec_id = (int) readl(card->iobase_mmio + SDM) & 0x3;
2960 printk(KERN_INFO "i810_audio: Primary codec has ID %d\n",
2961 primary_codec_id);
2962 }
2963
2964 if(! i810_ac97_exists(card, primary_codec_id))
2965 {
2966 printk(KERN_INFO "i810_audio: Codec not ready.. wait.. ");
2967 set_current_state(TASK_UNINTERRUPTIBLE);
2968 schedule_timeout(HZ); /* actually 600mS by the spec */
2969
2970 if(i810_ac97_exists(card, primary_codec_id))
2971 printk("OK\n");
2972 else
2973 printk("no response.\n");
2974 }
2975 if (card->use_mmio)
2976 readw(card->ac97base_mmio);
2977 else
2978 inw(card->ac97base);
2979 return 1;
2980 }
2981
2982 static int __devinit i810_ac97_init(struct i810_card *card)
2983 {
2984 int num_ac97 = 0;
2985 int ac97_id;
2986 int total_channels = 0;
2987 int nr_ac97_max = card_cap[card->pci_id_internal].nr_ac97;
2988 struct ac97_codec *codec;
2989 u16 eid;
2990 u32 reg;
2991
2992 if(!i810_ac97_power_up_bus(card)) return 0;
2993
2994 /* Number of channels supported */
2995 /* What about the codec? Just because the ICH supports */
2996 /* multiple channels doesn't mean the codec does. */
2997 /* we'll have to modify this in the codec section below */
2998 /* to reflect what the codec has. */
2999 /* ICH and ICH0 only support 2 channels so don't bother */
3000 /* to check.... */
3001
3002 card->channels = 2;
3003 reg = I810_IOREADL(card, GLOB_STA);
3004 if ( reg & 0x0200000 )
3005 card->channels = 6;
3006 else if ( reg & 0x0100000 )
3007 card->channels = 4;
3008 printk(KERN_INFO "i810_audio: Audio Controller supports %d channels.\n", card->channels);
3009 printk(KERN_INFO "i810_audio: Defaulting to base 2 channel mode.\n");
3010 reg = I810_IOREADL(card, GLOB_CNT);
3011 I810_IOWRITEL(reg & 0xffcfffff, card, GLOB_CNT);
3012
3013 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++)
3014 card->ac97_codec[num_ac97] = NULL;
3015
3016 /*@FIXME I don't know, if I'm playing to safe here... (jsaw) */
3017 if ((nr_ac97_max > 2) && !card->use_mmio) nr_ac97_max = 2;
3018
3019 for (num_ac97 = 0; num_ac97 < nr_ac97_max; num_ac97++) {
3020 /* codec reset */
3021 printk(KERN_INFO "i810_audio: Resetting connection %d\n", num_ac97);
3022 if (card->use_mmio)
3023 readw(card->ac97base_mmio + 0x80*num_ac97);
3024 else
3025 inw(card->ac97base + 0x80*num_ac97);
3026
3027 /* If we have the SDATA_IN Map Register, as on ICH4, we
3028 do not loop thru all possible codec IDs but thru all
3029 possible IO channels. Bit 0:1 of SDM then holds the
3030 last codec ID spoken to.
3031 */
3032 if (ich_use_mmio(card)) {
3033 ac97_id = (int) readl(card->iobase_mmio + SDM) & 0x3;
3034 printk(KERN_INFO "i810_audio: Connection %d with codec id %d\n",
3035 num_ac97, ac97_id);
3036 }
3037 else {
3038 ac97_id = num_ac97;
3039 }
3040
3041 /* The ICH programmer's reference says you should */
3042 /* check the ready status before probing. So we chk */
3043 /* What do we do if it's not ready? Wait and try */
3044 /* again, or abort? */
3045 if (!i810_ac97_exists(card, ac97_id)) {
3046 if(num_ac97 == 0)
3047 printk(KERN_ERR "i810_audio: Primary codec not ready.\n");
3048 }
3049
3050 if ((codec = ac97_alloc_codec()) == NULL)
3051 return -ENOMEM;
3052
3053 /* initialize some basic codec information, other fields will be filled
3054 in ac97_probe_codec */
3055 codec->private_data = card;
3056 codec->id = ac97_id;
3057 card->ac97_id_map[ac97_id] = num_ac97 * 0x80;
3058
3059 if (card->use_mmio) {
3060 codec->codec_read = i810_ac97_get_mmio;
3061 codec->codec_write = i810_ac97_set_mmio;
3062 }
3063 else {
3064 codec->codec_read = i810_ac97_get_io;
3065 codec->codec_write = i810_ac97_set_io;
3066 }
3067
3068 if(!i810_ac97_probe_and_powerup(card,codec)) {
3069 printk(KERN_ERR "i810_audio: timed out waiting for codec %d analog ready.\n", ac97_id);
3070 ac97_release_codec(codec);
3071 break; /* it didn't work */
3072 }
3073 /* Store state information about S/PDIF transmitter */
3074 card->ac97_status = 0;
3075
3076 /* Don't attempt to get eid until powerup is complete */
3077 eid = i810_ac97_get(codec, AC97_EXTENDED_ID);
3078
3079 if(eid==0xFFFF)
3080 {
3081 printk(KERN_WARNING "i810_audio: no codec attached ?\n");
3082 ac97_release_codec(codec);
3083 break;
3084 }
3085
3086 /* Check for an AC97 1.0 soft modem (ID1) */
3087
3088 if(codec->modem)
3089 {
3090 printk(KERN_WARNING "i810_audio: codec %d is a softmodem - skipping.\n", ac97_id);
3091 ac97_release_codec(codec);
3092 continue;
3093 }
3094
3095 card->ac97_features = eid;
3096
3097 /* Now check the codec for useful features to make up for
3098 the dumbness of the 810 hardware engine */
3099
3100 if(!(eid&0x0001))
3101 printk(KERN_WARNING "i810_audio: only 48Khz playback available.\n");
3102 else
3103 {
3104 if(!i810_ac97_enable_variable_rate(codec)) {
3105 printk(KERN_WARNING "i810_audio: Codec refused to allow VRA, using 48Khz only.\n");
3106 card->ac97_features&=~1;
3107 }
3108 }
3109
3110 /* Turn on the amplifier */
3111
3112 codec->codec_write(codec, AC97_POWER_CONTROL,
3113 codec->codec_read(codec, AC97_POWER_CONTROL) & ~0x8000);
3114
3115 /* Determine how many channels the codec(s) support */
3116 /* - The primary codec always supports 2 */
3117 /* - If the codec supports AMAP, surround DACs will */
3118 /* automaticlly get assigned to slots. */
3119 /* * Check for surround DACs and increment if */
3120 /* found. */
3121 /* - Else check if the codec is revision 2.2 */
3122 /* * If surround DACs exist, assign them to slots */
3123 /* and increment channel count. */
3124
3125 /* All of this only applies to ICH2 and above. ICH */
3126 /* and ICH0 only support 2 channels. ICH2 will only */
3127 /* support multiple codecs in a "split audio" config. */
3128 /* as described above. */
3129
3130 /* TODO: Remove all the debugging messages! */
3131
3132 if((eid & 0xc000) == 0) /* primary codec */
3133 total_channels += 2;
3134
3135 if(eid & 0x200) { /* GOOD, AMAP support */
3136 if (eid & 0x0080) /* L/R Surround channels */
3137 total_channels += 2;
3138 if (eid & 0x0140) /* LFE and Center channels */
3139 total_channels += 2;
3140 printk("i810_audio: AC'97 codec %d supports AMAP, total channels = %d\n", ac97_id, total_channels);
3141 } else if (eid & 0x0400) { /* this only works on 2.2 compliant codecs */
3142 eid &= 0xffcf;
3143 if((eid & 0xc000) != 0) {
3144 switch ( total_channels ) {
3145 case 2:
3146 /* Set dsa1, dsa0 to 01 */
3147 eid |= 0x0010;
3148 break;
3149 case 4:
3150 /* Set dsa1, dsa0 to 10 */
3151 eid |= 0x0020;
3152 break;
3153 case 6:
3154 /* Set dsa1, dsa0 to 11 */
3155 eid |= 0x0030;
3156 break;
3157 }
3158 total_channels += 2;
3159 }
3160 i810_ac97_set(codec, AC97_EXTENDED_ID, eid);
3161 eid = i810_ac97_get(codec, AC97_EXTENDED_ID);
3162 printk("i810_audio: AC'97 codec %d, new EID value = 0x%04x\n", ac97_id, eid);
3163 if (eid & 0x0080) /* L/R Surround channels */
3164 total_channels += 2;
3165 if (eid & 0x0140) /* LFE and Center channels */
3166 total_channels += 2;
3167 printk("i810_audio: AC'97 codec %d, DAC map configured, total channels = %d\n", ac97_id, total_channels);
3168 } else {
3169 printk("i810_audio: AC'97 codec %d Unable to map surround DAC's (or DAC's not present), total channels = %d\n", ac97_id, total_channels);
3170 }
3171
3172 if ((codec->dev_mixer = register_sound_mixer(&i810_mixer_fops, -1)) < 0) {
3173 printk(KERN_ERR "i810_audio: couldn't register mixer!\n");
3174 ac97_release_codec(codec);
3175 break;
3176 }
3177
3178 card->ac97_codec[num_ac97] = codec;
3179 }
3180
3181 /* tune up the primary codec */
3182 ac97_tune_hardware(card->pci_dev, ac97_quirks, ac97_quirk);
3183
3184 /* pick the minimum of channels supported by ICHx or codec(s) */
3185 card->channels = (card->channels > total_channels)?total_channels:card->channels;
3186
3187 return num_ac97;
3188 }
3189
3190 static void __devinit i810_configure_clocking (void)
3191 {
3192 struct i810_card *card;
3193 struct i810_state *state;
3194 struct dmabuf *dmabuf;
3195 unsigned int i, offset, new_offset;
3196 unsigned long flags;
3197
3198 card = devs;
3199 /* We could try to set the clocking for multiple cards, but can you even have
3200 * more than one i810 in a machine? Besides, clocking is global, so unless
3201 * someone actually thinks more than one i810 in a machine is possible and
3202 * decides to rewrite that little bit, setting the rate for more than one card
3203 * is a waste of time.
3204 */
3205 if(card != NULL) {
3206 state = card->states[0] = (struct i810_state *)
3207 kmalloc(sizeof(struct i810_state), GFP_KERNEL);
3208 if (state == NULL)
3209 return;
3210 memset(state, 0, sizeof(struct i810_state));
3211 dmabuf = &state->dmabuf;
3212
3213 dmabuf->write_channel = card->alloc_pcm_channel(card);
3214 state->virt = 0;
3215 state->card = card;
3216 state->magic = I810_STATE_MAGIC;
3217 init_waitqueue_head(&dmabuf->wait);
3218 mutex_init(&state->open_mutex);
3219 dmabuf->fmt = I810_FMT_STEREO | I810_FMT_16BIT;
3220 dmabuf->trigger = PCM_ENABLE_OUTPUT;
3221 i810_set_spdif_output(state, -1, 0);
3222 i810_set_dac_channels(state, 2);
3223 i810_set_dac_rate(state, 48000);
3224 if(prog_dmabuf(state, 0) != 0) {
3225 goto config_out_nodmabuf;
3226 }
3227 if(dmabuf->dmasize < 16384) {
3228 goto config_out;
3229 }
3230 dmabuf->count = dmabuf->dmasize;
3231 CIV_TO_LVI(card, dmabuf->write_channel->port, -1);
3232 local_irq_save(flags);
3233 start_dac(state);
3234 offset = i810_get_dma_addr(state, 0);
3235 mdelay(50);
3236 new_offset = i810_get_dma_addr(state, 0);
3237 stop_dac(state);
3238 local_irq_restore(flags);
3239 i = new_offset - offset;
3240 #ifdef DEBUG_INTERRUPTS
3241 printk("i810_audio: %d bytes in 50 milliseconds\n", i);
3242 #endif
3243 if(i == 0)
3244 goto config_out;
3245 i = i / 4 * 20;
3246 if (i > 48500 || i < 47500) {
3247 clocking = clocking * clocking / i;
3248 printk("i810_audio: setting clocking to %d\n", clocking);
3249 }
3250 config_out:
3251 dealloc_dmabuf(state);
3252 config_out_nodmabuf:
3253 state->card->free_pcm_channel(state->card,state->dmabuf.write_channel->num);
3254 kfree(state);
3255 card->states[0] = NULL;
3256 }
3257 }
3258
3259 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
3260 until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
3261
3262 static int __devinit i810_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
3263 {
3264 struct i810_card *card;
3265
3266 if (pci_enable_device(pci_dev))
3267 return -EIO;
3268
3269 if (pci_set_dma_mask(pci_dev, I810_DMA_MASK)) {
3270 printk(KERN_ERR "i810_audio: architecture does not support"
3271 " 32bit PCI busmaster DMA\n");
3272 return -ENODEV;
3273 }
3274
3275 if ((card = kmalloc(sizeof(struct i810_card), GFP_KERNEL)) == NULL) {
3276 printk(KERN_ERR "i810_audio: out of memory\n");
3277 return -ENOMEM;
3278 }
3279 memset(card, 0, sizeof(*card));
3280
3281 card->initializing = 1;
3282 card->pci_dev = pci_dev;
3283 card->pci_id = pci_id->device;
3284 card->ac97base = pci_resource_start (pci_dev, 0);
3285 card->iobase = pci_resource_start (pci_dev, 1);
3286
3287 if (!(card->ac97base) || !(card->iobase)) {
3288 card->ac97base = 0;
3289 card->iobase = 0;
3290 }
3291
3292 /* if chipset could have mmio capability, check it */
3293 if (card_cap[pci_id->driver_data].flags & CAP_MMIO) {
3294 card->ac97base_mmio_phys = pci_resource_start (pci_dev, 2);
3295 card->iobase_mmio_phys = pci_resource_start (pci_dev, 3);
3296
3297 if ((card->ac97base_mmio_phys) && (card->iobase_mmio_phys)) {
3298 card->use_mmio = 1;
3299 }
3300 else {
3301 card->ac97base_mmio_phys = 0;
3302 card->iobase_mmio_phys = 0;
3303 }
3304 }
3305
3306 if (!(card->use_mmio) && (!(card->iobase) || !(card->ac97base))) {
3307 printk(KERN_ERR "i810_audio: No I/O resources available.\n");
3308 goto out_mem;
3309 }
3310
3311 card->irq = pci_dev->irq;
3312 card->next = devs;
3313 card->magic = I810_CARD_MAGIC;
3314 #ifdef CONFIG_PM
3315 card->pm_suspended=0;
3316 #endif
3317 spin_lock_init(&card->lock);
3318 spin_lock_init(&card->ac97_lock);
3319 devs = card;
3320
3321 pci_set_master(pci_dev);
3322
3323 printk(KERN_INFO "i810: %s found at IO 0x%04lx and 0x%04lx, "
3324 "MEM 0x%04lx and 0x%04lx, IRQ %d\n",
3325 card_names[pci_id->driver_data],
3326 card->iobase, card->ac97base,
3327 card->ac97base_mmio_phys, card->iobase_mmio_phys,
3328 card->irq);
3329
3330 card->alloc_pcm_channel = i810_alloc_pcm_channel;
3331 card->alloc_rec_pcm_channel = i810_alloc_rec_pcm_channel;
3332 card->alloc_rec_mic_channel = i810_alloc_rec_mic_channel;
3333 card->free_pcm_channel = i810_free_pcm_channel;
3334
3335 if ((card->channel = pci_alloc_consistent(pci_dev,
3336 sizeof(struct i810_channel)*NR_HW_CH, &card->chandma)) == NULL) {
3337 printk(KERN_ERR "i810: cannot allocate channel DMA memory\n");
3338 goto out_mem;
3339 }
3340
3341 { /* We may dispose of this altogether some time soon, so... */
3342 struct i810_channel *cp = card->channel;
3343
3344 cp[0].offset = 0;
3345 cp[0].port = 0x00;
3346 cp[0].num = 0;
3347 cp[1].offset = 0;
3348 cp[1].port = 0x10;
3349 cp[1].num = 1;
3350 cp[2].offset = 0;
3351 cp[2].port = 0x20;
3352 cp[2].num = 2;
3353 }
3354
3355 /* claim our iospace and irq */
3356 if (!request_region(card->iobase, 64, card_names[pci_id->driver_data])) {
3357 printk(KERN_ERR "i810_audio: unable to allocate region %lx\n", card->iobase);
3358 goto out_region1;
3359 }
3360 if (!request_region(card->ac97base, 256, card_names[pci_id->driver_data])) {
3361 printk(KERN_ERR "i810_audio: unable to allocate region %lx\n", card->ac97base);
3362 goto out_region2;
3363 }
3364
3365 if (card->use_mmio) {
3366 if (request_mem_region(card->ac97base_mmio_phys, 512, "ich_audio MMBAR")) {
3367 if ((card->ac97base_mmio = ioremap(card->ac97base_mmio_phys, 512))) { /*@FIXME can ioremap fail? don't know (jsaw) */
3368 if (request_mem_region(card->iobase_mmio_phys, 256, "ich_audio MBBAR")) {
3369 if ((card->iobase_mmio = ioremap(card->iobase_mmio_phys, 256))) {
3370 printk(KERN_INFO "i810: %s mmio at 0x%04lx and 0x%04lx\n",
3371 card_names[pci_id->driver_data],
3372 (unsigned long) card->ac97base_mmio,
3373 (unsigned long) card->iobase_mmio);
3374 }
3375 else {
3376 iounmap(card->ac97base_mmio);
3377 release_mem_region(card->ac97base_mmio_phys, 512);
3378 release_mem_region(card->iobase_mmio_phys, 512);
3379 card->use_mmio = 0;
3380 }
3381 }
3382 else {
3383 iounmap(card->ac97base_mmio);
3384 release_mem_region(card->ac97base_mmio_phys, 512);
3385 card->use_mmio = 0;
3386 }
3387 }
3388 }
3389 else {
3390 card->use_mmio = 0;
3391 }
3392 }
3393
3394 /* initialize AC97 codec and register /dev/mixer */
3395 if (i810_ac97_init(card) <= 0)
3396 goto out_iospace;
3397 pci_set_drvdata(pci_dev, card);
3398
3399 if(clocking == 0) {
3400 clocking = 48000;
3401 i810_configure_clocking();
3402 }
3403
3404 /* register /dev/dsp */
3405 if ((card->dev_audio = register_sound_dsp(&i810_audio_fops, -1)) < 0) {
3406 int i;
3407 printk(KERN_ERR "i810_audio: couldn't register DSP device!\n");
3408 for (i = 0; i < NR_AC97; i++)
3409 if (card->ac97_codec[i] != NULL) {
3410 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
3411 ac97_release_codec(card->ac97_codec[i]);
3412 }
3413 goto out_iospace;
3414 }
3415
3416 if (request_irq(card->irq, &i810_interrupt, IRQF_SHARED,
3417 card_names[pci_id->driver_data], card)) {
3418 printk(KERN_ERR "i810_audio: unable to allocate irq %d\n", card->irq);
3419 goto out_iospace;
3420 }
3421
3422
3423 card->initializing = 0;
3424 return 0;
3425
3426 out_iospace:
3427 if (card->use_mmio) {
3428 iounmap(card->ac97base_mmio);
3429 iounmap(card->iobase_mmio);
3430 release_mem_region(card->ac97base_mmio_phys, 512);
3431 release_mem_region(card->iobase_mmio_phys, 256);
3432 }
3433 release_region(card->ac97base, 256);
3434 out_region2:
3435 release_region(card->iobase, 64);
3436 out_region1:
3437 pci_free_consistent(pci_dev, sizeof(struct i810_channel)*NR_HW_CH,
3438 card->channel, card->chandma);
3439 out_mem:
3440 kfree(card);
3441 return -ENODEV;
3442 }
3443
3444 static void __devexit i810_remove(struct pci_dev *pci_dev)
3445 {
3446 int i;
3447 struct i810_card *card = pci_get_drvdata(pci_dev);
3448 /* free hardware resources */
3449 free_irq(card->irq, devs);
3450 release_region(card->iobase, 64);
3451 release_region(card->ac97base, 256);
3452 pci_free_consistent(pci_dev, sizeof(struct i810_channel)*NR_HW_CH,
3453 card->channel, card->chandma);
3454 if (card->use_mmio) {
3455 iounmap(card->ac97base_mmio);
3456 iounmap(card->iobase_mmio);
3457 release_mem_region(card->ac97base_mmio_phys, 512);
3458 release_mem_region(card->iobase_mmio_phys, 256);
3459 }
3460
3461 /* unregister audio devices */
3462 for (i = 0; i < NR_AC97; i++)
3463 if (card->ac97_codec[i] != NULL) {
3464 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
3465 ac97_release_codec(card->ac97_codec[i]);
3466 card->ac97_codec[i] = NULL;
3467 }
3468 unregister_sound_dsp(card->dev_audio);
3469 kfree(card);
3470 }
3471
3472 #ifdef CONFIG_PM
3473 static int i810_pm_suspend(struct pci_dev *dev, pm_message_t pm_state)
3474 {
3475 struct i810_card *card = pci_get_drvdata(dev);
3476 struct i810_state *state;
3477 unsigned long flags;
3478 struct dmabuf *dmabuf;
3479 int i,num_ac97;
3480 #ifdef DEBUG
3481 printk("i810_audio: i810_pm_suspend called\n");
3482 #endif
3483 if(!card) return 0;
3484 spin_lock_irqsave(&card->lock, flags);
3485 card->pm_suspended=1;
3486 for(i=0;i<NR_HW_CH;i++) {
3487 state = card->states[i];
3488 if(!state) continue;
3489 /* this happens only if there are open files */
3490 dmabuf = &state->dmabuf;
3491 if(dmabuf->enable & DAC_RUNNING ||
3492 (dmabuf->count && (dmabuf->trigger & PCM_ENABLE_OUTPUT))) {
3493 state->pm_saved_dac_rate=dmabuf->rate;
3494 stop_dac(state);
3495 } else {
3496 state->pm_saved_dac_rate=0;
3497 }
3498 if(dmabuf->enable & ADC_RUNNING) {
3499 state->pm_saved_adc_rate=dmabuf->rate;
3500 stop_adc(state);
3501 } else {
3502 state->pm_saved_adc_rate=0;
3503 }
3504 dmabuf->ready = 0;
3505 dmabuf->swptr = dmabuf->hwptr = 0;
3506 dmabuf->count = dmabuf->total_bytes = 0;
3507 }
3508
3509 spin_unlock_irqrestore(&card->lock, flags);
3510
3511 /* save mixer settings */
3512 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3513 struct ac97_codec *codec = card->ac97_codec[num_ac97];
3514 if(!codec) continue;
3515 for(i=0;i< SOUND_MIXER_NRDEVICES ;i++) {
3516 if((supported_mixer(codec,i)) &&
3517 (codec->read_mixer)) {
3518 card->pm_saved_mixer_settings[i][num_ac97]=
3519 codec->read_mixer(codec,i);
3520 }
3521 }
3522 }
3523 pci_save_state(dev); /* XXX do we need this? */
3524 pci_disable_device(dev); /* disable busmastering */
3525 pci_set_power_state(dev,3); /* Zzz. */
3526
3527 return 0;
3528 }
3529
3530
3531 static int i810_pm_resume(struct pci_dev *dev)
3532 {
3533 int num_ac97,i=0;
3534 struct i810_card *card=pci_get_drvdata(dev);
3535 pci_enable_device(dev);
3536 pci_restore_state (dev);
3537
3538 /* observation of a toshiba portege 3440ct suggests that the
3539 hardware has to be more or less completely reinitialized from
3540 scratch after an apm suspend. Works For Me. -dan */
3541
3542 i810_ac97_power_up_bus(card);
3543
3544 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3545 struct ac97_codec *codec = card->ac97_codec[num_ac97];
3546 /* check they haven't stolen the hardware while we were
3547 away */
3548 if(!codec || !i810_ac97_exists(card,num_ac97)) {
3549 if(num_ac97) continue;
3550 else BUG();
3551 }
3552 if(!i810_ac97_probe_and_powerup(card,codec)) BUG();
3553
3554 if((card->ac97_features&0x0001)) {
3555 /* at probe time we found we could do variable
3556 rates, but APM suspend has made it forget
3557 its magical powers */
3558 if(!i810_ac97_enable_variable_rate(codec)) BUG();
3559 }
3560 /* we lost our mixer settings, so restore them */
3561 for(i=0;i< SOUND_MIXER_NRDEVICES ;i++) {
3562 if(supported_mixer(codec,i)){
3563 int val=card->
3564 pm_saved_mixer_settings[i][num_ac97];
3565 codec->mixer_state[i]=val;
3566 codec->write_mixer(codec,i,
3567 (val & 0xff) ,
3568 ((val >> 8) & 0xff) );
3569 }
3570 }
3571 }
3572
3573 /* we need to restore the sample rate from whatever it was */
3574 for(i=0;i<NR_HW_CH;i++) {
3575 struct i810_state * state=card->states[i];
3576 if(state) {
3577 if(state->pm_saved_adc_rate)
3578 i810_set_adc_rate(state,state->pm_saved_adc_rate);
3579 if(state->pm_saved_dac_rate)
3580 i810_set_dac_rate(state,state->pm_saved_dac_rate);
3581 }
3582 }
3583
3584
3585 card->pm_suspended = 0;
3586
3587 /* any processes that were reading/writing during the suspend
3588 probably ended up here */
3589 for(i=0;i<NR_HW_CH;i++) {
3590 struct i810_state *state = card->states[i];
3591 if(state) wake_up(&state->dmabuf.wait);
3592 }
3593
3594 return 0;
3595 }
3596 #endif /* CONFIG_PM */
3597
3598 MODULE_AUTHOR("The Linux kernel team");
3599 MODULE_DESCRIPTION("Intel 810 audio support");
3600 MODULE_LICENSE("GPL");
3601 module_param(ftsodell, int, 0444);
3602 module_param(clocking, uint, 0444);
3603 module_param(strict_clocking, int, 0444);
3604 module_param(spdif_locked, int, 0444);
3605
3606 #define I810_MODULE_NAME "i810_audio"
3607
3608 static struct pci_driver i810_pci_driver = {
3609 .name = I810_MODULE_NAME,
3610 .id_table = i810_pci_tbl,
3611 .probe = i810_probe,
3612 .remove = __devexit_p(i810_remove),
3613 #ifdef CONFIG_PM
3614 .suspend = i810_pm_suspend,
3615 .resume = i810_pm_resume,
3616 #endif /* CONFIG_PM */
3617 };
3618
3619
3620 static int __init i810_init_module (void)
3621 {
3622 int retval;
3623
3624 printk(KERN_INFO "Intel 810 + AC97 Audio, version "
3625 DRIVER_VERSION ", " __TIME__ " " __DATE__ "\n");
3626
3627 retval = pci_register_driver(&i810_pci_driver);
3628 if (retval)
3629 return retval;
3630
3631 if(ftsodell != 0) {
3632 printk("i810_audio: ftsodell is now a deprecated option.\n");
3633 }
3634 if(spdif_locked > 0 ) {
3635 if(spdif_locked == 32000 || spdif_locked == 44100 || spdif_locked == 48000) {
3636 printk("i810_audio: Enabling S/PDIF at sample rate %dHz.\n", spdif_locked);
3637 } else {
3638 printk("i810_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3639 spdif_locked = 0;
3640 }
3641 }
3642
3643 return 0;
3644 }
3645
3646 static void __exit i810_cleanup_module (void)
3647 {
3648 pci_unregister_driver(&i810_pci_driver);
3649 }
3650
3651 module_init(i810_init_module);
3652 module_exit(i810_cleanup_module);
3653
3654 /*
3655 Local Variables:
3656 c-basic-offset: 8
3657 End:
3658 */
hh.org GIT migration