2 card-opti92x-ad1848.c - driver for OPTi 82c92x based soundcards.
3 Copyright (C) 1998-2000 by Massimo Piccioni <dafastidio@libero.it>
5 Part of this code was developed at the Italian Ministry of Air Defence,
6 Sixth Division (oh, che pace ...), Rome.
8 Thanks to Maria Grazia Pollarini, Salvatore Vassallo.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include <sound/driver.h>
27 #include <linux/init.h>
28 #include <linux/err.h>
29 #include <linux/isa.h>
30 #include <linux/delay.h>
31 #include <linux/slab.h>
32 #include <linux/pnp.h>
33 #include <linux/moduleparam.h>
36 #include <sound/core.h>
38 #include <sound/cs4231.h>
41 #include <sound/ad1848.h>
43 #include <sound/control.h>
44 #include <sound/pcm.h>
47 #include <sound/mpu401.h>
48 #include <sound/opl3.h>
50 #include <sound/opl4.h>
52 #define SNDRV_LEGACY_FIND_FREE_IRQ
53 #define SNDRV_LEGACY_FIND_FREE_DMA
54 #include <sound/initval.h>
56 MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>");
57 MODULE_LICENSE("GPL");
59 MODULE_DESCRIPTION("OPTi93X");
60 MODULE_SUPPORTED_DEVICE("{{OPTi,82C931/3}}");
63 MODULE_DESCRIPTION("OPTi92X - CS4231");
64 MODULE_SUPPORTED_DEVICE("{{OPTi,82C924 (CS4231)},"
65 "{OPTi,82C925 (CS4231)}}");
67 MODULE_DESCRIPTION("OPTi92X - AD1848");
68 MODULE_SUPPORTED_DEVICE("{{OPTi,82C924 (AD1848)},"
69 "{OPTi,82C925 (AD1848)},"
74 static int index
= SNDRV_DEFAULT_IDX1
; /* Index 0-MAX */
75 static char *id
= SNDRV_DEFAULT_STR1
; /* ID for this card */
76 //static int enable = SNDRV_DEFAULT_ENABLE1; /* Enable this card */
77 static int isapnp
= 1; /* Enable ISA PnP detection */
78 static long port
= SNDRV_DEFAULT_PORT1
; /* 0x530,0xe80,0xf40,0x604 */
79 static long mpu_port
= SNDRV_DEFAULT_PORT1
; /* 0x300,0x310,0x320,0x330 */
80 static long fm_port
= SNDRV_DEFAULT_PORT1
; /* 0x388 */
81 static int irq
= SNDRV_DEFAULT_IRQ1
; /* 5,7,9,10,11 */
82 static int mpu_irq
= SNDRV_DEFAULT_IRQ1
; /* 5,7,9,10 */
83 static int dma1
= SNDRV_DEFAULT_DMA1
; /* 0,1,3 */
84 #if defined(CS4231) || defined(OPTi93X)
85 static int dma2
= SNDRV_DEFAULT_DMA1
; /* 0,1,3 */
86 #endif /* CS4231 || OPTi93X */
88 module_param(index
, int, 0444);
89 MODULE_PARM_DESC(index
, "Index value for opti9xx based soundcard.");
90 module_param(id
, charp
, 0444);
91 MODULE_PARM_DESC(id
, "ID string for opti9xx based soundcard.");
92 //module_param(enable, bool, 0444);
93 //MODULE_PARM_DESC(enable, "Enable opti9xx soundcard.");
94 module_param(isapnp
, bool, 0444);
95 MODULE_PARM_DESC(isapnp
, "Enable ISA PnP detection for specified soundcard.");
96 module_param(port
, long, 0444);
97 MODULE_PARM_DESC(port
, "WSS port # for opti9xx driver.");
98 module_param(mpu_port
, long, 0444);
99 MODULE_PARM_DESC(mpu_port
, "MPU-401 port # for opti9xx driver.");
100 module_param(fm_port
, long, 0444);
101 MODULE_PARM_DESC(fm_port
, "FM port # for opti9xx driver.");
102 module_param(irq
, int, 0444);
103 MODULE_PARM_DESC(irq
, "WSS irq # for opti9xx driver.");
104 module_param(mpu_irq
, int, 0444);
105 MODULE_PARM_DESC(mpu_irq
, "MPU-401 irq # for opti9xx driver.");
106 module_param(dma1
, int, 0444);
107 MODULE_PARM_DESC(dma1
, "1st dma # for opti9xx driver.");
108 #if defined(CS4231) || defined(OPTi93X)
109 module_param(dma2
, int, 0444);
110 MODULE_PARM_DESC(dma2
, "2nd dma # for opti9xx driver.");
111 #endif /* CS4231 || OPTi93X */
113 #define OPTi9XX_HW_DETECT 0
114 #define OPTi9XX_HW_82C928 1
115 #define OPTi9XX_HW_82C929 2
116 #define OPTi9XX_HW_82C924 3
117 #define OPTi9XX_HW_82C925 4
118 #define OPTi9XX_HW_82C930 5
119 #define OPTi9XX_HW_82C931 6
120 #define OPTi9XX_HW_82C933 7
121 #define OPTi9XX_HW_LAST OPTi9XX_HW_82C933
123 #define OPTi9XX_MC_REG(n) n
127 #define OPTi93X_INDEX 0x00
128 #define OPTi93X_DATA 0x01
129 #define OPTi93X_STATUS 0x02
130 #define OPTi93X_DDATA 0x03
131 #define OPTi93X_PORT(chip, r) ((chip)->port + OPTi93X_##r)
133 #define OPTi93X_MIXOUT_LEFT 0x00
134 #define OPTi93X_MIXOUT_RIGHT 0x01
135 #define OPTi93X_CD_LEFT_INPUT 0x02
136 #define OPTi93X_CD_RIGHT_INPUT 0x03
137 #define OPTi930_AUX_LEFT_INPUT 0x04
138 #define OPTi930_AUX_RIGHT_INPUT 0x05
139 #define OPTi931_FM_LEFT_INPUT 0x04
140 #define OPTi931_FM_RIGHT_INPUT 0x05
141 #define OPTi93X_DAC_LEFT 0x06
142 #define OPTi93X_DAC_RIGHT 0x07
143 #define OPTi93X_PLAY_FORMAT 0x08
144 #define OPTi93X_IFACE_CONF 0x09
145 #define OPTi93X_PIN_CTRL 0x0a
146 #define OPTi93X_ERR_INIT 0x0b
147 #define OPTi93X_ID 0x0c
148 #define OPTi93X_PLAY_UPR_CNT 0x0e
149 #define OPTi93X_PLAY_LWR_CNT 0x0f
150 #define OPTi931_AUX_LEFT_INPUT 0x10
151 #define OPTi931_AUX_RIGHT_INPUT 0x11
152 #define OPTi93X_LINE_LEFT_INPUT 0x12
153 #define OPTi93X_LINE_RIGHT_INPUT 0x13
154 #define OPTi93X_MIC_LEFT_INPUT 0x14
155 #define OPTi93X_MIC_RIGHT_INPUT 0x15
156 #define OPTi93X_OUT_LEFT 0x16
157 #define OPTi93X_OUT_RIGHT 0x17
158 #define OPTi93X_CAPT_FORMAT 0x1c
159 #define OPTi93X_CAPT_UPR_CNT 0x1e
160 #define OPTi93X_CAPT_LWR_CNT 0x1f
162 #define OPTi93X_TRD 0x20
163 #define OPTi93X_MCE 0x40
164 #define OPTi93X_INIT 0x80
166 #define OPTi93X_MIXOUT_MIC_GAIN 0x20
167 #define OPTi93X_MIXOUT_LINE 0x00
168 #define OPTi93X_MIXOUT_CD 0x40
169 #define OPTi93X_MIXOUT_MIC 0x80
170 #define OPTi93X_MIXOUT_MIXER 0xc0
172 #define OPTi93X_STEREO 0x10
173 #define OPTi93X_LINEAR_8 0x00
174 #define OPTi93X_ULAW_8 0x20
175 #define OPTi93X_LINEAR_16_LIT 0x40
176 #define OPTi93X_ALAW_8 0x60
177 #define OPTi93X_ADPCM_16 0xa0
178 #define OPTi93X_LINEAR_16_BIG 0xc0
180 #define OPTi93X_CAPTURE_PIO 0x80
181 #define OPTi93X_PLAYBACK_PIO 0x40
182 #define OPTi93X_AUTOCALIB 0x08
183 #define OPTi93X_SINGLE_DMA 0x04
184 #define OPTi93X_CAPTURE_ENABLE 0x02
185 #define OPTi93X_PLAYBACK_ENABLE 0x01
187 #define OPTi93X_IRQ_ENABLE 0x02
189 #define OPTi93X_DMA_REQUEST 0x10
190 #define OPTi93X_CALIB_IN_PROGRESS 0x20
192 #define OPTi93X_IRQ_PLAYBACK 0x04
193 #define OPTi93X_IRQ_CAPTURE 0x08
198 struct resource
*res_port
;
203 struct snd_opti9xx
*chip
;
204 unsigned short hardware
;
205 unsigned char image
[32];
207 unsigned char mce_bit
;
213 struct snd_card
*card
;
215 struct snd_pcm_substream
*playback_substream
;
216 struct snd_pcm_substream
*capture_substream
;
217 unsigned int p_dma_size
;
218 unsigned int c_dma_size
;
221 #define OPTi93X_MODE_NONE 0x00
222 #define OPTi93X_MODE_PLAY 0x01
223 #define OPTi93X_MODE_CAPTURE 0x02
224 #define OPTi93X_MODE_OPEN (OPTi93X_MODE_PLAY | OPTi93X_MODE_CAPTURE)
229 unsigned short hardware
;
230 unsigned char password
;
233 unsigned long mc_base
;
234 struct resource
*res_mc_base
;
235 unsigned long mc_base_size
;
237 unsigned long mc_indir_index
;
239 unsigned long pwd_reg
;
246 #if defined(CS4231) || defined(OPTi93X)
248 #endif /* CS4231 || OPTi93X */
257 struct pnp_dev
*devmpu
;
258 #endif /* CONFIG_PNP */
261 static int snd_opti9xx_pnp_is_probed
;
265 static struct pnp_card_device_id snd_opti9xx_pnpids
[] = {
268 { .id
= "OPT0924", .devs
= { { "OPT0000" }, { "OPT0002" } }, .driver_data
= 0x0924 },
270 { .id
= "OPT0925", .devs
= { { "OPT9250" }, { "OPT0002" } }, .driver_data
= 0x0925 },
273 { .id
= "OPT0931", .devs
= { { "OPT9310" }, { "OPT0002" } }, .driver_data
= 0x0931 },
278 MODULE_DEVICE_TABLE(pnp_card
, snd_opti9xx_pnpids
);
280 #endif /* CONFIG_PNP */
283 #define DEV_NAME "opti93x"
285 #define DEV_NAME "opti92x"
288 static char * snd_opti9xx_names
[] = {
292 "82C930", "82C931", "82C933"
296 static long __devinit
snd_legacy_find_free_ioport(long *port_table
, long size
)
298 while (*port_table
!= -1) {
299 if (request_region(*port_table
, size
, "ALSA test")) {
300 release_region(*port_table
, size
);
308 static int __devinit
snd_opti9xx_init(struct snd_opti9xx
*chip
,
309 unsigned short hardware
)
311 static int opti9xx_mc_size
[] = {7, 7, 10, 10, 2, 2, 2};
313 chip
->hardware
= hardware
;
314 strcpy(chip
->name
, snd_opti9xx_names
[hardware
]);
316 chip
->mc_base_size
= opti9xx_mc_size
[hardware
];
318 spin_lock_init(&chip
->lock
);
323 #if defined(CS4231) || defined (OPTi93X)
325 #endif /* CS4231 || OPTi93X */
332 case OPTi9XX_HW_82C928
:
333 case OPTi9XX_HW_82C929
:
334 chip
->mc_base
= 0xf8c;
335 chip
->password
= (hardware
== OPTi9XX_HW_82C928
) ? 0xe2 : 0xe3;
339 case OPTi9XX_HW_82C924
:
340 case OPTi9XX_HW_82C925
:
341 chip
->mc_base
= 0xf8c;
342 chip
->password
= 0xe5;
347 case OPTi9XX_HW_82C930
:
348 case OPTi9XX_HW_82C931
:
349 case OPTi9XX_HW_82C933
:
350 chip
->mc_base
= (hardware
== OPTi9XX_HW_82C930
) ? 0xf8f : 0xf8d;
351 chip
->mc_indir_index
= 0xe0e;
352 chip
->password
= 0xe4;
358 snd_printk("chip %d not supported\n", hardware
);
364 static unsigned char snd_opti9xx_read(struct snd_opti9xx
*chip
,
368 unsigned char retval
= 0xff;
370 spin_lock_irqsave(&chip
->lock
, flags
);
371 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
373 switch (chip
->hardware
) {
375 case OPTi9XX_HW_82C924
:
376 case OPTi9XX_HW_82C925
:
378 outb(reg
, chip
->mc_base
+ 8);
379 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
380 retval
= inb(chip
->mc_base
+ 9);
384 case OPTi9XX_HW_82C928
:
385 case OPTi9XX_HW_82C929
:
386 retval
= inb(chip
->mc_base
+ reg
);
390 case OPTi9XX_HW_82C930
:
391 case OPTi9XX_HW_82C931
:
392 case OPTi9XX_HW_82C933
:
393 outb(reg
, chip
->mc_indir_index
);
394 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
395 retval
= inb(chip
->mc_indir_index
+ 1);
400 snd_printk("chip %d not supported\n", chip
->hardware
);
403 spin_unlock_irqrestore(&chip
->lock
, flags
);
407 static void snd_opti9xx_write(struct snd_opti9xx
*chip
, unsigned char reg
,
412 spin_lock_irqsave(&chip
->lock
, flags
);
413 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
415 switch (chip
->hardware
) {
417 case OPTi9XX_HW_82C924
:
418 case OPTi9XX_HW_82C925
:
420 outb(reg
, chip
->mc_base
+ 8);
421 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
422 outb(value
, chip
->mc_base
+ 9);
426 case OPTi9XX_HW_82C928
:
427 case OPTi9XX_HW_82C929
:
428 outb(value
, chip
->mc_base
+ reg
);
432 case OPTi9XX_HW_82C930
:
433 case OPTi9XX_HW_82C931
:
434 case OPTi9XX_HW_82C933
:
435 outb(reg
, chip
->mc_indir_index
);
436 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
437 outb(value
, chip
->mc_indir_index
+ 1);
442 snd_printk("chip %d not supported\n", chip
->hardware
);
445 spin_unlock_irqrestore(&chip
->lock
, flags
);
449 #define snd_opti9xx_write_mask(chip, reg, value, mask) \
450 snd_opti9xx_write(chip, reg, \
451 (snd_opti9xx_read(chip, reg) & ~(mask)) | ((value) & (mask)))
454 static int __devinit
snd_opti9xx_configure(struct snd_opti9xx
*chip
)
456 unsigned char wss_base_bits
;
457 unsigned char irq_bits
;
458 unsigned char dma_bits
;
459 unsigned char mpu_port_bits
= 0;
460 unsigned char mpu_irq_bits
;
462 switch (chip
->hardware
) {
464 case OPTi9XX_HW_82C924
:
465 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(4), 0xf0, 0xfc);
466 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(6), 0x02, 0x02);
468 case OPTi9XX_HW_82C925
:
469 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(1), 0x80, 0x80);
470 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(2), 0x00, 0x20);
471 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(3), 0xf0, 0xff);
473 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x02, 0x02);
475 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x00, 0x02);
479 case OPTi9XX_HW_82C928
:
480 case OPTi9XX_HW_82C929
:
481 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(1), 0x80, 0x80);
482 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(2), 0x00, 0x20);
484 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(3), 0xa2, 0xae);
486 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(4), 0x00, 0x0c);
488 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x02, 0x02);
490 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x00, 0x02);
495 case OPTi9XX_HW_82C930
:
496 case OPTi9XX_HW_82C931
:
497 case OPTi9XX_HW_82C933
:
498 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(6), 0x02, 0x03);
499 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(3), 0x00, 0xff);
500 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(4), 0x10 |
501 (chip
->hardware
== OPTi9XX_HW_82C930
? 0x00 : 0x04),
503 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x20, 0xbf);
505 * The BTC 1817DW has QS1000 wavetable which is connected
506 * to the serial digital input of the OPTI931.
508 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(21), 0x82, 0xff);
510 * This bit sets OPTI931 to automaticaly select FM
511 * or digital input signal.
513 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(26), 0x01, 0x01);
518 snd_printk("chip %d not supported\n", chip
->hardware
);
522 switch (chip
->wss_base
) {
524 wss_base_bits
= 0x00;
527 wss_base_bits
= 0x03;
530 wss_base_bits
= 0x01;
533 wss_base_bits
= 0x02;
536 snd_printk("WSS port 0x%lx not valid\n", chip
->wss_base
);
539 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(1), wss_base_bits
<< 4, 0x30);
547 //#endif /* OPTi93X */
561 snd_printk("WSS irq # %d not valid\n", chip
->irq
);
562 goto __skip_resources
;
565 switch (chip
->dma1
) {
576 snd_printk("WSS dma1 # %d not valid\n", chip
->dma1
);
577 goto __skip_resources
;
580 #if defined(CS4231) || defined(OPTi93X)
581 if (chip
->dma1
== chip
->dma2
) {
582 snd_printk("don't want to share dmas\n");
586 switch (chip
->dma2
) {
591 snd_printk("WSS dma2 # %d not valid\n", chip
->dma2
);
592 goto __skip_resources
;
595 #endif /* CS4231 || OPTi93X */
598 outb(irq_bits
<< 3 | dma_bits
, chip
->wss_base
);
600 snd_opti9xx_write(chip
, OPTi9XX_MC_REG(3), (irq_bits
<< 3 | dma_bits
));
604 if (chip
->hardware
> OPTi9XX_HW_82C928
) {
605 switch (chip
->mpu_port
) {
610 mpu_port_bits
= 0x03;
613 mpu_port_bits
= 0x02;
616 mpu_port_bits
= 0x01;
619 mpu_port_bits
= 0x00;
622 snd_printk("MPU-401 port 0x%lx not valid\n",
627 switch (chip
->mpu_irq
) {
641 snd_printk("MPU-401 irq # %d not valid\n",
646 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(6),
647 (chip
->mpu_port
<= 0) ? 0x00 :
648 0x80 | mpu_port_bits
<< 5 | mpu_irq_bits
<< 3,
658 static unsigned char snd_opti93x_default_image
[32] =
660 0x00, /* 00/00 - l_mixout_outctrl */
661 0x00, /* 01/01 - r_mixout_outctrl */
662 0x88, /* 02/02 - l_cd_inctrl */
663 0x88, /* 03/03 - r_cd_inctrl */
664 0x88, /* 04/04 - l_a1/fm_inctrl */
665 0x88, /* 05/05 - r_a1/fm_inctrl */
666 0x80, /* 06/06 - l_dac_inctrl */
667 0x80, /* 07/07 - r_dac_inctrl */
668 0x00, /* 08/08 - ply_dataform_reg */
669 0x00, /* 09/09 - if_conf */
670 0x00, /* 0a/10 - pin_ctrl */
671 0x00, /* 0b/11 - err_init_reg */
672 0x0a, /* 0c/12 - id_reg */
673 0x00, /* 0d/13 - reserved */
674 0x00, /* 0e/14 - ply_upcount_reg */
675 0x00, /* 0f/15 - ply_lowcount_reg */
676 0x88, /* 10/16 - reserved/l_a1_inctrl */
677 0x88, /* 11/17 - reserved/r_a1_inctrl */
678 0x88, /* 12/18 - l_line_inctrl */
679 0x88, /* 13/19 - r_line_inctrl */
680 0x88, /* 14/20 - l_mic_inctrl */
681 0x88, /* 15/21 - r_mic_inctrl */
682 0x80, /* 16/22 - l_out_outctrl */
683 0x80, /* 17/23 - r_out_outctrl */
684 0x00, /* 18/24 - reserved */
685 0x00, /* 19/25 - reserved */
686 0x00, /* 1a/26 - reserved */
687 0x00, /* 1b/27 - reserved */
688 0x00, /* 1c/28 - cap_dataform_reg */
689 0x00, /* 1d/29 - reserved */
690 0x00, /* 1e/30 - cap_upcount_reg */
691 0x00 /* 1f/31 - cap_lowcount_reg */
695 static int snd_opti93x_busy_wait(struct snd_opti93x
*chip
)
699 for (timeout
= 250; timeout
-- > 0; udelay(10))
700 if (!(inb(OPTi93X_PORT(chip
, INDEX
)) & OPTi93X_INIT
))
703 snd_printk("chip still busy.\n");
707 static unsigned char snd_opti93x_in(struct snd_opti93x
*chip
, unsigned char reg
)
709 snd_opti93x_busy_wait(chip
);
710 outb(chip
->mce_bit
| (reg
& 0x1f), OPTi93X_PORT(chip
, INDEX
));
711 return inb(OPTi93X_PORT(chip
, DATA
));
714 static void snd_opti93x_out(struct snd_opti93x
*chip
, unsigned char reg
,
717 snd_opti93x_busy_wait(chip
);
718 outb(chip
->mce_bit
| (reg
& 0x1f), OPTi93X_PORT(chip
, INDEX
));
719 outb(value
, OPTi93X_PORT(chip
, DATA
));
722 static void snd_opti93x_out_image(struct snd_opti93x
*chip
, unsigned char reg
,
725 snd_opti93x_out(chip
, reg
, chip
->image
[reg
] = value
);
728 static void snd_opti93x_out_mask(struct snd_opti93x
*chip
, unsigned char reg
,
729 unsigned char mask
, unsigned char value
)
731 snd_opti93x_out_image(chip
, reg
,
732 (chip
->image
[reg
] & ~mask
) | (value
& mask
));
736 static void snd_opti93x_mce_up(struct snd_opti93x
*chip
)
738 snd_opti93x_busy_wait(chip
);
740 chip
->mce_bit
= OPTi93X_MCE
;
741 if (!(inb(OPTi93X_PORT(chip
, INDEX
)) & OPTi93X_MCE
))
742 outb(chip
->mce_bit
, OPTi93X_PORT(chip
, INDEX
));
745 static void snd_opti93x_mce_down(struct snd_opti93x
*chip
)
747 snd_opti93x_busy_wait(chip
);
750 if (inb(OPTi93X_PORT(chip
, INDEX
)) & OPTi93X_MCE
)
751 outb(chip
->mce_bit
, OPTi93X_PORT(chip
, INDEX
));
754 #define snd_opti93x_mute_reg(chip, reg, mute) \
755 snd_opti93x_out(chip, reg, mute ? 0x80 : chip->image[reg]);
757 static void snd_opti93x_mute(struct snd_opti93x
*chip
, int mute
)
760 if (chip
->mute
== mute
)
765 snd_opti93x_mute_reg(chip
, OPTi93X_CD_LEFT_INPUT
, mute
);
766 snd_opti93x_mute_reg(chip
, OPTi93X_CD_RIGHT_INPUT
, mute
);
767 switch (chip
->hardware
) {
768 case OPTi9XX_HW_82C930
:
769 snd_opti93x_mute_reg(chip
, OPTi930_AUX_LEFT_INPUT
, mute
);
770 snd_opti93x_mute_reg(chip
, OPTi930_AUX_RIGHT_INPUT
, mute
);
772 case OPTi9XX_HW_82C931
:
773 case OPTi9XX_HW_82C933
:
774 snd_opti93x_mute_reg(chip
, OPTi931_FM_LEFT_INPUT
, mute
);
775 snd_opti93x_mute_reg(chip
, OPTi931_FM_RIGHT_INPUT
, mute
);
776 snd_opti93x_mute_reg(chip
, OPTi931_AUX_LEFT_INPUT
, mute
);
777 snd_opti93x_mute_reg(chip
, OPTi931_AUX_RIGHT_INPUT
, mute
);
779 snd_opti93x_mute_reg(chip
, OPTi93X_DAC_LEFT
, mute
);
780 snd_opti93x_mute_reg(chip
, OPTi93X_DAC_RIGHT
, mute
);
781 snd_opti93x_mute_reg(chip
, OPTi93X_LINE_LEFT_INPUT
, mute
);
782 snd_opti93x_mute_reg(chip
, OPTi93X_LINE_RIGHT_INPUT
, mute
);
783 snd_opti93x_mute_reg(chip
, OPTi93X_MIC_LEFT_INPUT
, mute
);
784 snd_opti93x_mute_reg(chip
, OPTi93X_MIC_RIGHT_INPUT
, mute
);
785 snd_opti93x_mute_reg(chip
, OPTi93X_OUT_LEFT
, mute
);
786 snd_opti93x_mute_reg(chip
, OPTi93X_OUT_RIGHT
, mute
);
790 static unsigned int snd_opti93x_get_count(unsigned char format
,
793 switch (format
& 0xe0) {
794 case OPTi93X_LINEAR_16_LIT
:
795 case OPTi93X_LINEAR_16_BIG
:
798 case OPTi93X_ADPCM_16
:
801 return (format
& OPTi93X_STEREO
) ? (size
>> 1) : size
;
804 static unsigned int rates
[] = { 5512, 6615, 8000, 9600, 11025, 16000,
805 18900, 22050, 27428, 32000, 33075, 37800,
807 #define RATES ARRAY_SIZE(rates)
809 static struct snd_pcm_hw_constraint_list hw_constraints_rates
= {
815 static unsigned char bits
[] = { 0x01, 0x0f, 0x00, 0x0e, 0x03, 0x02,
816 0x05, 0x07, 0x04, 0x06, 0x0d, 0x09,
819 static unsigned char snd_opti93x_get_freq(unsigned int rate
)
823 for (i
= 0; i
< RATES
; i
++) {
824 if (rate
== rates
[i
])
828 return bits
[RATES
-1];
831 static unsigned char snd_opti93x_get_format(struct snd_opti93x
*chip
,
832 unsigned int format
, int channels
)
834 unsigned char retval
= OPTi93X_LINEAR_8
;
837 case SNDRV_PCM_FORMAT_MU_LAW
:
838 retval
= OPTi93X_ULAW_8
;
840 case SNDRV_PCM_FORMAT_A_LAW
:
841 retval
= OPTi93X_ALAW_8
;
843 case SNDRV_PCM_FORMAT_S16_LE
:
844 retval
= OPTi93X_LINEAR_16_LIT
;
846 case SNDRV_PCM_FORMAT_S16_BE
:
847 retval
= OPTi93X_LINEAR_16_BIG
;
849 case SNDRV_PCM_FORMAT_IMA_ADPCM
:
850 retval
= OPTi93X_ADPCM_16
;
852 return (channels
> 1) ? (retval
| OPTi93X_STEREO
) : retval
;
856 static void snd_opti93x_playback_format(struct snd_opti93x
*chip
, unsigned char fmt
)
860 snd_opti93x_mute(chip
, 1);
862 snd_opti93x_mce_up(chip
);
863 mask
= (chip
->mode
& OPTi93X_MODE_CAPTURE
) ? 0xf0 : 0xff;
864 snd_opti93x_out_mask(chip
, OPTi93X_PLAY_FORMAT
, mask
, fmt
);
865 snd_opti93x_mce_down(chip
);
867 snd_opti93x_mute(chip
, 0);
870 static void snd_opti93x_capture_format(struct snd_opti93x
*chip
, unsigned char fmt
)
872 snd_opti93x_mute(chip
, 1);
874 snd_opti93x_mce_up(chip
);
875 if (!(chip
->mode
& OPTi93X_MODE_PLAY
))
876 snd_opti93x_out_mask(chip
, OPTi93X_PLAY_FORMAT
, 0x0f, fmt
);
878 fmt
= chip
->image
[OPTi93X_PLAY_FORMAT
] & 0xf0;
879 snd_opti93x_out_image(chip
, OPTi93X_CAPT_FORMAT
, fmt
);
880 snd_opti93x_mce_down(chip
);
882 snd_opti93x_mute(chip
, 0);
886 static int snd_opti93x_open(struct snd_opti93x
*chip
, unsigned int mode
)
890 spin_lock_irqsave(&chip
->lock
, flags
);
892 if (chip
->mode
& mode
) {
893 spin_unlock_irqrestore(&chip
->lock
, flags
);
897 if (!(chip
->mode
& OPTi93X_MODE_OPEN
)) {
898 outb(0x00, OPTi93X_PORT(chip
, STATUS
));
899 snd_opti93x_out_mask(chip
, OPTi93X_PIN_CTRL
,
900 OPTi93X_IRQ_ENABLE
, OPTi93X_IRQ_ENABLE
);
906 spin_unlock_irqrestore(&chip
->lock
, flags
);
910 static void snd_opti93x_close(struct snd_opti93x
*chip
, unsigned int mode
)
914 spin_lock_irqsave(&chip
->lock
, flags
);
917 if (chip
->mode
& OPTi93X_MODE_OPEN
) {
918 spin_unlock_irqrestore(&chip
->lock
, flags
);
922 snd_opti93x_mute(chip
, 1);
924 outb(0, OPTi93X_PORT(chip
, STATUS
));
925 snd_opti93x_out_mask(chip
, OPTi93X_PIN_CTRL
, OPTi93X_IRQ_ENABLE
,
926 ~OPTi93X_IRQ_ENABLE
);
928 snd_opti93x_mce_up(chip
);
929 snd_opti93x_out_image(chip
, OPTi93X_IFACE_CONF
, 0x00);
930 snd_opti93x_mce_down(chip
);
933 snd_opti93x_mute(chip
, 0);
934 spin_unlock_irqrestore(&chip
->lock
, flags
);
937 static int snd_opti93x_trigger(struct snd_pcm_substream
*substream
,
938 unsigned char what
, int cmd
)
940 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
943 case SNDRV_PCM_TRIGGER_START
:
944 case SNDRV_PCM_TRIGGER_STOP
:
946 unsigned int what
= 0;
947 struct snd_pcm_substream
*s
;
948 snd_pcm_group_for_each_entry(s
, substream
) {
949 if (s
== chip
->playback_substream
) {
950 what
|= OPTi93X_PLAYBACK_ENABLE
;
951 snd_pcm_trigger_done(s
, substream
);
952 } else if (s
== chip
->capture_substream
) {
953 what
|= OPTi93X_CAPTURE_ENABLE
;
954 snd_pcm_trigger_done(s
, substream
);
957 spin_lock(&chip
->lock
);
958 if (cmd
== SNDRV_PCM_TRIGGER_START
) {
959 snd_opti93x_out_mask(chip
, OPTi93X_IFACE_CONF
, what
, what
);
960 if (what
& OPTi93X_CAPTURE_ENABLE
)
963 snd_opti93x_out_mask(chip
, OPTi93X_IFACE_CONF
, what
, 0x00);
964 spin_unlock(&chip
->lock
);
973 static int snd_opti93x_playback_trigger(struct snd_pcm_substream
*substream
, int cmd
)
975 return snd_opti93x_trigger(substream
,
976 OPTi93X_PLAYBACK_ENABLE
, cmd
);
979 static int snd_opti93x_capture_trigger(struct snd_pcm_substream
*substream
, int cmd
)
981 return snd_opti93x_trigger(substream
,
982 OPTi93X_CAPTURE_ENABLE
, cmd
);
985 static int snd_opti93x_hw_params(struct snd_pcm_substream
*substream
,
986 struct snd_pcm_hw_params
*hw_params
)
988 return snd_pcm_lib_malloc_pages(substream
, params_buffer_bytes(hw_params
));
992 static int snd_opti93x_hw_free(struct snd_pcm_substream
*substream
)
994 snd_pcm_lib_free_pages(substream
);
999 static int snd_opti93x_playback_prepare(struct snd_pcm_substream
*substream
)
1001 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1002 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1003 unsigned long flags
;
1004 unsigned char format
;
1005 unsigned int count
= snd_pcm_lib_period_bytes(substream
);
1006 unsigned int size
= snd_pcm_lib_buffer_bytes(substream
);
1008 spin_lock_irqsave(&chip
->lock
, flags
);
1010 chip
->p_dma_size
= size
;
1011 snd_opti93x_out_mask(chip
, OPTi93X_IFACE_CONF
,
1012 OPTi93X_PLAYBACK_ENABLE
| OPTi93X_PLAYBACK_PIO
,
1013 ~(OPTi93X_PLAYBACK_ENABLE
| OPTi93X_PLAYBACK_PIO
));
1015 snd_dma_program(chip
->dma1
, runtime
->dma_addr
, size
,
1016 DMA_MODE_WRITE
| DMA_AUTOINIT
);
1018 format
= snd_opti93x_get_freq(runtime
->rate
);
1019 format
|= snd_opti93x_get_format(chip
, runtime
->format
,
1021 snd_opti93x_playback_format(chip
, format
);
1022 format
= chip
->image
[OPTi93X_PLAY_FORMAT
];
1024 count
= snd_opti93x_get_count(format
, count
) - 1;
1025 snd_opti93x_out_image(chip
, OPTi93X_PLAY_LWR_CNT
, count
);
1026 snd_opti93x_out_image(chip
, OPTi93X_PLAY_UPR_CNT
, count
>> 8);
1028 spin_unlock_irqrestore(&chip
->lock
, flags
);
1032 static int snd_opti93x_capture_prepare(struct snd_pcm_substream
*substream
)
1034 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1035 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1036 unsigned long flags
;
1037 unsigned char format
;
1038 unsigned int count
= snd_pcm_lib_period_bytes(substream
);
1039 unsigned int size
= snd_pcm_lib_buffer_bytes(substream
);
1041 spin_lock_irqsave(&chip
->lock
, flags
);
1043 chip
->c_dma_size
= size
;
1044 snd_opti93x_out_mask(chip
, OPTi93X_IFACE_CONF
,
1045 OPTi93X_CAPTURE_ENABLE
| OPTi93X_CAPTURE_PIO
, 0);
1047 snd_dma_program(chip
->dma2
, runtime
->dma_addr
, size
,
1048 DMA_MODE_READ
| DMA_AUTOINIT
);
1050 format
= snd_opti93x_get_freq(runtime
->rate
);
1051 format
|= snd_opti93x_get_format(chip
, runtime
->format
,
1053 snd_opti93x_capture_format(chip
, format
);
1054 format
= chip
->image
[OPTi93X_CAPT_FORMAT
];
1056 count
= snd_opti93x_get_count(format
, count
) - 1;
1057 snd_opti93x_out_image(chip
, OPTi93X_CAPT_LWR_CNT
, count
);
1058 snd_opti93x_out_image(chip
, OPTi93X_CAPT_UPR_CNT
, count
>> 8);
1060 spin_unlock_irqrestore(&chip
->lock
, flags
);
1064 static snd_pcm_uframes_t
snd_opti93x_playback_pointer(struct snd_pcm_substream
*substream
)
1066 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1069 if (!(chip
->image
[OPTi93X_IFACE_CONF
] & OPTi93X_PLAYBACK_ENABLE
))
1072 ptr
= snd_dma_pointer(chip
->dma1
, chip
->p_dma_size
);
1073 return bytes_to_frames(substream
->runtime
, ptr
);
1076 static snd_pcm_uframes_t
snd_opti93x_capture_pointer(struct snd_pcm_substream
*substream
)
1078 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1081 if (!(chip
->image
[OPTi93X_IFACE_CONF
] & OPTi93X_CAPTURE_ENABLE
))
1084 ptr
= snd_dma_pointer(chip
->dma2
, chip
->c_dma_size
);
1085 return bytes_to_frames(substream
->runtime
, ptr
);
1089 static void snd_opti93x_overrange(struct snd_opti93x
*chip
)
1091 unsigned long flags
;
1093 spin_lock_irqsave(&chip
->lock
, flags
);
1095 if (snd_opti93x_in(chip
, OPTi93X_ERR_INIT
) & (0x08 | 0x02))
1096 chip
->capture_substream
->runtime
->overrange
++;
1098 spin_unlock_irqrestore(&chip
->lock
, flags
);
1101 static irqreturn_t
snd_opti93x_interrupt(int irq
, void *dev_id
)
1103 struct snd_opti93x
*codec
= dev_id
;
1104 unsigned char status
;
1106 status
= snd_opti9xx_read(codec
->chip
, OPTi9XX_MC_REG(11));
1107 if ((status
& OPTi93X_IRQ_PLAYBACK
) && codec
->playback_substream
)
1108 snd_pcm_period_elapsed(codec
->playback_substream
);
1109 if ((status
& OPTi93X_IRQ_CAPTURE
) && codec
->capture_substream
) {
1110 snd_opti93x_overrange(codec
);
1111 snd_pcm_period_elapsed(codec
->capture_substream
);
1113 outb(0x00, OPTi93X_PORT(codec
, STATUS
));
1118 static struct snd_pcm_hardware snd_opti93x_playback
= {
1119 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1120 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_SYNC_START
),
1121 .formats
= (SNDRV_PCM_FMTBIT_MU_LAW
| SNDRV_PCM_FMTBIT_A_LAW
| SNDRV_PCM_FMTBIT_IMA_ADPCM
|
1122 SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_S16_BE
),
1123 .rates
= SNDRV_PCM_RATE_KNOT
| SNDRV_PCM_RATE_8000_48000
,
1128 .buffer_bytes_max
= (128*1024),
1129 .period_bytes_min
= 64,
1130 .period_bytes_max
= (128*1024),
1132 .periods_max
= 1024,
1136 static struct snd_pcm_hardware snd_opti93x_capture
= {
1137 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1138 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_SYNC_START
),
1139 .formats
= (SNDRV_PCM_FMTBIT_MU_LAW
| SNDRV_PCM_FMTBIT_A_LAW
| SNDRV_PCM_FMTBIT_IMA_ADPCM
|
1140 SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_S16_BE
),
1141 .rates
= SNDRV_PCM_RATE_8000_48000
,
1146 .buffer_bytes_max
= (128*1024),
1147 .period_bytes_min
= 64,
1148 .period_bytes_max
= (128*1024),
1150 .periods_max
= 1024,
1154 static int snd_opti93x_playback_open(struct snd_pcm_substream
*substream
)
1157 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1158 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1160 if ((error
= snd_opti93x_open(chip
, OPTi93X_MODE_PLAY
)) < 0)
1162 snd_pcm_set_sync(substream
);
1163 chip
->playback_substream
= substream
;
1164 runtime
->hw
= snd_opti93x_playback
;
1165 snd_pcm_limit_isa_dma_size(chip
->dma1
, &runtime
->hw
.buffer_bytes_max
);
1166 snd_pcm_hw_constraint_list(runtime
, 0, SNDRV_PCM_HW_PARAM_RATE
, &hw_constraints_rates
);
1170 static int snd_opti93x_capture_open(struct snd_pcm_substream
*substream
)
1173 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1174 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1176 if ((error
= snd_opti93x_open(chip
, OPTi93X_MODE_CAPTURE
)) < 0)
1178 runtime
->hw
= snd_opti93x_capture
;
1179 snd_pcm_set_sync(substream
);
1180 chip
->capture_substream
= substream
;
1181 snd_pcm_limit_isa_dma_size(chip
->dma2
, &runtime
->hw
.buffer_bytes_max
);
1182 snd_pcm_hw_constraint_list(runtime
, 0, SNDRV_PCM_HW_PARAM_RATE
, &hw_constraints_rates
);
1186 static int snd_opti93x_playback_close(struct snd_pcm_substream
*substream
)
1188 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1190 chip
->playback_substream
= NULL
;
1191 snd_opti93x_close(chip
, OPTi93X_MODE_PLAY
);
1195 static int snd_opti93x_capture_close(struct snd_pcm_substream
*substream
)
1197 struct snd_opti93x
*chip
= snd_pcm_substream_chip(substream
);
1199 chip
->capture_substream
= NULL
;
1200 snd_opti93x_close(chip
, OPTi93X_MODE_CAPTURE
);
1205 static void snd_opti93x_init(struct snd_opti93x
*chip
)
1207 unsigned long flags
;
1210 spin_lock_irqsave(&chip
->lock
, flags
);
1211 snd_opti93x_mce_up(chip
);
1213 for (i
= 0; i
< 32; i
++)
1214 snd_opti93x_out_image(chip
, i
, snd_opti93x_default_image
[i
]);
1216 snd_opti93x_mce_down(chip
);
1217 spin_unlock_irqrestore(&chip
->lock
, flags
);
1220 static int snd_opti93x_probe(struct snd_opti93x
*chip
)
1222 unsigned long flags
;
1225 spin_lock_irqsave(&chip
->lock
, flags
);
1226 val
= snd_opti93x_in(chip
, OPTi93X_ID
) & 0x0f;
1227 spin_unlock_irqrestore(&chip
->lock
, flags
);
1229 return (val
== 0x0a) ? 0 : -ENODEV
;
1232 static int snd_opti93x_free(struct snd_opti93x
*chip
)
1234 release_and_free_resource(chip
->res_port
);
1235 if (chip
->dma1
>= 0) {
1236 disable_dma(chip
->dma1
);
1237 free_dma(chip
->dma1
);
1239 if (chip
->dma2
>= 0) {
1240 disable_dma(chip
->dma2
);
1241 free_dma(chip
->dma2
);
1243 if (chip
->irq
>= 0) {
1244 free_irq(chip
->irq
, chip
);
1250 static int snd_opti93x_dev_free(struct snd_device
*device
)
1252 struct snd_opti93x
*chip
= device
->device_data
;
1253 return snd_opti93x_free(chip
);
1256 static const char *snd_opti93x_chip_id(struct snd_opti93x
*codec
)
1258 switch (codec
->hardware
) {
1259 case OPTi9XX_HW_82C930
: return "82C930";
1260 case OPTi9XX_HW_82C931
: return "82C931";
1261 case OPTi9XX_HW_82C933
: return "82C933";
1262 default: return "???";
1266 static int snd_opti93x_create(struct snd_card
*card
, struct snd_opti9xx
*chip
,
1268 struct snd_opti93x
**rcodec
)
1270 static struct snd_device_ops ops
= {
1271 .dev_free
= snd_opti93x_dev_free
,
1274 struct snd_opti93x
*codec
;
1277 codec
= kzalloc(sizeof(*codec
), GFP_KERNEL
);
1284 if ((codec
->res_port
= request_region(chip
->wss_base
+ 4, 4, "OPTI93x CODEC")) == NULL
) {
1285 snd_printk(KERN_ERR
"opti9xx: can't grab port 0x%lx\n", chip
->wss_base
+ 4);
1286 snd_opti93x_free(codec
);
1289 if (request_dma(dma1
, "OPTI93x - 1")) {
1290 snd_printk(KERN_ERR
"opti9xx: can't grab DMA1 %d\n", dma1
);
1291 snd_opti93x_free(codec
);
1294 codec
->dma1
= chip
->dma1
;
1295 if (request_dma(dma2
, "OPTI93x - 2")) {
1296 snd_printk(KERN_ERR
"opti9xx: can't grab DMA2 %d\n", dma2
);
1297 snd_opti93x_free(codec
);
1300 codec
->dma2
= chip
->dma2
;
1302 if (request_irq(chip
->irq
, snd_opti93x_interrupt
, IRQF_DISABLED
, DEV_NAME
" - WSS", codec
)) {
1303 snd_printk(KERN_ERR
"opti9xx: can't grab IRQ %d\n", chip
->irq
);
1304 snd_opti93x_free(codec
);
1309 codec
->port
= chip
->wss_base
+ 4;
1310 codec
->irq
= chip
->irq
;
1312 spin_lock_init(&codec
->lock
);
1313 codec
->hardware
= chip
->hardware
;
1316 if ((error
= snd_opti93x_probe(codec
))) {
1317 snd_opti93x_free(codec
);
1321 snd_opti93x_init(codec
);
1323 /* Register device */
1324 if ((error
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, codec
, &ops
)) < 0) {
1325 snd_opti93x_free(codec
);
1333 static struct snd_pcm_ops snd_opti93x_playback_ops
= {
1334 .open
= snd_opti93x_playback_open
,
1335 .close
= snd_opti93x_playback_close
,
1336 .ioctl
= snd_pcm_lib_ioctl
,
1337 .hw_params
= snd_opti93x_hw_params
,
1338 .hw_free
= snd_opti93x_hw_free
,
1339 .prepare
= snd_opti93x_playback_prepare
,
1340 .trigger
= snd_opti93x_playback_trigger
,
1341 .pointer
= snd_opti93x_playback_pointer
,
1344 static struct snd_pcm_ops snd_opti93x_capture_ops
= {
1345 .open
= snd_opti93x_capture_open
,
1346 .close
= snd_opti93x_capture_close
,
1347 .ioctl
= snd_pcm_lib_ioctl
,
1348 .hw_params
= snd_opti93x_hw_params
,
1349 .hw_free
= snd_opti93x_hw_free
,
1350 .prepare
= snd_opti93x_capture_prepare
,
1351 .trigger
= snd_opti93x_capture_trigger
,
1352 .pointer
= snd_opti93x_capture_pointer
,
1355 static int snd_opti93x_pcm(struct snd_opti93x
*codec
, int device
, struct snd_pcm
**rpcm
)
1358 struct snd_pcm
*pcm
;
1360 if ((error
= snd_pcm_new(codec
->card
, "OPTi 82C93X", device
, 1, 1, &pcm
)) < 0)
1363 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_opti93x_playback_ops
);
1364 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_opti93x_capture_ops
);
1366 pcm
->private_data
= codec
;
1367 pcm
->info_flags
= SNDRV_PCM_INFO_JOINT_DUPLEX
;
1369 strcpy(pcm
->name
, snd_opti93x_chip_id(codec
));
1371 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
1373 64*1024, codec
->dma1
> 3 || codec
->dma2
> 3 ? 128*1024 : 64*1024);
1385 static int snd_opti93x_info_mux(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
1387 static char *texts
[4] = {
1388 "Line1", "Aux", "Mic", "Mix"
1391 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
1393 uinfo
->value
.enumerated
.items
= 4;
1394 if (uinfo
->value
.enumerated
.item
> 3)
1395 uinfo
->value
.enumerated
.item
= 3;
1396 strcpy(uinfo
->value
.enumerated
.name
, texts
[uinfo
->value
.enumerated
.item
]);
1400 static int snd_opti93x_get_mux(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1402 struct snd_opti93x
*chip
= snd_kcontrol_chip(kcontrol
);
1403 unsigned long flags
;
1405 spin_lock_irqsave(&chip
->lock
, flags
);
1406 ucontrol
->value
.enumerated
.item
[0] = (chip
->image
[OPTi93X_MIXOUT_LEFT
] & OPTi93X_MIXOUT_MIXER
) >> 6;
1407 ucontrol
->value
.enumerated
.item
[1] = (chip
->image
[OPTi93X_MIXOUT_RIGHT
] & OPTi93X_MIXOUT_MIXER
) >> 6;
1408 spin_unlock_irqrestore(&chip
->lock
, flags
);
1412 static int snd_opti93x_put_mux(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1414 struct snd_opti93x
*chip
= snd_kcontrol_chip(kcontrol
);
1415 unsigned long flags
;
1416 unsigned short left
, right
;
1419 if (ucontrol
->value
.enumerated
.item
[0] > 3 ||
1420 ucontrol
->value
.enumerated
.item
[1] > 3)
1422 left
= ucontrol
->value
.enumerated
.item
[0] << 6;
1423 right
= ucontrol
->value
.enumerated
.item
[1] << 6;
1424 spin_lock_irqsave(&chip
->lock
, flags
);
1425 left
= (chip
->image
[OPTi93X_MIXOUT_LEFT
] & ~OPTi93X_MIXOUT_MIXER
) | left
;
1426 right
= (chip
->image
[OPTi93X_MIXOUT_RIGHT
] & ~OPTi93X_MIXOUT_MIXER
) | right
;
1427 change
= left
!= chip
->image
[OPTi93X_MIXOUT_LEFT
] ||
1428 right
!= chip
->image
[OPTi93X_MIXOUT_RIGHT
];
1429 snd_opti93x_out_image(chip
, OPTi93X_MIXOUT_LEFT
, left
);
1430 snd_opti93x_out_image(chip
, OPTi93X_MIXOUT_RIGHT
, right
);
1431 spin_unlock_irqrestore(&chip
->lock
, flags
);
1437 #define OPTi93X_SINGLE(xname, xindex, reg, shift, mask, invert) \
1438 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1439 .info = snd_opti93x_info_single, \
1440 .get = snd_opti93x_get_single, .put = snd_opti93x_put_single, \
1441 .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
1443 static int snd_opti93x_info_single(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
1445 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
1447 uinfo
->type
= mask
== 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN
: SNDRV_CTL_ELEM_TYPE_INTEGER
;
1449 uinfo
->value
.integer
.min
= 0;
1450 uinfo
->value
.integer
.max
= mask
;
1454 static int snd_opti93x_get_single(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1456 struct snd_opti93x
*chip
= snd_kcontrol_chip(kcontrol
);
1457 unsigned long flags
;
1458 int reg
= kcontrol
->private_value
& 0xff;
1459 int shift
= (kcontrol
->private_value
>> 8) & 0xff;
1460 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
1461 int invert
= (kcontrol
->private_value
>> 24) & 0xff;
1463 spin_lock_irqsave(&chip
->lock
, flags
);
1464 ucontrol
->value
.integer
.value
[0] = (chip
->image
[reg
] >> shift
) & mask
;
1465 spin_unlock_irqrestore(&chip
->lock
, flags
);
1467 ucontrol
->value
.integer
.value
[0] = mask
- ucontrol
->value
.integer
.value
[0];
1471 static int snd_opti93x_put_single(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1473 struct snd_opti93x
*chip
= snd_kcontrol_chip(kcontrol
);
1474 unsigned long flags
;
1475 int reg
= kcontrol
->private_value
& 0xff;
1476 int shift
= (kcontrol
->private_value
>> 8) & 0xff;
1477 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
1478 int invert
= (kcontrol
->private_value
>> 24) & 0xff;
1482 val
= (ucontrol
->value
.integer
.value
[0] & mask
);
1486 spin_lock_irqsave(&chip
->lock
, flags
);
1487 val
= (chip
->image
[reg
] & ~(mask
<< shift
)) | val
;
1488 change
= val
!= chip
->image
[reg
];
1489 snd_opti93x_out(chip
, reg
, val
);
1490 spin_unlock_irqrestore(&chip
->lock
, flags
);
1496 #define OPTi93X_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1497 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1498 .info = snd_opti93x_info_double, \
1499 .get = snd_opti93x_get_double, .put = snd_opti93x_put_double, \
1500 .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1502 #define OPTi93X_DOUBLE_INVERT_INVERT(xctl) \
1503 do { xctl.private_value ^= 22; } while (0)
1504 #define OPTi93X_DOUBLE_CHANGE_REGS(xctl, left_reg, right_reg) \
1505 do { xctl.private_value &= ~0x0000ffff; \
1506 xctl.private_value |= left_reg | (right_reg << 8); } while (0)
1508 static int snd_opti93x_info_double(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
1510 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
1512 uinfo
->type
= mask
== 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN
: SNDRV_CTL_ELEM_TYPE_INTEGER
;
1514 uinfo
->value
.integer
.min
= 0;
1515 uinfo
->value
.integer
.max
= mask
;
1519 static int snd_opti93x_get_double(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1521 struct snd_opti93x
*chip
= snd_kcontrol_chip(kcontrol
);
1522 unsigned long flags
;
1523 int left_reg
= kcontrol
->private_value
& 0xff;
1524 int right_reg
= (kcontrol
->private_value
>> 8) & 0xff;
1525 int shift_left
= (kcontrol
->private_value
>> 16) & 0x07;
1526 int shift_right
= (kcontrol
->private_value
>> 19) & 0x07;
1527 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
1528 int invert
= (kcontrol
->private_value
>> 22) & 1;
1530 spin_lock_irqsave(&chip
->lock
, flags
);
1531 ucontrol
->value
.integer
.value
[0] = (chip
->image
[left_reg
] >> shift_left
) & mask
;
1532 ucontrol
->value
.integer
.value
[1] = (chip
->image
[right_reg
] >> shift_right
) & mask
;
1533 spin_unlock_irqrestore(&chip
->lock
, flags
);
1535 ucontrol
->value
.integer
.value
[0] = mask
- ucontrol
->value
.integer
.value
[0];
1536 ucontrol
->value
.integer
.value
[1] = mask
- ucontrol
->value
.integer
.value
[1];
1541 static int snd_opti93x_put_double(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1543 struct snd_opti93x
*chip
= snd_kcontrol_chip(kcontrol
);
1544 unsigned long flags
;
1545 int left_reg
= kcontrol
->private_value
& 0xff;
1546 int right_reg
= (kcontrol
->private_value
>> 8) & 0xff;
1547 int shift_left
= (kcontrol
->private_value
>> 16) & 0x07;
1548 int shift_right
= (kcontrol
->private_value
>> 19) & 0x07;
1549 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
1550 int invert
= (kcontrol
->private_value
>> 22) & 1;
1552 unsigned short val1
, val2
;
1554 val1
= ucontrol
->value
.integer
.value
[0] & mask
;
1555 val2
= ucontrol
->value
.integer
.value
[1] & mask
;
1560 val1
<<= shift_left
;
1561 val2
<<= shift_right
;
1562 spin_lock_irqsave(&chip
->lock
, flags
);
1563 val1
= (chip
->image
[left_reg
] & ~(mask
<< shift_left
)) | val1
;
1564 val2
= (chip
->image
[right_reg
] & ~(mask
<< shift_right
)) | val2
;
1565 change
= val1
!= chip
->image
[left_reg
] || val2
!= chip
->image
[right_reg
];
1566 snd_opti93x_out_image(chip
, left_reg
, val1
);
1567 snd_opti93x_out_image(chip
, right_reg
, val2
);
1568 spin_unlock_irqrestore(&chip
->lock
, flags
);
1572 static struct snd_kcontrol_new snd_opti93x_controls
[] __devinitdata
= {
1573 OPTi93X_DOUBLE("Master Playback Switch", 0, OPTi93X_OUT_LEFT
, OPTi93X_OUT_RIGHT
, 7, 7, 1, 1),
1574 OPTi93X_DOUBLE("Master Playback Volume", 0, OPTi93X_OUT_LEFT
, OPTi93X_OUT_RIGHT
, 1, 1, 31, 1),
1575 OPTi93X_DOUBLE("PCM Playback Switch", 0, OPTi93X_DAC_LEFT
, OPTi93X_DAC_RIGHT
, 7, 7, 1, 1),
1576 OPTi93X_DOUBLE("PCM Playback Volume", 0, OPTi93X_DAC_LEFT
, OPTi93X_DAC_RIGHT
, 0, 0, 31, 1),
1577 OPTi93X_DOUBLE("FM Playback Switch", 0, OPTi931_FM_LEFT_INPUT
, OPTi931_FM_RIGHT_INPUT
, 7, 7, 1, 1),
1578 OPTi93X_DOUBLE("FM Playback Volume", 0, OPTi931_FM_LEFT_INPUT
, OPTi931_FM_RIGHT_INPUT
, 1, 1, 15, 1),
1579 OPTi93X_DOUBLE("Line Playback Switch", 0, OPTi93X_LINE_LEFT_INPUT
, OPTi93X_LINE_RIGHT_INPUT
, 7, 7, 1, 1),
1580 OPTi93X_DOUBLE("Line Playback Volume", 0, OPTi93X_LINE_LEFT_INPUT
, OPTi93X_LINE_RIGHT_INPUT
, 1, 1, 15, 1),
1581 OPTi93X_DOUBLE("Mic Playback Switch", 0, OPTi93X_MIC_LEFT_INPUT
, OPTi93X_MIC_RIGHT_INPUT
, 7, 7, 1, 1),
1582 OPTi93X_DOUBLE("Mic Playback Volume", 0, OPTi93X_MIC_LEFT_INPUT
, OPTi93X_MIC_RIGHT_INPUT
, 1, 1, 15, 1),
1583 OPTi93X_DOUBLE("Mic Boost", 0, OPTi93X_MIXOUT_LEFT
, OPTi93X_MIXOUT_RIGHT
, 5, 5, 1, 1),
1584 OPTi93X_DOUBLE("CD Playback Switch", 0, OPTi93X_CD_LEFT_INPUT
, OPTi93X_CD_RIGHT_INPUT
, 7, 7, 1, 1),
1585 OPTi93X_DOUBLE("CD Playback Volume", 0, OPTi93X_CD_LEFT_INPUT
, OPTi93X_CD_RIGHT_INPUT
, 1, 1, 15, 1),
1586 OPTi93X_DOUBLE("Aux Playback Switch", 0, OPTi931_AUX_LEFT_INPUT
, OPTi931_AUX_RIGHT_INPUT
, 7, 7, 1, 1),
1587 OPTi93X_DOUBLE("Aux Playback Volume", 0, OPTi931_AUX_LEFT_INPUT
, OPTi931_AUX_RIGHT_INPUT
, 1, 1, 15, 1),
1588 OPTi93X_DOUBLE("Capture Volume", 0, OPTi93X_MIXOUT_LEFT
, OPTi93X_MIXOUT_RIGHT
, 0, 0, 15, 0),
1590 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1591 .name
= "Capture Source",
1592 .info
= snd_opti93x_info_mux
,
1593 .get
= snd_opti93x_get_mux
,
1594 .put
= snd_opti93x_put_mux
,
1598 static int snd_opti93x_mixer(struct snd_opti93x
*chip
)
1600 struct snd_card
*card
;
1601 struct snd_kcontrol_new knew
;
1605 snd_assert(chip
!= NULL
&& chip
->card
!= NULL
, return -EINVAL
);
1609 strcpy(card
->mixername
, snd_opti93x_chip_id(chip
));
1611 for (idx
= 0; idx
< ARRAY_SIZE(snd_opti93x_controls
); idx
++) {
1612 knew
= snd_opti93x_controls
[idx
];
1613 if (chip
->hardware
== OPTi9XX_HW_82C930
) {
1614 if (strstr(knew
.name
, "FM")) /* skip FM controls */
1616 else if (strcmp(knew
.name
, "Mic Playback Volume"))
1617 OPTi93X_DOUBLE_INVERT_INVERT(knew
);
1618 else if (strstr(knew
.name
, "Aux"))
1619 OPTi93X_DOUBLE_CHANGE_REGS(knew
, OPTi930_AUX_LEFT_INPUT
, OPTi930_AUX_RIGHT_INPUT
);
1620 else if (strcmp(knew
.name
, "PCM Playback Volume"))
1621 OPTi93X_DOUBLE_INVERT_INVERT(knew
);
1622 else if (strcmp(knew
.name
, "Master Playback Volume"))
1623 OPTi93X_DOUBLE_INVERT_INVERT(knew
);
1625 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&snd_opti93x_controls
[idx
], chip
))) < 0)
1631 #endif /* OPTi93X */
1633 static int __devinit
snd_card_opti9xx_detect(struct snd_card
*card
,
1634 struct snd_opti9xx
*chip
)
1639 for (i
= OPTi9XX_HW_82C928
; i
< OPTi9XX_HW_82C930
; i
++) {
1640 unsigned char value
;
1642 if ((err
= snd_opti9xx_init(chip
, i
)) < 0)
1645 if ((chip
->res_mc_base
= request_region(chip
->mc_base
, chip
->mc_base_size
, "OPTi9xx MC")) == NULL
)
1648 value
= snd_opti9xx_read(chip
, OPTi9XX_MC_REG(1));
1649 if ((value
!= 0xff) && (value
!= inb(chip
->mc_base
+ 1)))
1650 if (value
== snd_opti9xx_read(chip
, OPTi9XX_MC_REG(1)))
1653 release_and_free_resource(chip
->res_mc_base
);
1654 chip
->res_mc_base
= NULL
;
1658 for (i
= OPTi9XX_HW_82C931
; i
>= OPTi9XX_HW_82C930
; i
--) {
1659 unsigned long flags
;
1660 unsigned char value
;
1662 if ((err
= snd_opti9xx_init(chip
, i
)) < 0)
1665 if ((chip
->res_mc_base
= request_region(chip
->mc_base
, chip
->mc_base_size
, "OPTi9xx MC")) == NULL
)
1668 spin_lock_irqsave(&chip
->lock
, flags
);
1669 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
1670 outb(((chip
->mc_indir_index
& (1 << 8)) >> 4) |
1671 ((chip
->mc_indir_index
& 0xf0) >> 4), chip
->mc_base
);
1672 spin_unlock_irqrestore(&chip
->lock
, flags
);
1674 value
= snd_opti9xx_read(chip
, OPTi9XX_MC_REG(7));
1675 snd_opti9xx_write(chip
, OPTi9XX_MC_REG(7), 0xff - value
);
1676 if (snd_opti9xx_read(chip
, OPTi9XX_MC_REG(7)) == 0xff - value
)
1679 release_and_free_resource(chip
->res_mc_base
);
1680 chip
->res_mc_base
= NULL
;
1682 #endif /* OPTi93X */
1688 static int __devinit
snd_card_opti9xx_pnp(struct snd_opti9xx
*chip
,
1689 struct pnp_card_link
*card
,
1690 const struct pnp_card_device_id
*pid
)
1692 struct pnp_dev
*pdev
;
1693 struct pnp_resource_table
*cfg
= kmalloc(sizeof(*cfg
), GFP_KERNEL
);
1698 chip
->dev
= pnp_request_card_device(card
, pid
->devs
[0].id
, NULL
);
1699 if (chip
->dev
== NULL
) {
1703 chip
->devmpu
= pnp_request_card_device(card
, pid
->devs
[1].id
, NULL
);
1706 pnp_init_resource_table(cfg
);
1709 if (port
!= SNDRV_AUTO_PORT
)
1710 pnp_resource_change(&cfg
->port_resource
[0], port
+ 4, 4);
1712 if (pid
->driver_data
!= 0x0924 && port
!= SNDRV_AUTO_PORT
)
1713 pnp_resource_change(&cfg
->port_resource
[1], port
, 4);
1714 #endif /* OPTi93X */
1715 if (irq
!= SNDRV_AUTO_IRQ
)
1716 pnp_resource_change(&cfg
->irq_resource
[0], irq
, 1);
1717 if (dma1
!= SNDRV_AUTO_DMA
)
1718 pnp_resource_change(&cfg
->dma_resource
[0], dma1
, 1);
1719 #if defined(CS4231) || defined(OPTi93X)
1720 if (dma2
!= SNDRV_AUTO_DMA
)
1721 pnp_resource_change(&cfg
->dma_resource
[1], dma2
, 1);
1723 #ifdef snd_opti9xx_fixup_dma2
1724 snd_opti9xx_fixup_dma2(pdev
);
1726 #endif /* CS4231 || OPTi93X */
1728 if (fm_port
> 0 && fm_port
!= SNDRV_AUTO_PORT
)
1729 pnp_resource_change(&cfg
->port_resource
[1], fm_port
, 4);
1731 if (fm_port
> 0 && fm_port
!= SNDRV_AUTO_PORT
)
1732 pnp_resource_change(&cfg
->port_resource
[2], fm_port
, 4);
1734 if (pnp_manual_config_dev(pdev
, cfg
, 0) < 0)
1735 snd_printk(KERN_ERR
"AUDIO the requested resources are invalid, using auto config\n");
1736 err
= pnp_activate_dev(pdev
);
1738 snd_printk(KERN_ERR
"AUDIO pnp configure failure: %d\n", err
);
1744 port
= pnp_port_start(pdev
, 0) - 4;
1745 fm_port
= pnp_port_start(pdev
, 1) + 8;
1747 if (pid
->driver_data
!= 0x0924)
1748 port
= pnp_port_start(pdev
, 1);
1749 fm_port
= pnp_port_start(pdev
, 2) + 8;
1750 #endif /* OPTi93X */
1751 irq
= pnp_irq(pdev
, 0);
1752 dma1
= pnp_dma(pdev
, 0);
1753 #if defined(CS4231) || defined(OPTi93X)
1754 dma2
= pnp_dma(pdev
, 1);
1755 #endif /* CS4231 || OPTi93X */
1757 pdev
= chip
->devmpu
;
1758 if (pdev
&& mpu_port
> 0) {
1759 pnp_init_resource_table(cfg
);
1761 if (mpu_port
!= SNDRV_AUTO_PORT
)
1762 pnp_resource_change(&cfg
->port_resource
[0], mpu_port
, 2);
1763 if (mpu_irq
!= SNDRV_AUTO_IRQ
)
1764 pnp_resource_change(&cfg
->irq_resource
[0], mpu_irq
, 1);
1766 if (pnp_manual_config_dev(pdev
, cfg
, 0) < 0)
1767 snd_printk(KERN_ERR
"AUDIO the requested resources are invalid, using auto config\n");
1768 err
= pnp_activate_dev(pdev
);
1770 snd_printk(KERN_ERR
"AUDIO pnp configure failure\n");
1772 chip
->devmpu
= NULL
;
1774 mpu_port
= pnp_port_start(pdev
, 0);
1775 mpu_irq
= pnp_irq(pdev
, 0);
1779 return pid
->driver_data
;
1781 #endif /* CONFIG_PNP */
1783 static void snd_card_opti9xx_free(struct snd_card
*card
)
1785 struct snd_opti9xx
*chip
= card
->private_data
;
1788 release_and_free_resource(chip
->res_mc_base
);
1791 static int __devinit
snd_opti9xx_probe(struct snd_card
*card
)
1793 static long possible_ports
[] = {0x530, 0xe80, 0xf40, 0x604, -1};
1795 struct snd_opti9xx
*chip
= card
->private_data
;
1796 #if defined(OPTi93X)
1797 struct snd_opti93x
*codec
;
1798 #elif defined(CS4231)
1799 struct snd_cs4231
*codec
;
1800 struct snd_timer
*timer
;
1802 struct snd_ad1848
*codec
;
1804 struct snd_pcm
*pcm
;
1805 struct snd_rawmidi
*rmidi
;
1806 struct snd_hwdep
*synth
;
1808 if (! chip
->res_mc_base
&&
1809 (chip
->res_mc_base
= request_region(chip
->mc_base
, chip
->mc_base_size
,
1810 "OPTi9xx MC")) == NULL
)
1813 chip
->wss_base
= port
;
1814 chip
->fm_port
= fm_port
;
1815 chip
->mpu_port
= mpu_port
;
1817 chip
->mpu_irq
= mpu_irq
;
1819 #if defined(CS4231) || defined(OPTi93X)
1823 if (chip
->wss_base
== SNDRV_AUTO_PORT
) {
1824 if ((chip
->wss_base
= snd_legacy_find_free_ioport(possible_ports
, 4)) < 0) {
1825 snd_printk("unable to find a free WSS port\n");
1829 if ((error
= snd_opti9xx_configure(chip
)))
1832 #if defined(OPTi93X)
1833 if ((error
= snd_opti93x_create(card
, chip
, chip
->dma1
, chip
->dma2
, &codec
)))
1835 if ((error
= snd_opti93x_pcm(codec
, 0, &pcm
)) < 0)
1837 if ((error
= snd_opti93x_mixer(codec
)) < 0)
1839 #elif defined(CS4231)
1840 if ((error
= snd_cs4231_create(card
, chip
->wss_base
+ 4, -1,
1841 chip
->irq
, chip
->dma1
, chip
->dma2
,
1846 if ((error
= snd_cs4231_pcm(codec
, 0, &pcm
)) < 0)
1848 if ((error
= snd_cs4231_mixer(codec
)) < 0)
1850 if ((error
= snd_cs4231_timer(codec
, 0, &timer
)) < 0)
1853 if ((error
= snd_ad1848_create(card
, chip
->wss_base
+ 4,
1854 chip
->irq
, chip
->dma1
,
1855 AD1848_HW_DETECT
, &codec
)) < 0)
1857 if ((error
= snd_ad1848_pcm(codec
, 0, &pcm
)) < 0)
1859 if ((error
= snd_ad1848_mixer(codec
)) < 0)
1862 strcpy(card
->driver
, chip
->name
);
1863 sprintf(card
->shortname
, "OPTi %s", card
->driver
);
1864 #if defined(CS4231) || defined(OPTi93X)
1865 sprintf(card
->longname
, "%s, %s at 0x%lx, irq %d, dma %d&%d",
1866 card
->shortname
, pcm
->name
, chip
->wss_base
+ 4,
1867 chip
->irq
, chip
->dma1
, chip
->dma2
);
1869 sprintf(card
->longname
, "%s, %s at 0x%lx, irq %d, dma %d",
1870 card
->shortname
, pcm
->name
, chip
->wss_base
+ 4,
1871 chip
->irq
, chip
->dma1
);
1872 #endif /* CS4231 || OPTi93X */
1874 if (chip
->mpu_port
<= 0 || chip
->mpu_port
== SNDRV_AUTO_PORT
)
1877 if ((error
= snd_mpu401_uart_new(card
, 0, MPU401_HW_MPU401
,
1878 chip
->mpu_port
, 0, chip
->mpu_irq
, IRQF_DISABLED
,
1880 snd_printk(KERN_WARNING
"no MPU-401 device at 0x%lx?\n",
1883 if (chip
->fm_port
> 0 && chip
->fm_port
!= SNDRV_AUTO_PORT
) {
1884 struct snd_opl3
*opl3
= NULL
;
1886 if (chip
->hardware
== OPTi9XX_HW_82C928
||
1887 chip
->hardware
== OPTi9XX_HW_82C929
||
1888 chip
->hardware
== OPTi9XX_HW_82C924
) {
1889 struct snd_opl4
*opl4
;
1890 /* assume we have an OPL4 */
1891 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(2),
1893 if (snd_opl4_create(card
,
1896 2, &opl3
, &opl4
) < 0) {
1897 /* no luck, use OPL3 instead */
1898 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(2),
1902 #endif /* !OPTi93X */
1903 if (!opl3
&& snd_opl3_create(card
,
1906 OPL3_HW_AUTO
, 0, &opl3
) < 0) {
1907 snd_printk(KERN_WARNING
"no OPL device at 0x%lx-0x%lx\n",
1908 chip
->fm_port
, chip
->fm_port
+ 4 - 1);
1912 const int t1dev
= 1;
1914 const int t1dev
= 0;
1916 if ((error
= snd_opl3_timer_new(opl3
, t1dev
, t1dev
+1)) < 0)
1918 if ((error
= snd_opl3_hwdep_new(opl3
, 0, 1, &synth
)) < 0)
1923 return snd_card_register(card
);
1926 static struct snd_card
*snd_opti9xx_card_new(void)
1928 struct snd_card
*card
;
1930 card
= snd_card_new(index
, id
, THIS_MODULE
, sizeof(struct snd_opti9xx
));
1933 card
->private_free
= snd_card_opti9xx_free
;
1937 static int __devinit
snd_opti9xx_isa_match(struct device
*devptr
,
1941 if (snd_opti9xx_pnp_is_probed
)
1949 static int __devinit
snd_opti9xx_isa_probe(struct device
*devptr
,
1952 struct snd_card
*card
;
1954 static long possible_mpu_ports
[] = {0x300, 0x310, 0x320, 0x330, -1};
1956 static int possible_irqs
[] = {5, 9, 10, 11, 7, -1};
1958 static int possible_irqs
[] = {9, 10, 11, 7, -1};
1959 #endif /* OPTi93X */
1960 static int possible_mpu_irqs
[] = {5, 9, 10, 7, -1};
1961 static int possible_dma1s
[] = {3, 1, 0, -1};
1962 #if defined(CS4231) || defined(OPTi93X)
1963 static int possible_dma2s
[][2] = {{1,-1}, {0,-1}, {-1,-1}, {0,-1}};
1964 #endif /* CS4231 || OPTi93X */
1966 if (mpu_port
== SNDRV_AUTO_PORT
) {
1967 if ((mpu_port
= snd_legacy_find_free_ioport(possible_mpu_ports
, 2)) < 0) {
1968 snd_printk(KERN_ERR
"unable to find a free MPU401 port\n");
1972 if (irq
== SNDRV_AUTO_IRQ
) {
1973 if ((irq
= snd_legacy_find_free_irq(possible_irqs
)) < 0) {
1974 snd_printk(KERN_ERR
"unable to find a free IRQ\n");
1978 if (mpu_irq
== SNDRV_AUTO_IRQ
) {
1979 if ((mpu_irq
= snd_legacy_find_free_irq(possible_mpu_irqs
)) < 0) {
1980 snd_printk(KERN_ERR
"unable to find a free MPU401 IRQ\n");
1984 if (dma1
== SNDRV_AUTO_DMA
) {
1985 if ((dma1
= snd_legacy_find_free_dma(possible_dma1s
)) < 0) {
1986 snd_printk(KERN_ERR
"unable to find a free DMA1\n");
1990 #if defined(CS4231) || defined(OPTi93X)
1991 if (dma2
== SNDRV_AUTO_DMA
) {
1992 if ((dma2
= snd_legacy_find_free_dma(possible_dma2s
[dma1
% 4])) < 0) {
1993 snd_printk("unable to find a free DMA2\n");
1999 card
= snd_opti9xx_card_new();
2003 if ((error
= snd_card_opti9xx_detect(card
, card
->private_data
)) < 0) {
2004 snd_card_free(card
);
2007 snd_card_set_dev(card
, devptr
);
2008 if ((error
= snd_opti9xx_probe(card
)) < 0) {
2009 snd_card_free(card
);
2012 dev_set_drvdata(devptr
, card
);
2016 static int __devexit
snd_opti9xx_isa_remove(struct device
*devptr
,
2019 snd_card_free(dev_get_drvdata(devptr
));
2020 dev_set_drvdata(devptr
, NULL
);
2024 static struct isa_driver snd_opti9xx_driver
= {
2025 .match
= snd_opti9xx_isa_match
,
2026 .probe
= snd_opti9xx_isa_probe
,
2027 .remove
= __devexit_p(snd_opti9xx_isa_remove
),
2028 /* FIXME: suspend/resume */
2035 static int __devinit
snd_opti9xx_pnp_probe(struct pnp_card_link
*pcard
,
2036 const struct pnp_card_device_id
*pid
)
2038 struct snd_card
*card
;
2040 struct snd_opti9xx
*chip
;
2042 if (snd_opti9xx_pnp_is_probed
)
2046 card
= snd_opti9xx_card_new();
2049 chip
= card
->private_data
;
2051 hw
= snd_card_opti9xx_pnp(chip
, pcard
, pid
);
2054 hw
= OPTi9XX_HW_82C924
;
2057 hw
= OPTi9XX_HW_82C925
;
2060 hw
= OPTi9XX_HW_82C931
;
2063 snd_card_free(card
);
2067 if ((error
= snd_opti9xx_init(chip
, hw
))) {
2068 snd_card_free(card
);
2071 if (hw
<= OPTi9XX_HW_82C930
)
2072 chip
->mc_base
-= 0x80;
2073 snd_card_set_dev(card
, &pcard
->card
->dev
);
2074 if ((error
= snd_opti9xx_probe(card
)) < 0) {
2075 snd_card_free(card
);
2078 pnp_set_card_drvdata(pcard
, card
);
2079 snd_opti9xx_pnp_is_probed
= 1;
2083 static void __devexit
snd_opti9xx_pnp_remove(struct pnp_card_link
* pcard
)
2085 snd_card_free(pnp_get_card_drvdata(pcard
));
2086 pnp_set_card_drvdata(pcard
, NULL
);
2087 snd_opti9xx_pnp_is_probed
= 0;
2090 static struct pnp_card_driver opti9xx_pnpc_driver
= {
2091 .flags
= PNP_DRIVER_RES_DISABLE
,
2093 .id_table
= snd_opti9xx_pnpids
,
2094 .probe
= snd_opti9xx_pnp_probe
,
2095 .remove
= __devexit_p(snd_opti9xx_pnp_remove
),
2100 #define CHIP_NAME "82C93x"
2102 #define CHIP_NAME "82C92x"
2105 static int __init
alsa_card_opti9xx_init(void)
2108 pnp_register_card_driver(&opti9xx_pnpc_driver
);
2109 if (snd_opti9xx_pnp_is_probed
)
2111 pnp_unregister_card_driver(&opti9xx_pnpc_driver
);
2113 return isa_register_driver(&snd_opti9xx_driver
, 1);
2116 static void __exit
alsa_card_opti9xx_exit(void)
2118 if (!snd_opti9xx_pnp_is_probed
) {
2119 isa_unregister_driver(&snd_opti9xx_driver
);
2123 pnp_unregister_card_driver(&opti9xx_pnpc_driver
);
2127 module_init(alsa_card_opti9xx_init
)
2128 module_exit(alsa_card_opti9xx_exit
)