projects / deliverable / linux.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
ALSA: azt3328: use proper private_data hookup for codec identification
[deliverable/linux.git] / sound / pci / azt3328.c
... / ...
CommitLineData
1/*
2 * azt3328.c - driver for Aztech AZF3328 based soundcards (e.g. PCI168).
3 * Copyright (C) 2002, 2005 - 2010 by Andreas Mohr <andi AT lisas.de>
4 *
5 * Framework borrowed from Bart Hartgers's als4000.c.
6 * Driver developed on PCI168 AP(W) version (PCI rev. 10, subsystem ID 1801),
7 * found in a Fujitsu-Siemens PC ("Cordant", aluminum case).
8 * Other versions are:
9 * PCI168 A(W), sub ID 1800
10 * PCI168 A/AP, sub ID 8000
11 * Please give me feedback in case you try my driver with one of these!!
12 *
13 * Keywords: Windows XP Vista 168nt4-125.zip 168win95-125.zip PCI 168 download
14 * (XP/Vista do not support this card at all but every Linux distribution
15 * has very good support out of the box;
16 * just to make sure that the right people hit this and get to know that,
17 * despite the high level of Internet ignorance - as usual :-P -
18 * about very good support for this card - on Linux!)
19 *
20 * GPL LICENSE
21 * This program is free software; you can redistribute it and/or modify
22 * it under the terms of the GNU General Public License as published by
23 * the Free Software Foundation; either version 2 of the License, or
24 * (at your option) any later version.
25 *
26 * This program is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 * GNU General Public License for more details.
30
31 * You should have received a copy of the GNU General Public License
32 * along with this program; if not, write to the Free Software
33 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34 *
35 * NOTES
36 * Since Aztech does not provide any chipset documentation,
37 * even on repeated request to various addresses,
38 * and the answer that was finally given was negative
39 * (and I was stupid enough to manage to get hold of a PCI168 soundcard
40 * in the first place >:-P}),
41 * I was forced to base this driver on reverse engineering
42 * (3 weeks' worth of evenings filled with driver work).
43 * (and no, I did NOT go the easy way: to pick up a SB PCI128 for 9 Euros)
44 *
45 * It is quite likely that the AZF3328 chip is the PCI cousin of the
46 * AZF3318 ("azt1020 pnp", "MM Pro 16") ISA chip, given very similar specs.
47 *
48 * The AZF3328 chip (note: AZF3328, *not* AZT3328, that's just the driver name
49 * for compatibility reasons) from Azfin (joint-venture of Aztech and Fincitec,
50 * Fincitec acquired by National Semiconductor in 2002, together with the
51 * Fincitec-related company ARSmikro) has the following features:
52 *
53 * - compatibility & compliance:
54 * - Microsoft PC 97 ("PC 97 Hardware Design Guide",
55 * http://www.microsoft.com/whdc/archive/pcguides.mspx)
56 * - Microsoft PC 98 Baseline Audio
57 * - MPU401 UART
58 * - Sound Blaster Emulation (DOS Box)
59 * - builtin AC97 conformant codec (SNR over 80dB)
60 * Note that "conformant" != "compliant"!! this chip's mixer register layout
61 * *differs* from the standard AC97 layout:
62 * they chose to not implement the headphone register (which is not a
63 * problem since it's merely optional), yet when doing this, they committed
64 * the grave sin of letting other registers follow immediately instead of
65 * keeping a headphone dummy register, thereby shifting the mixer register
66 * addresses illegally. So far unfortunately it looks like the very flexible
67 * ALSA AC97 support is still not enough to easily compensate for such a
68 * grave layout violation despite all tweaks and quirks mechanisms it offers.
69 * - builtin genuine OPL3 - verified to work fine, 20080506
70 * - full duplex 16bit playback/record at independent sampling rate
71 * - MPU401 (+ legacy address support, claimed by one official spec sheet)
72 * FIXME: how to enable legacy addr??
73 * - game port (legacy address support)
74 * - builtin DirectInput support, helps reduce CPU overhead (interrupt-driven
75 * features supported). - See common term "Digital Enhanced Game Port"...
76 * (probably DirectInput 3.0 spec - confirm)
77 * - builtin 3D enhancement (said to be YAMAHA Ymersion)
78 * - built-in General DirectX timer having a 20 bits counter
79 * with 1us resolution (see below!)
80 * - I2S serial output port for external DAC
81 * [FIXME: 3.3V or 5V level? maximum rate is 66.2kHz right?]
82 * - supports 33MHz PCI spec 2.1, PCI power management 1.0, compliant with ACPI
83 * - supports hardware volume control
84 * - single chip low cost solution (128 pin QFP)
85 * - supports programmable Sub-vendor and Sub-system ID [24C02 SEEPROM chip]
86 * required for Microsoft's logo compliance (FIXME: where?)
87 * At least the Trident 4D Wave DX has one bit somewhere
88 * to enable writes to PCI subsystem VID registers, that should be it.
89 * This might easily be in extended PCI reg space, since PCI168 also has
90 * some custom data starting at 0x80. What kind of config settings
91 * are located in our extended PCI space anyway??
92 * - PCI168 AP(W) card: power amplifier with 4 Watts/channel at 4 Ohms
93 * [TDA1517P chip]
94 *
95 * Note that this driver now is actually *better* than the Windows driver,
96 * since it additionally supports the card's 1MHz DirectX timer - just try
97 * the following snd-seq module parameters etc.:
98 * - options snd-seq seq_default_timer_class=2 seq_default_timer_sclass=0
99 * seq_default_timer_card=0 seq_client_load=1 seq_default_timer_device=0
100 * seq_default_timer_subdevice=0 seq_default_timer_resolution=1000000
101 * - "timidity -iAv -B2,8 -Os -EFreverb=0"
102 * - "pmidi -p 128:0 jazz.mid"
103 *
104 * OPL3 hardware playback testing, try something like:
105 * cat /proc/asound/hwdep
106 * and
107 * aconnect -o
108 * Then use
109 * sbiload -Dhw:x,y --opl3 /usr/share/sounds/opl3/std.o3 ......./drums.o3
110 * where x,y is the xx-yy number as given in hwdep.
111 * Then try
112 * pmidi -p a:b jazz.mid
113 * where a:b is the client number plus 0 usually, as given by aconnect above.
114 * Oh, and make sure to unmute the FM mixer control (doh!)
115 * NOTE: power use during OPL3 playback is _VERY_ high (70W --> 90W!)
116 * despite no CPU activity, possibly due to hindering ACPI idling somehow.
117 * Shouldn't be a problem of the AZF3328 chip itself, I'd hope.
118 * Higher PCM / FM mixer levels seem to conflict (causes crackling),
119 * at least sometimes. Maybe even use with hardware sequencer timer above :)
120 * adplay/adplug-utils might soon offer hardware-based OPL3 playback, too.
121 *
122 * Certain PCI versions of this card are susceptible to DMA traffic underruns
123 * in some systems (resulting in sound crackling/clicking/popping),
124 * probably because they don't have a DMA FIFO buffer or so.
125 * Overview (PCI ID/PCI subID/PCI rev.):
126 * - no DMA crackling on SiS735: 0x50DC/0x1801/16
127 * - unknown performance: 0x50DC/0x1801/10
128 * (well, it's not bad on an Athlon 1800 with now very optimized IRQ handler)
129 *
130 * Crackling happens with VIA chipsets or, in my case, an SiS735, which is
131 * supposed to be very fast and supposed to get rid of crackling much
132 * better than a VIA, yet ironically I still get crackling, like many other
133 * people with the same chipset.
134 * Possible remedies:
135 * - use speaker (amplifier) output instead of headphone output
136 * (in case crackling is due to overloaded output clipping)
137 * - plug card into a different PCI slot, preferrably one that isn't shared
138 * too much (this helps a lot, but not completely!)
139 * - get rid of PCI VGA card, use AGP instead
140 * - upgrade or downgrade BIOS
141 * - fiddle with PCI latency settings (setpci -v -s BUSID latency_timer=XX)
142 * Not too helpful.
143 * - Disable ACPI/power management/"Auto Detect RAM/PCI Clk" in BIOS
144 *
145 * BUGS
146 * - full-duplex might *still* be problematic, however a recent test was fine
147 * - (non-bug) "Bass/Treble or 3D settings don't work" - they do get evaluated
148 * if you set PCM output switch to "pre 3D" instead of "post 3D".
149 * If this can't be set, then get a mixer application that Isn't Stupid (tm)
150 * (e.g. kmix, gamix) - unfortunately several are!!
151 * - locking is not entirely clean, especially the audio stream activity
152 * ints --> may be racy
153 * - an _unconnected_ secondary joystick at the gameport will be reported
154 * to be "active" (floating values, not precisely -1) due to the way we need
155 * to read the Digital Enhanced Game Port. Not sure whether it is fixable.
156 *
157 * TODO
158 * - use PCI_VDEVICE
159 * - verify driver status on x86_64
160 * - test multi-card driver operation
161 * - (ab)use 1MHz DirectX timer as kernel clocksource
162 * - test MPU401 MIDI playback etc.
163 * - add more power micro-management (disable various units of the card
164 * as long as they're unused, to improve audio quality and save power).
165 * However this requires more I/O ports which I haven't figured out yet
166 * and which thus might not even exist...
167 * The standard suspend/resume functionality could probably make use of
168 * some improvement, too...
169 * - figure out what all unknown port bits are responsible for
170 * - figure out some cleverly evil scheme to possibly make ALSA AC97 code
171 * fully accept our quite incompatible ""AC97"" mixer and thus save some
172 * code (but I'm not too optimistic that doing this is possible at all)
173 * - use MMIO (memory-mapped I/O)? Slightly faster access, e.g. for gameport.
174 */
175
176#include <asm/io.h>
177#include <linux/init.h>
178#include <linux/pci.h>
179#include <linux/delay.h>
180#include <linux/slab.h>
181#include <linux/gameport.h>
182#include <linux/moduleparam.h>
183#include <linux/dma-mapping.h>
184#include <sound/core.h>
185#include <sound/control.h>
186#include <sound/pcm.h>
187#include <sound/rawmidi.h>
188#include <sound/mpu401.h>
189#include <sound/opl3.h>
190#include <sound/initval.h>
191#include "azt3328.h"
192
193MODULE_AUTHOR("Andreas Mohr <andi AT lisas.de>");
194MODULE_DESCRIPTION("Aztech AZF3328 (PCI168)");
195MODULE_LICENSE("GPL");
196MODULE_SUPPORTED_DEVICE("{{Aztech,AZF3328}}");
197
198#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
199#define SUPPORT_GAMEPORT 1
200#endif
201
202/* === Debug settings ===
203 Further diagnostic functionality than the settings below
204 does not need to be provided, since one can easily write a POSIX shell script
205 to dump the card's I/O ports (those listed in lspci -v -v):
206 dump()
207 {
208 local descr=$1; local addr=$2; local count=$3
209
210 echo "${descr}: ${count} @ ${addr}:"
211 dd if=/dev/port skip=`printf %d ${addr}` count=${count} bs=1 \
212 2>/dev/null| hexdump -C
213 }
214 and then use something like
215 "dump joy200 0x200 8", "dump mpu388 0x388 4", "dump joy 0xb400 8",
216 "dump codec00 0xa800 32", "dump mixer 0xb800 64", "dump synth 0xbc00 8",
217 possibly within a "while true; do ... sleep 1; done" loop.
218 Tweaking ports could be done using
219 VALSTRING="`printf "%02x" $value`"
220 printf "\x""$VALSTRING"|dd of=/dev/port seek=`printf %d ${addr}` bs=1 \
221 2>/dev/null
222*/
223
224#define DEBUG_MISC 0
225#define DEBUG_CALLS 0
226#define DEBUG_MIXER 0
227#define DEBUG_CODEC 0
228#define DEBUG_TIMER 0
229#define DEBUG_GAME 0
230#define DEBUG_PM 0
231#define MIXER_TESTING 0
232
233#if DEBUG_MISC
234#define snd_azf3328_dbgmisc(format, args...) printk(KERN_DEBUG format, ##args)
235#else
236#define snd_azf3328_dbgmisc(format, args...)
237#endif
238
239#if DEBUG_CALLS
240#define snd_azf3328_dbgcalls(format, args...) printk(format, ##args)
241#define snd_azf3328_dbgcallenter() printk(KERN_DEBUG "--> %s\n", __func__)
242#define snd_azf3328_dbgcallleave() printk(KERN_DEBUG "<-- %s\n", __func__)
243#else
244#define snd_azf3328_dbgcalls(format, args...)
245#define snd_azf3328_dbgcallenter()
246#define snd_azf3328_dbgcallleave()
247#endif
248
249#if DEBUG_MIXER
250#define snd_azf3328_dbgmixer(format, args...) printk(KERN_DEBUG format, ##args)
251#else
252#define snd_azf3328_dbgmixer(format, args...)
253#endif
254
255#if DEBUG_CODEC
256#define snd_azf3328_dbgcodec(format, args...) printk(KERN_DEBUG format, ##args)
257#else
258#define snd_azf3328_dbgcodec(format, args...)
259#endif
260
261#if DEBUG_MISC
262#define snd_azf3328_dbgtimer(format, args...) printk(KERN_DEBUG format, ##args)
263#else
264#define snd_azf3328_dbgtimer(format, args...)
265#endif
266
267#if DEBUG_GAME
268#define snd_azf3328_dbggame(format, args...) printk(KERN_DEBUG format, ##args)
269#else
270#define snd_azf3328_dbggame(format, args...)
271#endif
272
273#if DEBUG_PM
274#define snd_azf3328_dbgpm(format, args...) printk(KERN_DEBUG format, ##args)
275#else
276#define snd_azf3328_dbgpm(format, args...)
277#endif
278
279static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
280module_param_array(index, int, NULL, 0444);
281MODULE_PARM_DESC(index, "Index value for AZF3328 soundcard.");
282
283static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
284module_param_array(id, charp, NULL, 0444);
285MODULE_PARM_DESC(id, "ID string for AZF3328 soundcard.");
286
287static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
288module_param_array(enable, bool, NULL, 0444);
289MODULE_PARM_DESC(enable, "Enable AZF3328 soundcard.");
290
291static int seqtimer_scaling = 128;
292module_param(seqtimer_scaling, int, 0444);
293MODULE_PARM_DESC(seqtimer_scaling, "Set 1024000Hz sequencer timer scale factor (lockup danger!). Default 128.");
294
295enum snd_azf3328_codec_type {
296 /* warning: fixed indices (also used for bitmask checks!) */
297 AZF_CODEC_PLAYBACK = 0,
298 AZF_CODEC_CAPTURE = 1,
299 AZF_CODEC_I2S_OUT = 2,
300};
301
302struct snd_azf3328_codec_data {
303 unsigned long io_base; /* keep first! (avoid offset calc) */
304 unsigned int dma_base; /* helper to avoid an indirection in hotpath */
305 spinlock_t *lock; /* TODO: convert to our own per-codec lock member */
306 struct snd_pcm_substream *substream;
307 bool running;
308 enum snd_azf3328_codec_type type;
309 const char *name;
310};
311
312struct snd_azf3328 {
313 /* often-used fields towards beginning, then grouped */
314
315 unsigned long ctrl_io; /* usually 0xb000, size 128 */
316 unsigned long game_io; /* usually 0xb400, size 8 */
317 unsigned long mpu_io; /* usually 0xb800, size 4 */
318 unsigned long opl3_io; /* usually 0xbc00, size 8 */
319 unsigned long mixer_io; /* usually 0xc000, size 64 */
320
321 spinlock_t reg_lock;
322
323 struct snd_timer *timer;
324
325 struct snd_pcm *pcm[3];
326
327 /* playback, recording and I2S out codecs */
328 struct snd_azf3328_codec_data codecs[3];
329
330 struct snd_card *card;
331 struct snd_rawmidi *rmidi;
332
333#ifdef SUPPORT_GAMEPORT
334 struct gameport *gameport;
335 u16 axes[4];
336#endif
337
338 struct pci_dev *pci;
339 int irq;
340
341 /* register 0x6a is write-only, thus need to remember setting.
342 * If we need to add more registers here, then we might try to fold this
343 * into some transparent combined shadow register handling with
344 * CONFIG_PM register storage below, but that's slightly difficult. */
345 u16 shadow_reg_ctrl_6AH;
346
347#ifdef CONFIG_PM
348 /* register value containers for power management
349 * Note: not always full I/O range preserved (similar to Win driver!) */
350 u32 saved_regs_ctrl[AZF_ALIGN(AZF_IO_SIZE_CTRL_PM) / 4];
351 u32 saved_regs_game[AZF_ALIGN(AZF_IO_SIZE_GAME_PM) / 4];
352 u32 saved_regs_mpu[AZF_ALIGN(AZF_IO_SIZE_MPU_PM) / 4];
353 u32 saved_regs_opl3[AZF_ALIGN(AZF_IO_SIZE_OPL3_PM) / 4];
354 u32 saved_regs_mixer[AZF_ALIGN(AZF_IO_SIZE_MIXER_PM) / 4];
355#endif
356};
357
358static DEFINE_PCI_DEVICE_TABLE(snd_azf3328_ids) = {
359 { 0x122D, 0x50DC, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* PCI168/3328 */
360 { 0x122D, 0x80DA, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* 3328 */
361 { 0, }
362};
363
364MODULE_DEVICE_TABLE(pci, snd_azf3328_ids);
365
366
367static int
368snd_azf3328_io_reg_setb(unsigned reg, u8 mask, bool do_set)
369{
370 /* Well, strictly spoken, the inb/outb sequence isn't atomic
371 and would need locking. However we currently don't care
372 since it potentially complicates matters. */
373 u8 prev = inb(reg), new;
374
375 new = (do_set) ? (prev|mask) : (prev & ~mask);
376 /* we need to always write the new value no matter whether it differs
377 * or not, since some register bits don't indicate their setting */
378 outb(new, reg);
379 if (new != prev)
380 return 1;
381
382 return 0;
383}
384
385static inline void
386snd_azf3328_codec_outb(const struct snd_azf3328_codec_data *codec,
387 unsigned reg,
388 u8 value
389)
390{
391 outb(value, codec->io_base + reg);
392}
393
394static inline u8
395snd_azf3328_codec_inb(const struct snd_azf3328_codec_data *codec, unsigned reg)
396{
397 return inb(codec->io_base + reg);
398}
399
400static inline void
401snd_azf3328_codec_outw(const struct snd_azf3328_codec_data *codec,
402 unsigned reg,
403 u16 value
404)
405{
406 outw(value, codec->io_base + reg);
407}
408
409static inline u16
410snd_azf3328_codec_inw(const struct snd_azf3328_codec_data *codec, unsigned reg)
411{
412 return inw(codec->io_base + reg);
413}
414
415static inline void
416snd_azf3328_codec_outl(const struct snd_azf3328_codec_data *codec,
417 unsigned reg,
418 u32 value
419)
420{
421 outl(value, codec->io_base + reg);
422}
423
424static inline u32
425snd_azf3328_codec_inl(const struct snd_azf3328_codec_data *codec, unsigned reg)
426{
427 return inl(codec->io_base + reg);
428}
429
430static inline void
431snd_azf3328_ctrl_outb(const struct snd_azf3328 *chip, unsigned reg, u8 value)
432{
433 outb(value, chip->ctrl_io + reg);
434}
435
436static inline u8
437snd_azf3328_ctrl_inb(const struct snd_azf3328 *chip, unsigned reg)
438{
439 return inb(chip->ctrl_io + reg);
440}
441
442static inline void
443snd_azf3328_ctrl_outw(const struct snd_azf3328 *chip, unsigned reg, u16 value)
444{
445 outw(value, chip->ctrl_io + reg);
446}
447
448static inline void
449snd_azf3328_ctrl_outl(const struct snd_azf3328 *chip, unsigned reg, u32 value)
450{
451 outl(value, chip->ctrl_io + reg);
452}
453
454static inline void
455snd_azf3328_game_outb(const struct snd_azf3328 *chip, unsigned reg, u8 value)
456{
457 outb(value, chip->game_io + reg);
458}
459
460static inline void
461snd_azf3328_game_outw(const struct snd_azf3328 *chip, unsigned reg, u16 value)
462{
463 outw(value, chip->game_io + reg);
464}
465
466static inline u8
467snd_azf3328_game_inb(const struct snd_azf3328 *chip, unsigned reg)
468{
469 return inb(chip->game_io + reg);
470}
471
472static inline u16
473snd_azf3328_game_inw(const struct snd_azf3328 *chip, unsigned reg)
474{
475 return inw(chip->game_io + reg);
476}
477
478static inline void
479snd_azf3328_mixer_outw(const struct snd_azf3328 *chip, unsigned reg, u16 value)
480{
481 outw(value, chip->mixer_io + reg);
482}
483
484static inline u16
485snd_azf3328_mixer_inw(const struct snd_azf3328 *chip, unsigned reg)
486{
487 return inw(chip->mixer_io + reg);
488}
489
490#define AZF_MUTE_BIT 0x80
491
492static bool
493snd_azf3328_mixer_set_mute(const struct snd_azf3328 *chip,
494 unsigned reg, bool do_mute
495)
496{
497 unsigned long portbase = chip->mixer_io + reg + 1;
498 bool updated;
499
500 /* the mute bit is on the *second* (i.e. right) register of a
501 * left/right channel setting */
502 updated = snd_azf3328_io_reg_setb(portbase, AZF_MUTE_BIT, do_mute);
503
504 /* indicate whether it was muted before */
505 return (do_mute) ? !updated : updated;
506}
507
508static void
509snd_azf3328_mixer_write_volume_gradually(const struct snd_azf3328 *chip,
510 unsigned reg,
511 unsigned char dst_vol_left,
512 unsigned char dst_vol_right,
513 int chan_sel, int delay
514)
515{
516 unsigned long portbase = chip->mixer_io + reg;
517 unsigned char curr_vol_left = 0, curr_vol_right = 0;
518 int left_change = 0, right_change = 0;
519
520 snd_azf3328_dbgcallenter();
521
522 if (chan_sel & SET_CHAN_LEFT) {
523 curr_vol_left = inb(portbase + 1);
524
525 /* take care of muting flag contained in left channel */
526 if (curr_vol_left & AZF_MUTE_BIT)
527 dst_vol_left |= AZF_MUTE_BIT;
528 else
529 dst_vol_left &= ~AZF_MUTE_BIT;
530
531 left_change = (curr_vol_left > dst_vol_left) ? -1 : 1;
532 }
533
534 if (chan_sel & SET_CHAN_RIGHT) {
535 curr_vol_right = inb(portbase + 0);
536
537 right_change = (curr_vol_right > dst_vol_right) ? -1 : 1;
538 }
539
540 do {
541 if (left_change) {
542 if (curr_vol_left != dst_vol_left) {
543 curr_vol_left += left_change;
544 outb(curr_vol_left, portbase + 1);
545 } else
546 left_change = 0;
547 }
548 if (right_change) {
549 if (curr_vol_right != dst_vol_right) {
550 curr_vol_right += right_change;
551
552 /* during volume change, the right channel is crackling
553 * somewhat more than the left channel, unfortunately.
554 * This seems to be a hardware issue. */
555 outb(curr_vol_right, portbase + 0);
556 } else
557 right_change = 0;
558 }
559 if (delay)
560 mdelay(delay);
561 } while ((left_change) || (right_change));
562 snd_azf3328_dbgcallleave();
563}
564
565/*
566 * general mixer element
567 */
568struct azf3328_mixer_reg {
569 unsigned reg;
570 unsigned int lchan_shift, rchan_shift;
571 unsigned int mask;
572 unsigned int invert: 1;
573 unsigned int stereo: 1;
574 unsigned int enum_c: 4;
575};
576
577#define COMPOSE_MIXER_REG(reg,lchan_shift,rchan_shift,mask,invert,stereo,enum_c) \
578 ((reg) | (lchan_shift << 8) | (rchan_shift << 12) | \
579 (mask << 16) | \
580 (invert << 24) | \
581 (stereo << 25) | \
582 (enum_c << 26))
583
584static void snd_azf3328_mixer_reg_decode(struct azf3328_mixer_reg *r, unsigned long val)
585{
586 r->reg = val & 0xff;
587 r->lchan_shift = (val >> 8) & 0x0f;
588 r->rchan_shift = (val >> 12) & 0x0f;
589 r->mask = (val >> 16) & 0xff;
590 r->invert = (val >> 24) & 1;
591 r->stereo = (val >> 25) & 1;
592 r->enum_c = (val >> 26) & 0x0f;
593}
594
595/*
596 * mixer switches/volumes
597 */
598
599#define AZF3328_MIXER_SWITCH(xname, reg, shift, invert) \
600{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
601 .info = snd_azf3328_info_mixer, \
602 .get = snd_azf3328_get_mixer, .put = snd_azf3328_put_mixer, \
603 .private_value = COMPOSE_MIXER_REG(reg, shift, 0, 0x1, invert, 0, 0), \
604}
605
606#define AZF3328_MIXER_VOL_STEREO(xname, reg, mask, invert) \
607{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
608 .info = snd_azf3328_info_mixer, \
609 .get = snd_azf3328_get_mixer, .put = snd_azf3328_put_mixer, \
610 .private_value = COMPOSE_MIXER_REG(reg, 8, 0, mask, invert, 1, 0), \
611}
612
613#define AZF3328_MIXER_VOL_MONO(xname, reg, mask, is_right_chan) \
614{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
615 .info = snd_azf3328_info_mixer, \
616 .get = snd_azf3328_get_mixer, .put = snd_azf3328_put_mixer, \
617 .private_value = COMPOSE_MIXER_REG(reg, is_right_chan ? 0 : 8, 0, mask, 1, 0, 0), \
618}
619
620#define AZF3328_MIXER_VOL_SPECIAL(xname, reg, mask, shift, invert) \
621{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
622 .info = snd_azf3328_info_mixer, \
623 .get = snd_azf3328_get_mixer, .put = snd_azf3328_put_mixer, \
624 .private_value = COMPOSE_MIXER_REG(reg, shift, 0, mask, invert, 0, 0), \
625}
626
627#define AZF3328_MIXER_ENUM(xname, reg, enum_c, shift) \
628{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
629 .info = snd_azf3328_info_mixer_enum, \
630 .get = snd_azf3328_get_mixer_enum, .put = snd_azf3328_put_mixer_enum, \
631 .private_value = COMPOSE_MIXER_REG(reg, shift, 0, 0, 0, 0, enum_c), \
632}
633
634static int
635snd_azf3328_info_mixer(struct snd_kcontrol *kcontrol,
636 struct snd_ctl_elem_info *uinfo)
637{
638 struct azf3328_mixer_reg reg;
639
640 snd_azf3328_dbgcallenter();
641 snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
642 uinfo->type = reg.mask == 1 ?
643 SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
644 uinfo->count = reg.stereo + 1;
645 uinfo->value.integer.min = 0;
646 uinfo->value.integer.max = reg.mask;
647 snd_azf3328_dbgcallleave();
648 return 0;
649}
650
651static int
652snd_azf3328_get_mixer(struct snd_kcontrol *kcontrol,
653 struct snd_ctl_elem_value *ucontrol)
654{
655 struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol);
656 struct azf3328_mixer_reg reg;
657 u16 oreg, val;
658
659 snd_azf3328_dbgcallenter();
660 snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
661
662 oreg = snd_azf3328_mixer_inw(chip, reg.reg);
663 val = (oreg >> reg.lchan_shift) & reg.mask;
664 if (reg.invert)
665 val = reg.mask - val;
666 ucontrol->value.integer.value[0] = val;
667 if (reg.stereo) {
668 val = (oreg >> reg.rchan_shift) & reg.mask;
669 if (reg.invert)
670 val = reg.mask - val;
671 ucontrol->value.integer.value[1] = val;
672 }
673 snd_azf3328_dbgmixer("get: %02x is %04x -> vol %02lx|%02lx "
674 "(shift %02d|%02d, mask %02x, inv. %d, stereo %d)\n",
675 reg.reg, oreg,
676 ucontrol->value.integer.value[0], ucontrol->value.integer.value[1],
677 reg.lchan_shift, reg.rchan_shift, reg.mask, reg.invert, reg.stereo);
678 snd_azf3328_dbgcallleave();
679 return 0;
680}
681
682static int
683snd_azf3328_put_mixer(struct snd_kcontrol *kcontrol,
684 struct snd_ctl_elem_value *ucontrol)
685{
686 struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol);
687 struct azf3328_mixer_reg reg;
688 u16 oreg, nreg, val;
689
690 snd_azf3328_dbgcallenter();
691 snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
692 oreg = snd_azf3328_mixer_inw(chip, reg.reg);
693 val = ucontrol->value.integer.value[0] & reg.mask;
694 if (reg.invert)
695 val = reg.mask - val;
696 nreg = oreg & ~(reg.mask << reg.lchan_shift);
697 nreg |= (val << reg.lchan_shift);
698 if (reg.stereo) {
699 val = ucontrol->value.integer.value[1] & reg.mask;
700 if (reg.invert)
701 val = reg.mask - val;
702 nreg &= ~(reg.mask << reg.rchan_shift);
703 nreg |= (val << reg.rchan_shift);
704 }
705 if (reg.mask >= 0x07) /* it's a volume control, so better take care */
706 snd_azf3328_mixer_write_volume_gradually(
707 chip, reg.reg, nreg >> 8, nreg & 0xff,
708 /* just set both channels, doesn't matter */
709 SET_CHAN_LEFT|SET_CHAN_RIGHT,
710 0);
711 else
712 snd_azf3328_mixer_outw(chip, reg.reg, nreg);
713
714 snd_azf3328_dbgmixer("put: %02x to %02lx|%02lx, "
715 "oreg %04x; shift %02d|%02d -> nreg %04x; after: %04x\n",
716 reg.reg, ucontrol->value.integer.value[0], ucontrol->value.integer.value[1],
717 oreg, reg.lchan_shift, reg.rchan_shift,
718 nreg, snd_azf3328_mixer_inw(chip, reg.reg));
719 snd_azf3328_dbgcallleave();
720 return (nreg != oreg);
721}
722
723static int
724snd_azf3328_info_mixer_enum(struct snd_kcontrol *kcontrol,
725 struct snd_ctl_elem_info *uinfo)
726{
727 static const char * const texts1[] = {
728 "Mic1", "Mic2"
729 };
730 static const char * const texts2[] = {
731 "Mix", "Mic"
732 };
733 static const char * const texts3[] = {
734 "Mic", "CD", "Video", "Aux",
735 "Line", "Mix", "Mix Mono", "Phone"
736 };
737 static const char * const texts4[] = {
738 "pre 3D", "post 3D"
739 };
740 struct azf3328_mixer_reg reg;
741 const char * const *p = NULL;
742
743 snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
744 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
745 uinfo->count = (reg.reg == IDX_MIXER_REC_SELECT) ? 2 : 1;
746 uinfo->value.enumerated.items = reg.enum_c;
747 if (uinfo->value.enumerated.item > reg.enum_c - 1U)
748 uinfo->value.enumerated.item = reg.enum_c - 1U;
749 if (reg.reg == IDX_MIXER_ADVCTL2) {
750 switch(reg.lchan_shift) {
751 case 8: /* modem out sel */
752 p = texts1;
753 break;
754 case 9: /* mono sel source */
755 p = texts2;
756 break;
757 case 15: /* PCM Out Path */
758 p = texts4;
759 break;
760 }
761 } else
762 if (reg.reg == IDX_MIXER_REC_SELECT)
763 p = texts3;
764
765 strcpy(uinfo->value.enumerated.name, p[uinfo->value.enumerated.item]);
766 return 0;
767}
768
769static int
770snd_azf3328_get_mixer_enum(struct snd_kcontrol *kcontrol,
771 struct snd_ctl_elem_value *ucontrol)
772{
773 struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol);
774 struct azf3328_mixer_reg reg;
775 unsigned short val;
776
777 snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
778 val = snd_azf3328_mixer_inw(chip, reg.reg);
779 if (reg.reg == IDX_MIXER_REC_SELECT) {
780 ucontrol->value.enumerated.item[0] = (val >> 8) & (reg.enum_c - 1);
781 ucontrol->value.enumerated.item[1] = (val >> 0) & (reg.enum_c - 1);
782 } else
783 ucontrol->value.enumerated.item[0] = (val >> reg.lchan_shift) & (reg.enum_c - 1);
784
785 snd_azf3328_dbgmixer("get_enum: %02x is %04x -> %d|%d (shift %02d, enum_c %d)\n",
786 reg.reg, val, ucontrol->value.enumerated.item[0], ucontrol->value.enumerated.item[1],
787 reg.lchan_shift, reg.enum_c);
788 return 0;
789}
790
791static int
792snd_azf3328_put_mixer_enum(struct snd_kcontrol *kcontrol,
793 struct snd_ctl_elem_value *ucontrol)
794{
795 struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol);
796 struct azf3328_mixer_reg reg;
797 u16 oreg, nreg, val;
798
799 snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
800 oreg = snd_azf3328_mixer_inw(chip, reg.reg);
801 val = oreg;
802 if (reg.reg == IDX_MIXER_REC_SELECT) {
803 if (ucontrol->value.enumerated.item[0] > reg.enum_c - 1U ||
804 ucontrol->value.enumerated.item[1] > reg.enum_c - 1U)
805 return -EINVAL;
806 val = (ucontrol->value.enumerated.item[0] << 8) |
807 (ucontrol->value.enumerated.item[1] << 0);
808 } else {
809 if (ucontrol->value.enumerated.item[0] > reg.enum_c - 1U)
810 return -EINVAL;
811 val &= ~((reg.enum_c - 1) << reg.lchan_shift);
812 val |= (ucontrol->value.enumerated.item[0] << reg.lchan_shift);
813 }
814 snd_azf3328_mixer_outw(chip, reg.reg, val);
815 nreg = val;
816
817 snd_azf3328_dbgmixer("put_enum: %02x to %04x, oreg %04x\n", reg.reg, val, oreg);
818 return (nreg != oreg);
819}
820
821static struct snd_kcontrol_new snd_azf3328_mixer_controls[] __devinitdata = {
822 AZF3328_MIXER_SWITCH("Master Playback Switch", IDX_MIXER_PLAY_MASTER, 15, 1),
823 AZF3328_MIXER_VOL_STEREO("Master Playback Volume", IDX_MIXER_PLAY_MASTER, 0x1f, 1),
824 AZF3328_MIXER_SWITCH("PCM Playback Switch", IDX_MIXER_WAVEOUT, 15, 1),
825 AZF3328_MIXER_VOL_STEREO("PCM Playback Volume",
826 IDX_MIXER_WAVEOUT, 0x1f, 1),
827 AZF3328_MIXER_SWITCH("PCM 3D Bypass Playback Switch",
828 IDX_MIXER_ADVCTL2, 7, 1),
829 AZF3328_MIXER_SWITCH("FM Playback Switch", IDX_MIXER_FMSYNTH, 15, 1),
830 AZF3328_MIXER_VOL_STEREO("FM Playback Volume", IDX_MIXER_FMSYNTH, 0x1f, 1),
831 AZF3328_MIXER_SWITCH("CD Playback Switch", IDX_MIXER_CDAUDIO, 15, 1),
832 AZF3328_MIXER_VOL_STEREO("CD Playback Volume", IDX_MIXER_CDAUDIO, 0x1f, 1),
833 AZF3328_MIXER_SWITCH("Capture Switch", IDX_MIXER_REC_VOLUME, 15, 1),
834 AZF3328_MIXER_VOL_STEREO("Capture Volume", IDX_MIXER_REC_VOLUME, 0x0f, 0),
835 AZF3328_MIXER_ENUM("Capture Source", IDX_MIXER_REC_SELECT, 8, 0),
836 AZF3328_MIXER_SWITCH("Mic Playback Switch", IDX_MIXER_MIC, 15, 1),
837 AZF3328_MIXER_VOL_MONO("Mic Playback Volume", IDX_MIXER_MIC, 0x1f, 1),
838 AZF3328_MIXER_SWITCH("Mic Boost (+20dB)", IDX_MIXER_MIC, 6, 0),
839 AZF3328_MIXER_SWITCH("Line Playback Switch", IDX_MIXER_LINEIN, 15, 1),
840 AZF3328_MIXER_VOL_STEREO("Line Playback Volume", IDX_MIXER_LINEIN, 0x1f, 1),
841 AZF3328_MIXER_SWITCH("Beep Playback Switch", IDX_MIXER_PCBEEP, 15, 1),
842 AZF3328_MIXER_VOL_SPECIAL("Beep Playback Volume", IDX_MIXER_PCBEEP, 0x0f, 1, 1),
843 AZF3328_MIXER_SWITCH("Video Playback Switch", IDX_MIXER_VIDEO, 15, 1),
844 AZF3328_MIXER_VOL_STEREO("Video Playback Volume", IDX_MIXER_VIDEO, 0x1f, 1),
845 AZF3328_MIXER_SWITCH("Aux Playback Switch", IDX_MIXER_AUX, 15, 1),
846 AZF3328_MIXER_VOL_STEREO("Aux Playback Volume", IDX_MIXER_AUX, 0x1f, 1),
847 AZF3328_MIXER_SWITCH("Modem Playback Switch", IDX_MIXER_MODEMOUT, 15, 1),
848 AZF3328_MIXER_VOL_MONO("Modem Playback Volume", IDX_MIXER_MODEMOUT, 0x1f, 1),
849 AZF3328_MIXER_SWITCH("Modem Capture Switch", IDX_MIXER_MODEMIN, 15, 1),
850 AZF3328_MIXER_VOL_MONO("Modem Capture Volume", IDX_MIXER_MODEMIN, 0x1f, 1),
851 AZF3328_MIXER_ENUM("Mic Select", IDX_MIXER_ADVCTL2, 2, 8),
852 AZF3328_MIXER_ENUM("Mono Output Select", IDX_MIXER_ADVCTL2, 2, 9),
853 AZF3328_MIXER_ENUM("PCM Output Route", IDX_MIXER_ADVCTL2, 2, 15), /* PCM Out Path, place in front since it controls *both* 3D and Bass/Treble! */
854 AZF3328_MIXER_VOL_SPECIAL("Tone Control - Treble", IDX_MIXER_BASSTREBLE, 0x07, 1, 0),
855 AZF3328_MIXER_VOL_SPECIAL("Tone Control - Bass", IDX_MIXER_BASSTREBLE, 0x07, 9, 0),
856 AZF3328_MIXER_SWITCH("3D Control - Switch", IDX_MIXER_ADVCTL2, 13, 0),
857 AZF3328_MIXER_VOL_SPECIAL("3D Control - Width", IDX_MIXER_ADVCTL1, 0x07, 1, 0), /* "3D Width" */
858 AZF3328_MIXER_VOL_SPECIAL("3D Control - Depth", IDX_MIXER_ADVCTL1, 0x03, 8, 0), /* "Hifi 3D" */
859#if MIXER_TESTING
860 AZF3328_MIXER_SWITCH("0", IDX_MIXER_ADVCTL2, 0, 0),
861 AZF3328_MIXER_SWITCH("1", IDX_MIXER_ADVCTL2, 1, 0),
862 AZF3328_MIXER_SWITCH("2", IDX_MIXER_ADVCTL2, 2, 0),
863 AZF3328_MIXER_SWITCH("3", IDX_MIXER_ADVCTL2, 3, 0),
864 AZF3328_MIXER_SWITCH("4", IDX_MIXER_ADVCTL2, 4, 0),
865 AZF3328_MIXER_SWITCH("5", IDX_MIXER_ADVCTL2, 5, 0),
866 AZF3328_MIXER_SWITCH("6", IDX_MIXER_ADVCTL2, 6, 0),
867 AZF3328_MIXER_SWITCH("7", IDX_MIXER_ADVCTL2, 7, 0),
868 AZF3328_MIXER_SWITCH("8", IDX_MIXER_ADVCTL2, 8, 0),
869 AZF3328_MIXER_SWITCH("9", IDX_MIXER_ADVCTL2, 9, 0),
870 AZF3328_MIXER_SWITCH("10", IDX_MIXER_ADVCTL2, 10, 0),
871 AZF3328_MIXER_SWITCH("11", IDX_MIXER_ADVCTL2, 11, 0),
872 AZF3328_MIXER_SWITCH("12", IDX_MIXER_ADVCTL2, 12, 0),
873 AZF3328_MIXER_SWITCH("13", IDX_MIXER_ADVCTL2, 13, 0),
874 AZF3328_MIXER_SWITCH("14", IDX_MIXER_ADVCTL2, 14, 0),
875 AZF3328_MIXER_SWITCH("15", IDX_MIXER_ADVCTL2, 15, 0),
876#endif
877};
878
879static u16 __devinitdata snd_azf3328_init_values[][2] = {
880 { IDX_MIXER_PLAY_MASTER, MIXER_MUTE_MASK|0x1f1f },
881 { IDX_MIXER_MODEMOUT, MIXER_MUTE_MASK|0x1f1f },
882 { IDX_MIXER_BASSTREBLE, 0x0000 },
883 { IDX_MIXER_PCBEEP, MIXER_MUTE_MASK|0x1f1f },
884 { IDX_MIXER_MODEMIN, MIXER_MUTE_MASK|0x1f1f },
885 { IDX_MIXER_MIC, MIXER_MUTE_MASK|0x001f },
886 { IDX_MIXER_LINEIN, MIXER_MUTE_MASK|0x1f1f },
887 { IDX_MIXER_CDAUDIO, MIXER_MUTE_MASK|0x1f1f },
888 { IDX_MIXER_VIDEO, MIXER_MUTE_MASK|0x1f1f },
889 { IDX_MIXER_AUX, MIXER_MUTE_MASK|0x1f1f },
890 { IDX_MIXER_WAVEOUT, MIXER_MUTE_MASK|0x1f1f },
891 { IDX_MIXER_FMSYNTH, MIXER_MUTE_MASK|0x1f1f },
892 { IDX_MIXER_REC_VOLUME, MIXER_MUTE_MASK|0x0707 },
893};
894
895static int __devinit
896snd_azf3328_mixer_new(struct snd_azf3328 *chip)
897{
898 struct snd_card *card;
899 const struct snd_kcontrol_new *sw;
900 unsigned int idx;
901 int err;
902
903 snd_azf3328_dbgcallenter();
904 if (snd_BUG_ON(!chip || !chip->card))
905 return -EINVAL;
906
907 card = chip->card;
908
909 /* mixer reset */
910 snd_azf3328_mixer_outw(chip, IDX_MIXER_RESET, 0x0000);
911
912 /* mute and zero volume channels */
913 for (idx = 0; idx < ARRAY_SIZE(snd_azf3328_init_values); ++idx) {
914 snd_azf3328_mixer_outw(chip,
915 snd_azf3328_init_values[idx][0],
916 snd_azf3328_init_values[idx][1]);
917 }
918
919 /* add mixer controls */
920 sw = snd_azf3328_mixer_controls;
921 for (idx = 0; idx < ARRAY_SIZE(snd_azf3328_mixer_controls);
922 ++idx, ++sw) {
923 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(sw, chip))) < 0)
924 return err;
925 }
926 snd_component_add(card, "AZF3328 mixer");
927 strcpy(card->mixername, "AZF3328 mixer");
928
929 snd_azf3328_dbgcallleave();
930 return 0;
931}
932
933static int
934snd_azf3328_hw_params(struct snd_pcm_substream *substream,
935 struct snd_pcm_hw_params *hw_params)
936{
937 int res;
938 snd_azf3328_dbgcallenter();
939 res = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
940 snd_azf3328_dbgcallleave();
941 return res;
942}
943
944static int
945snd_azf3328_hw_free(struct snd_pcm_substream *substream)
946{
947 snd_azf3328_dbgcallenter();
948 snd_pcm_lib_free_pages(substream);
949 snd_azf3328_dbgcallleave();
950 return 0;
951}
952
953static void
954snd_azf3328_codec_setfmt(struct snd_azf3328_codec_data *codec,
955 enum azf_freq_t bitrate,
956 unsigned int format_width,
957 unsigned int channels
958)
959{
960 unsigned long flags;
961 u16 val = 0xff00;
962 u8 freq = 0;
963
964 snd_azf3328_dbgcallenter();
965 switch (bitrate) {
966#define AZF_FMT_XLATE(in_freq, out_bits) \
967 do { \
968 case AZF_FREQ_ ## in_freq: \
969 freq = SOUNDFORMAT_FREQ_ ## out_bits; \
970 break; \
971 } while (0);
972 AZF_FMT_XLATE(4000, SUSPECTED_4000)
973 AZF_FMT_XLATE(4800, SUSPECTED_4800)
974 /* the AZF3328 names it "5510" for some strange reason: */
975 AZF_FMT_XLATE(5512, 5510)
976 AZF_FMT_XLATE(6620, 6620)
977 AZF_FMT_XLATE(8000, 8000)
978 AZF_FMT_XLATE(9600, 9600)
979 AZF_FMT_XLATE(11025, 11025)
980 AZF_FMT_XLATE(13240, SUSPECTED_13240)
981 AZF_FMT_XLATE(16000, 16000)
982 AZF_FMT_XLATE(22050, 22050)
983 AZF_FMT_XLATE(32000, 32000)
984 default:
985 snd_printk(KERN_WARNING "unknown bitrate %d, assuming 44.1kHz!\n", bitrate);
986 /* fall-through */
987 AZF_FMT_XLATE(44100, 44100)
988 AZF_FMT_XLATE(48000, 48000)
989 AZF_FMT_XLATE(66200, SUSPECTED_66200)
990#undef AZF_FMT_XLATE
991 }
992 /* val = 0xff07; 3m27.993s (65301Hz; -> 64000Hz???) hmm, 66120, 65967, 66123 */
993 /* val = 0xff09; 17m15.098s (13123,478Hz; -> 12000Hz???) hmm, 13237.2Hz? */
994 /* val = 0xff0a; 47m30.599s (4764,891Hz; -> 4800Hz???) yup, 4803Hz */
995 /* val = 0xff0c; 57m0.510s (4010,263Hz; -> 4000Hz???) yup, 4003Hz */
996 /* val = 0xff05; 5m11.556s (... -> 44100Hz) */
997 /* val = 0xff03; 10m21.529s (21872,463Hz; -> 22050Hz???) */
998 /* val = 0xff0f; 20m41.883s (10937,993Hz; -> 11025Hz???) */
999 /* val = 0xff0d; 41m23.135s (5523,600Hz; -> 5512Hz???) */
1000 /* val = 0xff0e; 28m30.777s (8017Hz; -> 8000Hz???) */
1001
1002 val |= freq;
1003
1004 if (channels == 2)
1005 val |= SOUNDFORMAT_FLAG_2CHANNELS;
1006
1007 if (format_width == 16)
1008 val |= SOUNDFORMAT_FLAG_16BIT;
1009
1010 spin_lock_irqsave(codec->lock, flags);
1011
1012 /* set bitrate/format */
1013 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_SOUNDFORMAT, val);
1014
1015 /* changing the bitrate/format settings switches off the
1016 * audio output with an annoying click in case of 8/16bit format change
1017 * (maybe shutting down DAC/ADC?), thus immediately
1018 * do some tweaking to reenable it and get rid of the clicking
1019 * (FIXME: yes, it works, but what exactly am I doing here?? :)
1020 * FIXME: does this have some side effects for full-duplex
1021 * or other dramatic side effects? */
1022 /* do it for non-capture codecs only */
1023 if (codec->type != AZF_CODEC_CAPTURE)
1024 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1025 snd_azf3328_codec_inw(codec, IDX_IO_CODEC_DMA_FLAGS) |
1026 DMA_RUN_SOMETHING1 |
1027 DMA_RUN_SOMETHING2 |
1028 SOMETHING_ALMOST_ALWAYS_SET |
1029 DMA_EPILOGUE_SOMETHING |
1030 DMA_SOMETHING_ELSE
1031 );
1032
1033 spin_unlock_irqrestore(codec->lock, flags);
1034 snd_azf3328_dbgcallleave();
1035}
1036
1037static inline void
1038snd_azf3328_codec_setfmt_lowpower(struct snd_azf3328_codec_data *codec
1039)
1040{
1041 /* choose lowest frequency for low power consumption.
1042 * While this will cause louder noise due to rather coarse frequency,
1043 * it should never matter since output should always
1044 * get disabled properly when idle anyway. */
1045 snd_azf3328_codec_setfmt(codec, AZF_FREQ_4000, 8, 1);
1046}
1047
1048static void
1049snd_azf3328_ctrl_reg_6AH_update(struct snd_azf3328 *chip,
1050 unsigned bitmask,
1051 bool enable
1052)
1053{
1054 bool do_mask = !enable;
1055 if (do_mask)
1056 chip->shadow_reg_ctrl_6AH |= bitmask;
1057 else
1058 chip->shadow_reg_ctrl_6AH &= ~bitmask;
1059 snd_azf3328_dbgcodec("6AH_update mask 0x%04x do_mask %d: val 0x%04x\n",
1060 bitmask, do_mask, chip->shadow_reg_ctrl_6AH);
1061 snd_azf3328_ctrl_outw(chip, IDX_IO_6AH, chip->shadow_reg_ctrl_6AH);
1062}
1063
1064static inline void
1065snd_azf3328_ctrl_enable_codecs(struct snd_azf3328 *chip, bool enable)
1066{
1067 snd_azf3328_dbgcodec("codec_enable %d\n", enable);
1068 /* no idea what exactly is being done here, but I strongly assume it's
1069 * PM related */
1070 snd_azf3328_ctrl_reg_6AH_update(
1071 chip, IO_6A_PAUSE_PLAYBACK_BIT8, enable
1072 );
1073}
1074
1075static void
1076snd_azf3328_ctrl_codec_activity(struct snd_azf3328 *chip,
1077 enum snd_azf3328_codec_type codec_type,
1078 bool enable
1079)
1080{
1081 struct snd_azf3328_codec_data *codec = &chip->codecs[codec_type];
1082 bool need_change = (codec->running != enable);
1083
1084 snd_azf3328_dbgcodec(
1085 "codec_activity: %s codec, enable %d, need_change %d\n",
1086 codec->name, enable, need_change
1087 );
1088 if (need_change) {
1089 static const struct {
1090 enum snd_azf3328_codec_type other1;
1091 enum snd_azf3328_codec_type other2;
1092 } peer_codecs[3] =
1093 { { AZF_CODEC_CAPTURE, AZF_CODEC_I2S_OUT },
1094 { AZF_CODEC_PLAYBACK, AZF_CODEC_I2S_OUT },
1095 { AZF_CODEC_PLAYBACK, AZF_CODEC_CAPTURE } };
1096 bool call_function;
1097
1098 if (enable)
1099 /* if enable codec, call enable_codecs func
1100 to enable codec supply... */
1101 call_function = 1;
1102 else {
1103 /* ...otherwise call enable_codecs func
1104 (which globally shuts down operation of codecs)
1105 only in case the other codecs are currently
1106 not active either! */
1107 call_function =
1108 ((!chip->codecs[peer_codecs[codec_type].other1]
1109 .running)
1110 && (!chip->codecs[peer_codecs[codec_type].other2]
1111 .running));
1112 }
1113 if (call_function)
1114 snd_azf3328_ctrl_enable_codecs(chip, enable);
1115
1116 /* ...and adjust clock, too
1117 * (reduce noise and power consumption) */
1118 if (!enable)
1119 snd_azf3328_codec_setfmt_lowpower(codec);
1120 codec->running = enable;
1121 }
1122}
1123
1124static void
1125snd_azf3328_codec_setdmaa(struct snd_azf3328_codec_data *codec,
1126 unsigned long addr,
1127 unsigned int count,
1128 unsigned int size
1129)
1130{
1131 snd_azf3328_dbgcallenter();
1132 if (!codec->running) {
1133 /* AZF3328 uses a two buffer pointer DMA transfer approach */
1134
1135 unsigned long flags, addr_area2;
1136
1137 /* width 32bit (prevent overflow): */
1138 u32 count_areas, lengths;
1139
1140 count_areas = size/2;
1141 addr_area2 = addr+count_areas;
1142 snd_azf3328_dbgcodec("setdma: buffers %08lx[%u] / %08lx[%u]\n",
1143 addr, count_areas, addr_area2, count_areas);
1144
1145 count_areas--; /* max. index */
1146
1147 /* build combined I/O buffer length word */
1148 lengths = (count_areas << 16) | (count_areas);
1149 spin_lock_irqsave(codec->lock, flags);
1150 snd_azf3328_codec_outl(codec, IDX_IO_CODEC_DMA_START_1, addr);
1151 snd_azf3328_codec_outl(codec, IDX_IO_CODEC_DMA_START_2,
1152 addr_area2);
1153 snd_azf3328_codec_outl(codec, IDX_IO_CODEC_DMA_LENGTHS,
1154 lengths);
1155 spin_unlock_irqrestore(codec->lock, flags);
1156 }
1157 snd_azf3328_dbgcallleave();
1158}
1159
1160static int
1161snd_azf3328_pcm_prepare(struct snd_pcm_substream *substream)
1162{
1163 struct snd_pcm_runtime *runtime = substream->runtime;
1164 struct snd_azf3328_codec_data *codec = runtime->private_data;
1165#if 0
1166 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
1167 unsigned int count = snd_pcm_lib_period_bytes(substream);
1168#endif
1169
1170 snd_azf3328_dbgcallenter();
1171
1172 codec->dma_base = runtime->dma_addr;
1173
1174#if 0
1175 snd_azf3328_codec_setfmt(codec,
1176 runtime->rate,
1177 snd_pcm_format_width(runtime->format),
1178 runtime->channels);
1179 snd_azf3328_codec_setdmaa(codec,
1180 runtime->dma_addr, count, size);
1181#endif
1182 snd_azf3328_dbgcallleave();
1183 return 0;
1184}
1185
1186static int
1187snd_azf3328_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
1188{
1189 struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
1190 struct snd_pcm_runtime *runtime = substream->runtime;
1191 struct snd_azf3328_codec_data *codec = runtime->private_data;
1192 int result = 0;
1193 u16 flags1;
1194 bool previously_muted = 0;
1195 bool is_main_mixer_playback_codec = (AZF_CODEC_PLAYBACK == codec->type);
1196
1197 snd_azf3328_dbgcalls("snd_azf3328_pcm_trigger cmd %d\n", cmd);
1198
1199 switch (cmd) {
1200 case SNDRV_PCM_TRIGGER_START:
1201 snd_azf3328_dbgcodec("START %s\n", codec->name);
1202
1203 if (is_main_mixer_playback_codec) {
1204 /* mute WaveOut (avoid clicking during setup) */
1205 previously_muted =
1206 snd_azf3328_mixer_set_mute(
1207 chip, IDX_MIXER_WAVEOUT, 1
1208 );
1209 }
1210
1211 snd_azf3328_codec_setfmt(codec,
1212 runtime->rate,
1213 snd_pcm_format_width(runtime->format),
1214 runtime->channels);
1215
1216 spin_lock(codec->lock);
1217 /* first, remember current value: */
1218 flags1 = snd_azf3328_codec_inw(codec, IDX_IO_CODEC_DMA_FLAGS);
1219
1220 /* stop transfer */
1221 flags1 &= ~DMA_RESUME;
1222 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
1223
1224 /* FIXME: clear interrupts or what??? */
1225 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_IRQTYPE, 0xffff);
1226 spin_unlock(codec->lock);
1227
1228 snd_azf3328_codec_setdmaa(codec, runtime->dma_addr,
1229 snd_pcm_lib_period_bytes(substream),
1230 snd_pcm_lib_buffer_bytes(substream)
1231 );
1232
1233 spin_lock(codec->lock);
1234#ifdef WIN9X
1235 /* FIXME: enable playback/recording??? */
1236 flags1 |= DMA_RUN_SOMETHING1 | DMA_RUN_SOMETHING2;
1237 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
1238
1239 /* start transfer again */
1240 /* FIXME: what is this value (0x0010)??? */
1241 flags1 |= DMA_RESUME | DMA_EPILOGUE_SOMETHING;
1242 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
1243#else /* NT4 */
1244 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1245 0x0000);
1246 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1247 DMA_RUN_SOMETHING1);
1248 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1249 DMA_RUN_SOMETHING1 |
1250 DMA_RUN_SOMETHING2);
1251 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1252 DMA_RESUME |
1253 SOMETHING_ALMOST_ALWAYS_SET |
1254 DMA_EPILOGUE_SOMETHING |
1255 DMA_SOMETHING_ELSE);
1256#endif
1257 spin_unlock(codec->lock);
1258 snd_azf3328_ctrl_codec_activity(chip, codec->type, 1);
1259
1260 if (is_main_mixer_playback_codec) {
1261 /* now unmute WaveOut */
1262 if (!previously_muted)
1263 snd_azf3328_mixer_set_mute(
1264 chip, IDX_MIXER_WAVEOUT, 0
1265 );
1266 }
1267
1268 snd_azf3328_dbgcodec("STARTED %s\n", codec->name);
1269 break;
1270 case SNDRV_PCM_TRIGGER_RESUME:
1271 snd_azf3328_dbgcodec("RESUME %s\n", codec->name);
1272 /* resume codec if we were active */
1273 spin_lock(codec->lock);
1274 if (codec->running)
1275 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1276 snd_azf3328_codec_inw(
1277 codec, IDX_IO_CODEC_DMA_FLAGS
1278 ) | DMA_RESUME
1279 );
1280 spin_unlock(codec->lock);
1281 break;
1282 case SNDRV_PCM_TRIGGER_STOP:
1283 snd_azf3328_dbgcodec("STOP %s\n", codec->name);
1284
1285 if (is_main_mixer_playback_codec) {
1286 /* mute WaveOut (avoid clicking during setup) */
1287 previously_muted =
1288 snd_azf3328_mixer_set_mute(
1289 chip, IDX_MIXER_WAVEOUT, 1
1290 );
1291 }
1292
1293 spin_lock(codec->lock);
1294 /* first, remember current value: */
1295 flags1 = snd_azf3328_codec_inw(codec, IDX_IO_CODEC_DMA_FLAGS);
1296
1297 /* stop transfer */
1298 flags1 &= ~DMA_RESUME;
1299 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
1300
1301 /* hmm, is this really required? we're resetting the same bit
1302 * immediately thereafter... */
1303 flags1 |= DMA_RUN_SOMETHING1;
1304 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
1305
1306 flags1 &= ~DMA_RUN_SOMETHING1;
1307 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
1308 spin_unlock(codec->lock);
1309 snd_azf3328_ctrl_codec_activity(chip, codec->type, 0);
1310
1311 if (is_main_mixer_playback_codec) {
1312 /* now unmute WaveOut */
1313 if (!previously_muted)
1314 snd_azf3328_mixer_set_mute(
1315 chip, IDX_MIXER_WAVEOUT, 0
1316 );
1317 }
1318
1319 snd_azf3328_dbgcodec("STOPPED %s\n", codec->name);
1320 break;
1321 case SNDRV_PCM_TRIGGER_SUSPEND:
1322 snd_azf3328_dbgcodec("SUSPEND %s\n", codec->name);
1323 /* make sure codec is stopped */
1324 snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
1325 snd_azf3328_codec_inw(
1326 codec, IDX_IO_CODEC_DMA_FLAGS
1327 ) & ~DMA_RESUME
1328 );
1329 break;
1330 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1331 snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_PUSH NIY!\n");
1332 break;
1333 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1334 snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_RELEASE NIY!\n");
1335 break;
1336 default:
1337 snd_printk(KERN_ERR "FIXME: unknown trigger mode!\n");
1338 return -EINVAL;
1339 }
1340
1341 snd_azf3328_dbgcallleave();
1342 return result;
1343}
1344
1345static snd_pcm_uframes_t
1346snd_azf3328_pcm_pointer(struct snd_pcm_substream *substream
1347)
1348{
1349 const struct snd_azf3328_codec_data *codec =
1350 substream->runtime->private_data;
1351 unsigned long result;
1352 snd_pcm_uframes_t frmres;
1353
1354 result = snd_azf3328_codec_inl(codec, IDX_IO_CODEC_DMA_CURRPOS);
1355
1356 /* calculate offset */
1357#ifdef QUERY_HARDWARE
1358 result -= snd_azf3328_codec_inl(codec, IDX_IO_CODEC_DMA_START_1);
1359#else
1360 result -= codec->dma_base;
1361#endif
1362 frmres = bytes_to_frames( substream->runtime, result);
1363 snd_azf3328_dbgcodec("%08li %s @ 0x%8lx, frames %8ld\n",
1364 jiffies, codec->name, result, frmres);
1365 return frmres;
1366}
1367
1368/******************************************************************/
1369
1370#ifdef SUPPORT_GAMEPORT
1371static inline void
1372snd_azf3328_gameport_irq_enable(struct snd_azf3328 *chip,
1373 bool enable
1374)
1375{
1376 snd_azf3328_io_reg_setb(
1377 chip->game_io+IDX_GAME_HWCONFIG,
1378 GAME_HWCFG_IRQ_ENABLE,
1379 enable
1380 );
1381}
1382
1383static inline void
1384snd_azf3328_gameport_legacy_address_enable(struct snd_azf3328 *chip,
1385 bool enable
1386)
1387{
1388 snd_azf3328_io_reg_setb(
1389 chip->game_io+IDX_GAME_HWCONFIG,
1390 GAME_HWCFG_LEGACY_ADDRESS_ENABLE,
1391 enable
1392 );
1393}
1394
1395static void
1396snd_azf3328_gameport_set_counter_frequency(struct snd_azf3328 *chip,
1397 unsigned int freq_cfg
1398)
1399{
1400 snd_azf3328_io_reg_setb(
1401 chip->game_io+IDX_GAME_HWCONFIG,
1402 0x02,
1403 (freq_cfg & 1) != 0
1404 );
1405 snd_azf3328_io_reg_setb(
1406 chip->game_io+IDX_GAME_HWCONFIG,
1407 0x04,
1408 (freq_cfg & 2) != 0
1409 );
1410}
1411
1412static inline void
1413snd_azf3328_gameport_axis_circuit_enable(struct snd_azf3328 *chip, bool enable)
1414{
1415 snd_azf3328_ctrl_reg_6AH_update(
1416 chip, IO_6A_SOMETHING2_GAMEPORT, enable
1417 );
1418}
1419
1420static inline void
1421snd_azf3328_gameport_interrupt(struct snd_azf3328 *chip)
1422{
1423 /*
1424 * skeleton handler only
1425 * (we do not want axis reading in interrupt handler - too much load!)
1426 */
1427 snd_azf3328_dbggame("gameport irq\n");
1428
1429 /* this should ACK the gameport IRQ properly, hopefully. */
1430 snd_azf3328_game_inw(chip, IDX_GAME_AXIS_VALUE);
1431}
1432
1433static int
1434snd_azf3328_gameport_open(struct gameport *gameport, int mode)
1435{
1436 struct snd_azf3328 *chip = gameport_get_port_data(gameport);
1437 int res;
1438
1439 snd_azf3328_dbggame("gameport_open, mode %d\n", mode);
1440 switch (mode) {
1441 case GAMEPORT_MODE_COOKED:
1442 case GAMEPORT_MODE_RAW:
1443 res = 0;
1444 break;
1445 default:
1446 res = -1;
1447 break;
1448 }
1449
1450 snd_azf3328_gameport_set_counter_frequency(chip,
1451 GAME_HWCFG_ADC_COUNTER_FREQ_STD);
1452 snd_azf3328_gameport_axis_circuit_enable(chip, (res == 0));
1453
1454 return res;
1455}
1456
1457static void
1458snd_azf3328_gameport_close(struct gameport *gameport)
1459{
1460 struct snd_azf3328 *chip = gameport_get_port_data(gameport);
1461
1462 snd_azf3328_dbggame("gameport_close\n");
1463 snd_azf3328_gameport_set_counter_frequency(chip,
1464 GAME_HWCFG_ADC_COUNTER_FREQ_1_200);
1465 snd_azf3328_gameport_axis_circuit_enable(chip, 0);
1466}
1467
1468static int
1469snd_azf3328_gameport_cooked_read(struct gameport *gameport,
1470 int *axes,
1471 int *buttons
1472)
1473{
1474 struct snd_azf3328 *chip = gameport_get_port_data(gameport);
1475 int i;
1476 u8 val;
1477 unsigned long flags;
1478
1479 if (snd_BUG_ON(!chip))
1480 return 0;
1481
1482 spin_lock_irqsave(&chip->reg_lock, flags);
1483 val = snd_azf3328_game_inb(chip, IDX_GAME_LEGACY_COMPATIBLE);
1484 *buttons = (~(val) >> 4) & 0xf;
1485
1486 /* ok, this one is a bit dirty: cooked_read is being polled by a timer,
1487 * thus we're atomic and cannot actively wait in here
1488 * (which would be useful for us since it probably would be better
1489 * to trigger a measurement in here, then wait a short amount of
1490 * time until it's finished, then read values of _this_ measurement).
1491 *
1492 * Thus we simply resort to reading values if they're available already
1493 * and trigger the next measurement.
1494 */
1495
1496 val = snd_azf3328_game_inb(chip, IDX_GAME_AXES_CONFIG);
1497 if (val & GAME_AXES_SAMPLING_READY) {
1498 for (i = 0; i < ARRAY_SIZE(chip->axes); ++i) {
1499 /* configure the axis to read */
1500 val = (i << 4) | 0x0f;
1501 snd_azf3328_game_outb(chip, IDX_GAME_AXES_CONFIG, val);
1502
1503 chip->axes[i] = snd_azf3328_game_inw(
1504 chip, IDX_GAME_AXIS_VALUE
1505 );
1506 }
1507 }
1508
1509 /* trigger next sampling of axes, to be evaluated the next time we
1510 * enter this function */
1511
1512 /* for some very, very strange reason we cannot enable
1513 * Measurement Ready monitoring for all axes here,
1514 * at least not when only one joystick connected */
1515 val = 0x03; /* we're able to monitor axes 1 and 2 only */
1516 snd_azf3328_game_outb(chip, IDX_GAME_AXES_CONFIG, val);
1517
1518 snd_azf3328_game_outw(chip, IDX_GAME_AXIS_VALUE, 0xffff);
1519 spin_unlock_irqrestore(&chip->reg_lock, flags);
1520
1521 for (i = 0; i < ARRAY_SIZE(chip->axes); i++) {
1522 axes[i] = chip->axes[i];
1523 if (axes[i] == 0xffff)
1524 axes[i] = -1;
1525 }
1526
1527 snd_azf3328_dbggame("cooked_read: axes %d %d %d %d buttons %d\n",
1528 axes[0], axes[1], axes[2], axes[3], *buttons
1529 );
1530
1531 return 0;
1532}
1533
1534static int __devinit
1535snd_azf3328_gameport(struct snd_azf3328 *chip, int dev)
1536{
1537 struct gameport *gp;
1538
1539 chip->gameport = gp = gameport_allocate_port();
1540 if (!gp) {
1541 printk(KERN_ERR "azt3328: cannot alloc memory for gameport\n");
1542 return -ENOMEM;
1543 }
1544
1545 gameport_set_name(gp, "AZF3328 Gameport");
1546 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
1547 gameport_set_dev_parent(gp, &chip->pci->dev);
1548 gp->io = chip->game_io;
1549 gameport_set_port_data(gp, chip);
1550
1551 gp->open = snd_azf3328_gameport_open;
1552 gp->close = snd_azf3328_gameport_close;
1553 gp->fuzz = 16; /* seems ok */
1554 gp->cooked_read = snd_azf3328_gameport_cooked_read;
1555
1556 /* DISABLE legacy address: we don't need it! */
1557 snd_azf3328_gameport_legacy_address_enable(chip, 0);
1558
1559 snd_azf3328_gameport_set_counter_frequency(chip,
1560 GAME_HWCFG_ADC_COUNTER_FREQ_1_200);
1561 snd_azf3328_gameport_axis_circuit_enable(chip, 0);
1562
1563 gameport_register_port(chip->gameport);
1564
1565 return 0;
1566}
1567
1568static void
1569snd_azf3328_gameport_free(struct snd_azf3328 *chip)
1570{
1571 if (chip->gameport) {
1572 gameport_unregister_port(chip->gameport);
1573 chip->gameport = NULL;
1574 }
1575 snd_azf3328_gameport_irq_enable(chip, 0);
1576}
1577#else
1578static inline int
1579snd_azf3328_gameport(struct snd_azf3328 *chip, int dev) { return -ENOSYS; }
1580static inline void
1581snd_azf3328_gameport_free(struct snd_azf3328 *chip) { }
1582static inline void
1583snd_azf3328_gameport_interrupt(struct snd_azf3328 *chip)
1584{
1585 printk(KERN_WARNING "huh, game port IRQ occurred!?\n");
1586}
1587#endif /* SUPPORT_GAMEPORT */
1588
1589/******************************************************************/
1590
1591static inline void
1592snd_azf3328_irq_log_unknown_type(u8 which)
1593{
1594 snd_azf3328_dbgcodec(
1595 "azt3328: unknown IRQ type (%x) occurred, please report!\n",
1596 which
1597 );
1598}
1599
1600static inline void
1601snd_azf3328_pcm_interrupt(const struct snd_azf3328_codec_data *first_codec,
1602 u8 status
1603)
1604{
1605 u8 which;
1606 enum snd_azf3328_codec_type codec_type;
1607 const struct snd_azf3328_codec_data *codec = first_codec;
1608
1609 for (codec_type = AZF_CODEC_PLAYBACK;
1610 codec_type <= AZF_CODEC_I2S_OUT;
1611 ++codec_type, ++codec) {
1612
1613 /* skip codec if there's no interrupt for it */
1614 if (!(status & (1 << codec_type)))
1615 continue;
1616
1617 spin_lock(codec->lock);
1618 which = snd_azf3328_codec_inb(codec, IDX_IO_CODEC_IRQTYPE);
1619 /* ack all IRQ types immediately */
1620 snd_azf3328_codec_outb(codec, IDX_IO_CODEC_IRQTYPE, which);
1621 spin_unlock(codec->lock);
1622
1623 if (codec->substream) {
1624 snd_pcm_period_elapsed(codec->substream);
1625 snd_azf3328_dbgcodec("%s period done (#%x), @ %x\n",
1626 codec->name,
1627 which,
1628 snd_azf3328_codec_inl(
1629 codec, IDX_IO_CODEC_DMA_CURRPOS
1630 )
1631 );
1632 } else
1633 printk(KERN_WARNING "azt3328: irq handler problem!\n");
1634 if (which & IRQ_SOMETHING)
1635 snd_azf3328_irq_log_unknown_type(which);
1636 }
1637}
1638
1639static irqreturn_t
1640snd_azf3328_interrupt(int irq, void *dev_id)
1641{
1642 struct snd_azf3328 *chip = dev_id;
1643 u8 status;
1644#if DEBUG_CODEC
1645 static unsigned long irq_count;
1646#endif
1647
1648 status = snd_azf3328_ctrl_inb(chip, IDX_IO_IRQSTATUS);
1649
1650 /* fast path out, to ease interrupt sharing */
1651 if (!(status &
1652 (IRQ_PLAYBACK|IRQ_RECORDING|IRQ_I2S_OUT
1653 |IRQ_GAMEPORT|IRQ_MPU401|IRQ_TIMER)
1654 ))
1655 return IRQ_NONE; /* must be interrupt for another device */
1656
1657 snd_azf3328_dbgcodec(
1658 "irq_count %ld! IDX_IO_IRQSTATUS %04x\n",
1659 irq_count++ /* debug-only */,
1660 status
1661 );
1662
1663 if (status & IRQ_TIMER) {
1664 /* snd_azf3328_dbgcodec("timer %ld\n",
1665 snd_azf3328_codec_inl(chip, IDX_IO_TIMER_VALUE)
1666 & TIMER_VALUE_MASK
1667 ); */
1668 if (chip->timer)
1669 snd_timer_interrupt(chip->timer, chip->timer->sticks);
1670 /* ACK timer */
1671 spin_lock(&chip->reg_lock);
1672 snd_azf3328_ctrl_outb(chip, IDX_IO_TIMER_VALUE + 3, 0x07);
1673 spin_unlock(&chip->reg_lock);
1674 snd_azf3328_dbgcodec("azt3328: timer IRQ\n");
1675 }
1676
1677 if (status & (IRQ_PLAYBACK|IRQ_RECORDING|IRQ_I2S_OUT))
1678 snd_azf3328_pcm_interrupt(chip->codecs, status);
1679
1680 if (status & IRQ_GAMEPORT)
1681 snd_azf3328_gameport_interrupt(chip);
1682
1683 /* MPU401 has less critical IRQ requirements
1684 * than timer and playback/recording, right? */
1685 if (status & IRQ_MPU401) {
1686 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
1687
1688 /* hmm, do we have to ack the IRQ here somehow?
1689 * If so, then I don't know how yet... */
1690 snd_azf3328_dbgcodec("azt3328: MPU401 IRQ\n");
1691 }
1692 return IRQ_HANDLED;
1693}
1694
1695/*****************************************************************/
1696
1697/* as long as we think we have identical snd_pcm_hardware parameters
1698 for playback, capture and i2s out, we can use the same physical struct
1699 since the struct is simply being copied into a member.
1700*/
1701static const struct snd_pcm_hardware snd_azf3328_hardware =
1702{
1703 /* FIXME!! Correct? */
1704 .info = SNDRV_PCM_INFO_MMAP |
1705 SNDRV_PCM_INFO_INTERLEAVED |
1706 SNDRV_PCM_INFO_MMAP_VALID,
1707 .formats = SNDRV_PCM_FMTBIT_S8 |
1708 SNDRV_PCM_FMTBIT_U8 |
1709 SNDRV_PCM_FMTBIT_S16_LE |
1710 SNDRV_PCM_FMTBIT_U16_LE,
1711 .rates = SNDRV_PCM_RATE_5512 |
1712 SNDRV_PCM_RATE_8000_48000 |
1713 SNDRV_PCM_RATE_KNOT,
1714 .rate_min = AZF_FREQ_4000,
1715 .rate_max = AZF_FREQ_66200,
1716 .channels_min = 1,
1717 .channels_max = 2,
1718 .buffer_bytes_max = (64*1024),
1719 .period_bytes_min = 1024,
1720 .period_bytes_max = (32*1024),
1721 /* We simply have two DMA areas (instead of a list of descriptors
1722 such as other cards); I believe that this is a fixed hardware
1723 attribute and there isn't much driver magic to be done to expand it.
1724 Thus indicate that we have at least and at most 2 periods. */
1725 .periods_min = 2,
1726 .periods_max = 2,
1727 /* FIXME: maybe that card actually has a FIFO?
1728 * Hmm, it seems newer revisions do have one, but we still don't know
1729 * its size... */
1730 .fifo_size = 0,
1731};
1732
1733
1734static unsigned int snd_azf3328_fixed_rates[] = {
1735 AZF_FREQ_4000,
1736 AZF_FREQ_4800,
1737 AZF_FREQ_5512,
1738 AZF_FREQ_6620,
1739 AZF_FREQ_8000,
1740 AZF_FREQ_9600,
1741 AZF_FREQ_11025,
1742 AZF_FREQ_13240,
1743 AZF_FREQ_16000,
1744 AZF_FREQ_22050,
1745 AZF_FREQ_32000,
1746 AZF_FREQ_44100,
1747 AZF_FREQ_48000,
1748 AZF_FREQ_66200
1749};
1750
1751static struct snd_pcm_hw_constraint_list snd_azf3328_hw_constraints_rates = {
1752 .count = ARRAY_SIZE(snd_azf3328_fixed_rates),
1753 .list = snd_azf3328_fixed_rates,
1754 .mask = 0,
1755};
1756
1757/*****************************************************************/
1758
1759static int
1760snd_azf3328_pcm_open(struct snd_pcm_substream *substream,
1761 enum snd_azf3328_codec_type codec_type
1762)
1763{
1764 struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
1765 struct snd_pcm_runtime *runtime = substream->runtime;
1766 struct snd_azf3328_codec_data *codec = &chip->codecs[codec_type];
1767
1768 snd_azf3328_dbgcallenter();
1769 codec->substream = substream;
1770
1771 /* same parameters for all our codecs - at least we think so... */
1772 runtime->hw = snd_azf3328_hardware;
1773
1774 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
1775 &snd_azf3328_hw_constraints_rates);
1776 runtime->private_data = codec;
1777 snd_azf3328_dbgcallleave();
1778 return 0;
1779}
1780
1781static int
1782snd_azf3328_pcm_playback_open(struct snd_pcm_substream *substream)
1783{
1784 return snd_azf3328_pcm_open(substream, AZF_CODEC_PLAYBACK);
1785}
1786
1787static int
1788snd_azf3328_pcm_capture_open(struct snd_pcm_substream *substream)
1789{
1790 return snd_azf3328_pcm_open(substream, AZF_CODEC_CAPTURE);
1791}
1792
1793static int
1794snd_azf3328_pcm_i2s_out_open(struct snd_pcm_substream *substream)
1795{
1796 return snd_azf3328_pcm_open(substream, AZF_CODEC_I2S_OUT);
1797}
1798
1799static int
1800snd_azf3328_pcm_close(struct snd_pcm_substream *substream
1801)
1802{
1803 struct snd_azf3328_codec_data *codec =
1804 substream->runtime->private_data;
1805
1806 snd_azf3328_dbgcallenter();
1807 codec->substream = NULL;
1808 snd_azf3328_dbgcallleave();
1809 return 0;
1810}
1811
1812/******************************************************************/
1813
1814static struct snd_pcm_ops snd_azf3328_playback_ops = {
1815 .open = snd_azf3328_pcm_playback_open,
1816 .close = snd_azf3328_pcm_close,
1817 .ioctl = snd_pcm_lib_ioctl,
1818 .hw_params = snd_azf3328_hw_params,
1819 .hw_free = snd_azf3328_hw_free,
1820 .prepare = snd_azf3328_pcm_prepare,
1821 .trigger = snd_azf3328_pcm_trigger,
1822 .pointer = snd_azf3328_pcm_pointer
1823};
1824
1825static struct snd_pcm_ops snd_azf3328_capture_ops = {
1826 .open = snd_azf3328_pcm_capture_open,
1827 .close = snd_azf3328_pcm_close,
1828 .ioctl = snd_pcm_lib_ioctl,
1829 .hw_params = snd_azf3328_hw_params,
1830 .hw_free = snd_azf3328_hw_free,
1831 .prepare = snd_azf3328_pcm_prepare,
1832 .trigger = snd_azf3328_pcm_trigger,
1833 .pointer = snd_azf3328_pcm_pointer
1834};
1835
1836static struct snd_pcm_ops snd_azf3328_i2s_out_ops = {
1837 .open = snd_azf3328_pcm_i2s_out_open,
1838 .close = snd_azf3328_pcm_close,
1839 .ioctl = snd_pcm_lib_ioctl,
1840 .hw_params = snd_azf3328_hw_params,
1841 .hw_free = snd_azf3328_hw_free,
1842 .prepare = snd_azf3328_pcm_prepare,
1843 .trigger = snd_azf3328_pcm_trigger,
1844 .pointer = snd_azf3328_pcm_pointer
1845};
1846
1847static int __devinit
1848snd_azf3328_pcm(struct snd_azf3328 *chip)
1849{
1850enum { AZF_PCMDEV_STD, AZF_PCMDEV_I2S_OUT, NUM_AZF_PCMDEVS }; /* pcm devices */
1851
1852 struct snd_pcm *pcm;
1853 int err;
1854
1855 snd_azf3328_dbgcallenter();
1856
1857 err = snd_pcm_new(chip->card, "AZF3328 DSP", AZF_PCMDEV_STD,
1858 1, 1, &pcm);
1859 if (err < 0)
1860 return err;
1861 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
1862 &snd_azf3328_playback_ops);
1863 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
1864 &snd_azf3328_capture_ops);
1865
1866 pcm->private_data = chip;
1867 pcm->info_flags = 0;
1868 strcpy(pcm->name, chip->card->shortname);
1869 /* same pcm object for playback/capture (see snd_pcm_new() above) */
1870 chip->pcm[AZF_CODEC_PLAYBACK] = pcm;
1871 chip->pcm[AZF_CODEC_CAPTURE] = pcm;
1872
1873 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1874 snd_dma_pci_data(chip->pci),
1875 64*1024, 64*1024);
1876
1877 err = snd_pcm_new(chip->card, "AZF3328 I2S OUT", AZF_PCMDEV_I2S_OUT,
1878 1, 0, &pcm);
1879 if (err < 0)
1880 return err;
1881 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
1882 &snd_azf3328_i2s_out_ops);
1883
1884 pcm->private_data = chip;
1885 pcm->info_flags = 0;
1886 strcpy(pcm->name, chip->card->shortname);
1887 chip->pcm[AZF_CODEC_I2S_OUT] = pcm;
1888
1889 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1890 snd_dma_pci_data(chip->pci),
1891 64*1024, 64*1024);
1892
1893 snd_azf3328_dbgcallleave();
1894 return 0;
1895}
1896
1897/******************************************************************/
1898
1899/*** NOTE: the physical timer resolution actually is 1024000 ticks per second
1900 *** (probably derived from main crystal via a divider of 24),
1901 *** but announcing those attributes to user-space would make programs
1902 *** configure the timer to a 1 tick value, resulting in an absolutely fatal
1903 *** timer IRQ storm.
1904 *** Thus I chose to announce a down-scaled virtual timer to the outside and
1905 *** calculate real timer countdown values internally.
1906 *** (the scale factor can be set via module parameter "seqtimer_scaling").
1907 ***/
1908
1909static int
1910snd_azf3328_timer_start(struct snd_timer *timer)
1911{
1912 struct snd_azf3328 *chip;
1913 unsigned long flags;
1914 unsigned int delay;
1915
1916 snd_azf3328_dbgcallenter();
1917 chip = snd_timer_chip(timer);
1918 delay = ((timer->sticks * seqtimer_scaling) - 1) & TIMER_VALUE_MASK;
1919 if (delay < 49) {
1920 /* uhoh, that's not good, since user-space won't know about
1921 * this timing tweak
1922 * (we need to do it to avoid a lockup, though) */
1923
1924 snd_azf3328_dbgtimer("delay was too low (%d)!\n", delay);
1925 delay = 49; /* minimum time is 49 ticks */
1926 }
1927 snd_azf3328_dbgtimer("setting timer countdown value %d\n", delay);
1928 delay |= TIMER_COUNTDOWN_ENABLE | TIMER_IRQ_ENABLE;
1929 spin_lock_irqsave(&chip->reg_lock, flags);
1930 snd_azf3328_ctrl_outl(chip, IDX_IO_TIMER_VALUE, delay);
1931 spin_unlock_irqrestore(&chip->reg_lock, flags);
1932 snd_azf3328_dbgcallleave();
1933 return 0;
1934}
1935
1936static int
1937snd_azf3328_timer_stop(struct snd_timer *timer)
1938{
1939 struct snd_azf3328 *chip;
1940 unsigned long flags;
1941
1942 snd_azf3328_dbgcallenter();
1943 chip = snd_timer_chip(timer);
1944 spin_lock_irqsave(&chip->reg_lock, flags);
1945 /* disable timer countdown and interrupt */
1946 /* Hmm, should we write TIMER_IRQ_ACK here?
1947 YES indeed, otherwise a rogue timer operation - which prompts
1948 ALSA(?) to call repeated stop() in vain, but NOT start() -
1949 will never end (value 0x03 is kept shown in control byte).
1950 Simply manually poking 0x04 _once_ immediately successfully stops
1951 the hardware/ALSA interrupt activity. */
1952 snd_azf3328_ctrl_outb(chip, IDX_IO_TIMER_VALUE + 3, 0x04);
1953 spin_unlock_irqrestore(&chip->reg_lock, flags);
1954 snd_azf3328_dbgcallleave();
1955 return 0;
1956}
1957
1958
1959static int
1960snd_azf3328_timer_precise_resolution(struct snd_timer *timer,
1961 unsigned long *num, unsigned long *den)
1962{
1963 snd_azf3328_dbgcallenter();
1964 *num = 1;
1965 *den = 1024000 / seqtimer_scaling;
1966 snd_azf3328_dbgcallleave();
1967 return 0;
1968}
1969
1970static struct snd_timer_hardware snd_azf3328_timer_hw = {
1971 .flags = SNDRV_TIMER_HW_AUTO,
1972 .resolution = 977, /* 1000000/1024000 = 0.9765625us */
1973 .ticks = 1024000, /* max tick count, defined by the value register; actually it's not 1024000, but 1048576, but we don't care */
1974 .start = snd_azf3328_timer_start,
1975 .stop = snd_azf3328_timer_stop,
1976 .precise_resolution = snd_azf3328_timer_precise_resolution,
1977};
1978
1979static int __devinit
1980snd_azf3328_timer(struct snd_azf3328 *chip, int device)
1981{
1982 struct snd_timer *timer = NULL;
1983 struct snd_timer_id tid;
1984 int err;
1985
1986 snd_azf3328_dbgcallenter();
1987 tid.dev_class = SNDRV_TIMER_CLASS_CARD;
1988 tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
1989 tid.card = chip->card->number;
1990 tid.device = device;
1991 tid.subdevice = 0;
1992
1993 snd_azf3328_timer_hw.resolution *= seqtimer_scaling;
1994 snd_azf3328_timer_hw.ticks /= seqtimer_scaling;
1995
1996 err = snd_timer_new(chip->card, "AZF3328", &tid, &timer);
1997 if (err < 0)
1998 goto out;
1999
2000 strcpy(timer->name, "AZF3328 timer");
2001 timer->private_data = chip;
2002 timer->hw = snd_azf3328_timer_hw;
2003
2004 chip->timer = timer;
2005
2006 snd_azf3328_timer_stop(timer);
2007
2008 err = 0;
2009
2010out:
2011 snd_azf3328_dbgcallleave();
2012 return err;
2013}
2014
2015/******************************************************************/
2016
2017static int
2018snd_azf3328_free(struct snd_azf3328 *chip)
2019{
2020 if (chip->irq < 0)
2021 goto __end_hw;
2022
2023 /* reset (close) mixer:
2024 * first mute master volume, then reset
2025 */
2026 snd_azf3328_mixer_set_mute(chip, IDX_MIXER_PLAY_MASTER, 1);
2027 snd_azf3328_mixer_outw(chip, IDX_MIXER_RESET, 0x0000);
2028
2029 snd_azf3328_timer_stop(chip->timer);
2030 snd_azf3328_gameport_free(chip);
2031
2032 if (chip->irq >= 0)
2033 synchronize_irq(chip->irq);
2034__end_hw:
2035 if (chip->irq >= 0)
2036 free_irq(chip->irq, chip);
2037 pci_release_regions(chip->pci);
2038 pci_disable_device(chip->pci);
2039
2040 kfree(chip);
2041 return 0;
2042}
2043
2044static int
2045snd_azf3328_dev_free(struct snd_device *device)
2046{
2047 struct snd_azf3328 *chip = device->device_data;
2048 return snd_azf3328_free(chip);
2049}
2050
2051#if 0
2052/* check whether a bit can be modified */
2053static void
2054snd_azf3328_test_bit(unsigned unsigned reg, int bit)
2055{
2056 unsigned char val, valoff, valon;
2057
2058 val = inb(reg);
2059
2060 outb(val & ~(1 << bit), reg);
2061 valoff = inb(reg);
2062
2063 outb(val|(1 << bit), reg);
2064 valon = inb(reg);
2065
2066 outb(val, reg);
2067
2068 printk(KERN_DEBUG "reg %04x bit %d: %02x %02x %02x\n",
2069 reg, bit, val, valoff, valon
2070 );
2071}
2072#endif
2073
2074static inline void
2075snd_azf3328_debug_show_ports(const struct snd_azf3328 *chip)
2076{
2077#if DEBUG_MISC
2078 u16 tmp;
2079
2080 snd_azf3328_dbgmisc(
2081 "ctrl_io 0x%lx, game_io 0x%lx, mpu_io 0x%lx, "
2082 "opl3_io 0x%lx, mixer_io 0x%lx, irq %d\n",
2083 chip->ctrl_io, chip->game_io, chip->mpu_io,
2084 chip->opl3_io, chip->mixer_io, chip->irq
2085 );
2086
2087 snd_azf3328_dbgmisc("game %02x %02x %02x %02x %02x %02x\n",
2088 snd_azf3328_game_inb(chip, 0),
2089 snd_azf3328_game_inb(chip, 1),
2090 snd_azf3328_game_inb(chip, 2),
2091 snd_azf3328_game_inb(chip, 3),
2092 snd_azf3328_game_inb(chip, 4),
2093 snd_azf3328_game_inb(chip, 5)
2094 );
2095
2096 for (tmp = 0; tmp < 0x07; tmp += 1)
2097 snd_azf3328_dbgmisc("mpu_io 0x%04x\n", inb(chip->mpu_io + tmp));
2098
2099 for (tmp = 0; tmp <= 0x07; tmp += 1)
2100 snd_azf3328_dbgmisc("0x%02x: game200 0x%04x, game208 0x%04x\n",
2101 tmp, inb(0x200 + tmp), inb(0x208 + tmp));
2102
2103 for (tmp = 0; tmp <= 0x01; tmp += 1)
2104 snd_azf3328_dbgmisc(
2105 "0x%02x: mpu300 0x%04x, mpu310 0x%04x, mpu320 0x%04x, "
2106 "mpu330 0x%04x opl388 0x%04x opl38c 0x%04x\n",
2107 tmp,
2108 inb(0x300 + tmp),
2109 inb(0x310 + tmp),
2110 inb(0x320 + tmp),
2111 inb(0x330 + tmp),
2112 inb(0x388 + tmp),
2113 inb(0x38c + tmp)
2114 );
2115
2116 for (tmp = 0; tmp < AZF_IO_SIZE_CTRL; tmp += 2)
2117 snd_azf3328_dbgmisc("ctrl 0x%02x: 0x%04x\n",
2118 tmp, snd_azf3328_ctrl_inw(chip, tmp)
2119 );
2120
2121 for (tmp = 0; tmp < AZF_IO_SIZE_MIXER; tmp += 2)
2122 snd_azf3328_dbgmisc("mixer 0x%02x: 0x%04x\n",
2123 tmp, snd_azf3328_mixer_inw(chip, tmp)
2124 );
2125#endif /* DEBUG_MISC */
2126}
2127
2128static int __devinit
2129snd_azf3328_create(struct snd_card *card,
2130 struct pci_dev *pci,
2131 unsigned long device_type,
2132 struct snd_azf3328 **rchip)
2133{
2134 struct snd_azf3328 *chip;
2135 int err;
2136 static struct snd_device_ops ops = {
2137 .dev_free = snd_azf3328_dev_free,
2138 };
2139 u8 dma_init;
2140 enum snd_azf3328_codec_type codec_type;
2141 struct snd_azf3328_codec_data *codec_setup;
2142
2143 *rchip = NULL;
2144
2145 err = pci_enable_device(pci);
2146 if (err < 0)
2147 return err;
2148
2149 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
2150 if (chip == NULL) {
2151 err = -ENOMEM;
2152 goto out_err;
2153 }
2154 spin_lock_init(&chip->reg_lock);
2155 chip->card = card;
2156 chip->pci = pci;
2157 chip->irq = -1;
2158
2159 /* check if we can restrict PCI DMA transfers to 24 bits */
2160 if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
2161 pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
2162 snd_printk(KERN_ERR "architecture does not support "
2163 "24bit PCI busmaster DMA\n"
2164 );
2165 err = -ENXIO;
2166 goto out_err;
2167 }
2168
2169 err = pci_request_regions(pci, "Aztech AZF3328");
2170 if (err < 0)
2171 goto out_err;
2172
2173 chip->ctrl_io = pci_resource_start(pci, 0);
2174 chip->game_io = pci_resource_start(pci, 1);
2175 chip->mpu_io = pci_resource_start(pci, 2);
2176 chip->opl3_io = pci_resource_start(pci, 3);
2177 chip->mixer_io = pci_resource_start(pci, 4);
2178
2179 codec_setup = &chip->codecs[AZF_CODEC_PLAYBACK];
2180 codec_setup->io_base = chip->ctrl_io + AZF_IO_OFFS_CODEC_PLAYBACK;
2181 codec_setup->lock = &chip->reg_lock;
2182 codec_setup->type = AZF_CODEC_PLAYBACK;
2183 codec_setup->name = "PLAYBACK";
2184
2185 codec_setup = &chip->codecs[AZF_CODEC_CAPTURE];
2186 codec_setup->io_base = chip->ctrl_io + AZF_IO_OFFS_CODEC_CAPTURE;
2187 codec_setup->lock = &chip->reg_lock;
2188 codec_setup->type = AZF_CODEC_CAPTURE;
2189 codec_setup->name = "CAPTURE";
2190
2191 codec_setup = &chip->codecs[AZF_CODEC_I2S_OUT];
2192 codec_setup->io_base = chip->ctrl_io + AZF_IO_OFFS_CODEC_I2S_OUT;
2193 codec_setup->lock = &chip->reg_lock;
2194 codec_setup->type = AZF_CODEC_I2S_OUT;
2195 codec_setup->name = "I2S_OUT";
2196
2197 if (request_irq(pci->irq, snd_azf3328_interrupt,
2198 IRQF_SHARED, card->shortname, chip)) {
2199 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
2200 err = -EBUSY;
2201 goto out_err;
2202 }
2203 chip->irq = pci->irq;
2204 pci_set_master(pci);
2205 synchronize_irq(chip->irq);
2206
2207 snd_azf3328_debug_show_ports(chip);
2208
2209 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
2210 if (err < 0)
2211 goto out_err;
2212
2213 /* create mixer interface & switches */
2214 err = snd_azf3328_mixer_new(chip);
2215 if (err < 0)
2216 goto out_err;
2217
2218 /* standard codec init stuff */
2219 /* default DMA init value */
2220 dma_init = DMA_RUN_SOMETHING2|DMA_EPILOGUE_SOMETHING|DMA_SOMETHING_ELSE;
2221
2222 for (codec_type = AZF_CODEC_PLAYBACK;
2223 codec_type <= AZF_CODEC_I2S_OUT; ++codec_type) {
2224 struct snd_azf3328_codec_data *codec =
2225 &chip->codecs[codec_type];
2226
2227 /* shutdown codecs to reduce power / noise */
2228 /* have ...ctrl_codec_activity() act properly */
2229 codec->running = 1;
2230 snd_azf3328_ctrl_codec_activity(chip, codec_type, 0);
2231
2232 spin_lock_irq(codec->lock);
2233 snd_azf3328_codec_outb(codec, IDX_IO_CODEC_DMA_FLAGS,
2234 dma_init);
2235 spin_unlock_irq(codec->lock);
2236 }
2237
2238 snd_card_set_dev(card, &pci->dev);
2239
2240 *rchip = chip;
2241
2242 err = 0;
2243 goto out;
2244
2245out_err:
2246 if (chip)
2247 snd_azf3328_free(chip);
2248 pci_disable_device(pci);
2249
2250out:
2251 return err;
2252}
2253
2254static int __devinit
2255snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
2256{
2257 static int dev;
2258 struct snd_card *card;
2259 struct snd_azf3328 *chip;
2260 struct snd_opl3 *opl3;
2261 int err;
2262
2263 snd_azf3328_dbgcallenter();
2264 if (dev >= SNDRV_CARDS)
2265 return -ENODEV;
2266 if (!enable[dev]) {
2267 dev++;
2268 return -ENOENT;
2269 }
2270
2271 err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
2272 if (err < 0)
2273 return err;
2274
2275 strcpy(card->driver, "AZF3328");
2276 strcpy(card->shortname, "Aztech AZF3328 (PCI168)");
2277
2278 err = snd_azf3328_create(card, pci, pci_id->driver_data, &chip);
2279 if (err < 0)
2280 goto out_err;
2281
2282 card->private_data = chip;
2283
2284 /* chose to use MPU401_HW_AZT2320 ID instead of MPU401_HW_MPU401,
2285 since our hardware ought to be similar, thus use same ID. */
2286 err = snd_mpu401_uart_new(
2287 card, 0,
2288 MPU401_HW_AZT2320, chip->mpu_io, MPU401_INFO_INTEGRATED,
2289 pci->irq, 0, &chip->rmidi
2290 );
2291 if (err < 0) {
2292 snd_printk(KERN_ERR "azf3328: no MPU-401 device at 0x%lx?\n",
2293 chip->mpu_io
2294 );
2295 goto out_err;
2296 }
2297
2298 err = snd_azf3328_timer(chip, 0);
2299 if (err < 0)
2300 goto out_err;
2301
2302 err = snd_azf3328_pcm(chip);
2303 if (err < 0)
2304 goto out_err;
2305
2306 if (snd_opl3_create(card, chip->opl3_io, chip->opl3_io+2,
2307 OPL3_HW_AUTO, 1, &opl3) < 0) {
2308 snd_printk(KERN_ERR "azf3328: no OPL3 device at 0x%lx-0x%lx?\n",
2309 chip->opl3_io, chip->opl3_io+2
2310 );
2311 } else {
2312 /* need to use IDs 1, 2 since ID 0 is snd_azf3328_timer above */
2313 err = snd_opl3_timer_new(opl3, 1, 2);
2314 if (err < 0)
2315 goto out_err;
2316 err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
2317 if (err < 0)
2318 goto out_err;
2319 }
2320
2321 opl3->private_data = chip;
2322
2323 sprintf(card->longname, "%s at 0x%lx, irq %i",
2324 card->shortname, chip->ctrl_io, chip->irq);
2325
2326 err = snd_card_register(card);
2327 if (err < 0)
2328 goto out_err;
2329
2330#ifdef MODULE
2331 printk(KERN_INFO
2332"azt3328: Sound driver for Aztech AZF3328-based soundcards such as PCI168.\n"
2333"azt3328: Hardware was completely undocumented, unfortunately.\n"
2334"azt3328: Feel free to contact andi AT lisas.de for bug reports etc.!\n"
2335"azt3328: User-scalable sequencer timer set to %dHz (1024000Hz / %d).\n",
2336 1024000 / seqtimer_scaling, seqtimer_scaling);
2337#endif
2338
2339 snd_azf3328_gameport(chip, dev);
2340
2341 pci_set_drvdata(pci, card);
2342 dev++;
2343
2344 err = 0;
2345 goto out;
2346
2347out_err:
2348 snd_printk(KERN_ERR "azf3328: something failed, exiting\n");
2349 snd_card_free(card);
2350
2351out:
2352 snd_azf3328_dbgcallleave();
2353 return err;
2354}
2355
2356static void __devexit
2357snd_azf3328_remove(struct pci_dev *pci)
2358{
2359 snd_azf3328_dbgcallenter();
2360 snd_card_free(pci_get_drvdata(pci));
2361 pci_set_drvdata(pci, NULL);
2362 snd_azf3328_dbgcallleave();
2363}
2364
2365#ifdef CONFIG_PM
2366static inline void
2367snd_azf3328_suspend_regs(unsigned long io_addr, unsigned count, u32 *saved_regs)
2368{
2369 unsigned reg;
2370
2371 for (reg = 0; reg < count; ++reg) {
2372 *saved_regs = inl(io_addr);
2373 snd_azf3328_dbgpm("suspend: io 0x%04lx: 0x%08x\n",
2374 io_addr, *saved_regs);
2375 ++saved_regs;
2376 io_addr += sizeof(*saved_regs);
2377 }
2378}
2379
2380static int
2381snd_azf3328_suspend(struct pci_dev *pci, pm_message_t state)
2382{
2383 struct snd_card *card = pci_get_drvdata(pci);
2384 struct snd_azf3328 *chip = card->private_data;
2385 u16 *saved_regs_ctrl_u16;
2386
2387 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
2388
2389 /* same pcm object for playback/capture */
2390 snd_pcm_suspend_all(chip->pcm[AZF_CODEC_PLAYBACK]);
2391 snd_pcm_suspend_all(chip->pcm[AZF_CODEC_I2S_OUT]);
2392
2393 snd_azf3328_suspend_regs(chip->mixer_io,
2394 ARRAY_SIZE(chip->saved_regs_mixer), chip->saved_regs_mixer);
2395
2396 /* make sure to disable master volume etc. to prevent looping sound */
2397 snd_azf3328_mixer_set_mute(chip, IDX_MIXER_PLAY_MASTER, 1);
2398 snd_azf3328_mixer_set_mute(chip, IDX_MIXER_WAVEOUT, 1);
2399
2400 snd_azf3328_suspend_regs(chip->ctrl_io,
2401 ARRAY_SIZE(chip->saved_regs_ctrl), chip->saved_regs_ctrl);
2402
2403 /* manually store the one currently relevant write-only reg, too */
2404 saved_regs_ctrl_u16 = (u16 *)chip->saved_regs_ctrl;
2405 saved_regs_ctrl_u16[IDX_IO_6AH / 2] = chip->shadow_reg_ctrl_6AH;
2406
2407 snd_azf3328_suspend_regs(chip->game_io,
2408 ARRAY_SIZE(chip->saved_regs_game), chip->saved_regs_game);
2409 snd_azf3328_suspend_regs(chip->mpu_io,
2410 ARRAY_SIZE(chip->saved_regs_mpu), chip->saved_regs_mpu);
2411 snd_azf3328_suspend_regs(chip->opl3_io,
2412 ARRAY_SIZE(chip->saved_regs_opl3), chip->saved_regs_opl3);
2413
2414 pci_disable_device(pci);
2415 pci_save_state(pci);
2416 pci_set_power_state(pci, pci_choose_state(pci, state));
2417 return 0;
2418}
2419
2420static inline void
2421snd_azf3328_resume_regs(const u32 *saved_regs,
2422 unsigned long io_addr,
2423 unsigned count
2424)
2425{
2426 unsigned reg;
2427
2428 for (reg = 0; reg < count; ++reg) {
2429 outl(*saved_regs, io_addr);
2430 snd_azf3328_dbgpm("resume: io 0x%04lx: 0x%08x --> 0x%08x\n",
2431 io_addr, *saved_regs, inl(io_addr));
2432 ++saved_regs;
2433 io_addr += sizeof(*saved_regs);
2434 }
2435}
2436
2437static int
2438snd_azf3328_resume(struct pci_dev *pci)
2439{
2440 struct snd_card *card = pci_get_drvdata(pci);
2441 const struct snd_azf3328 *chip = card->private_data;
2442
2443 pci_set_power_state(pci, PCI_D0);
2444 pci_restore_state(pci);
2445 if (pci_enable_device(pci) < 0) {
2446 printk(KERN_ERR "azt3328: pci_enable_device failed, "
2447 "disabling device\n");
2448 snd_card_disconnect(card);
2449 return -EIO;
2450 }
2451 pci_set_master(pci);
2452
2453 snd_azf3328_resume_regs(chip->saved_regs_game, chip->game_io,
2454 ARRAY_SIZE(chip->saved_regs_game));
2455 snd_azf3328_resume_regs(chip->saved_regs_mpu, chip->mpu_io,
2456 ARRAY_SIZE(chip->saved_regs_mpu));
2457 snd_azf3328_resume_regs(chip->saved_regs_opl3, chip->opl3_io,
2458 ARRAY_SIZE(chip->saved_regs_opl3));
2459
2460 snd_azf3328_resume_regs(chip->saved_regs_mixer, chip->mixer_io,
2461 ARRAY_SIZE(chip->saved_regs_mixer));
2462
2463 /* unfortunately with 32bit transfers, IDX_MIXER_PLAY_MASTER (0x02)
2464 and IDX_MIXER_RESET (offset 0x00) get touched at the same time,
2465 resulting in a mixer reset condition persisting until _after_
2466 master vol was restored. Thus master vol needs an extra restore. */
2467 outw(((u16 *)chip->saved_regs_mixer)[1], chip->mixer_io + 2);
2468
2469 snd_azf3328_resume_regs(chip->saved_regs_ctrl, chip->ctrl_io,
2470 ARRAY_SIZE(chip->saved_regs_ctrl));
2471
2472 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
2473 return 0;
2474}
2475#endif /* CONFIG_PM */
2476
2477
2478static struct pci_driver driver = {
2479 .name = "AZF3328",
2480 .id_table = snd_azf3328_ids,
2481 .probe = snd_azf3328_probe,
2482 .remove = __devexit_p(snd_azf3328_remove),
2483#ifdef CONFIG_PM
2484 .suspend = snd_azf3328_suspend,
2485 .resume = snd_azf3328_resume,
2486#endif
2487};
2488
2489static int __init
2490alsa_card_azf3328_init(void)
2491{
2492 int err;
2493 snd_azf3328_dbgcallenter();
2494 err = pci_register_driver(&driver);
2495 snd_azf3328_dbgcallleave();
2496 return err;
2497}
2498
2499static void __exit
2500alsa_card_azf3328_exit(void)
2501{
2502 snd_azf3328_dbgcallenter();
2503 pci_unregister_driver(&driver);
2504 snd_azf3328_dbgcallleave();
2505}
2506
2507module_init(alsa_card_azf3328_init)
2508module_exit(alsa_card_azf3328_exit)
Linux kernel - Deliverables
This page took 0.05041 seconds and 5 git commands to generate.