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>
29 #include <linux/delay.h>
30 #include <linux/init.h>
31 #include <linux/slab.h>
32 #include <linux/pnp.h>
33 #include <linux/moduleparam.h>
34 #include <sound/core.h>
36 #include <sound/cs4231.h>
39 #include <sound/ad1848.h>
41 #include <sound/control.h>
42 #include <sound/pcm.h>
45 #include <sound/mpu401.h>
46 #include <sound/opl3.h>
48 #include <sound/opl4.h>
50 #define SNDRV_LEGACY_FIND_FREE_IRQ
51 #define SNDRV_LEGACY_FIND_FREE_DMA
52 #include <sound/initval.h>
54 MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>");
55 MODULE_LICENSE("GPL");
57 MODULE_DESCRIPTION("OPTi93X");
58 MODULE_SUPPORTED_DEVICE("{{OPTi,82C931/3}}");
61 MODULE_DESCRIPTION("OPTi92X - CS4231");
62 MODULE_SUPPORTED_DEVICE("{{OPTi,82C924 (CS4231)},"
63 "{OPTi,82C925 (CS4231)}}");
65 MODULE_DESCRIPTION("OPTi92X - AD1848");
66 MODULE_SUPPORTED_DEVICE("{{OPTi,82C924 (AD1848)},"
67 "{OPTi,82C925 (AD1848)},"
72 static int index
= SNDRV_DEFAULT_IDX1
; /* Index 0-MAX */
73 static char *id
= SNDRV_DEFAULT_STR1
; /* ID for this card */
74 //static int enable = SNDRV_DEFAULT_ENABLE1; /* Enable this card */
75 static int isapnp
= 1; /* Enable ISA PnP detection */
76 static long port
= SNDRV_DEFAULT_PORT1
; /* 0x530,0xe80,0xf40,0x604 */
77 static long mpu_port
= SNDRV_DEFAULT_PORT1
; /* 0x300,0x310,0x320,0x330 */
78 static long fm_port
= SNDRV_DEFAULT_PORT1
; /* 0x388 */
79 static int irq
= SNDRV_DEFAULT_IRQ1
; /* 5,7,9,10,11 */
80 static int mpu_irq
= SNDRV_DEFAULT_IRQ1
; /* 5,7,9,10 */
81 static int dma1
= SNDRV_DEFAULT_DMA1
; /* 0,1,3 */
82 #if defined(CS4231) || defined(OPTi93X)
83 static int dma2
= SNDRV_DEFAULT_DMA1
; /* 0,1,3 */
84 #endif /* CS4231 || OPTi93X */
86 module_param(index
, int, 0444);
87 MODULE_PARM_DESC(index
, "Index value for opti9xx based soundcard.");
88 module_param(id
, charp
, 0444);
89 MODULE_PARM_DESC(id
, "ID string for opti9xx based soundcard.");
90 //module_param(enable, bool, 0444);
91 //MODULE_PARM_DESC(enable, "Enable opti9xx soundcard.");
92 module_param(isapnp
, bool, 0444);
93 MODULE_PARM_DESC(isapnp
, "Enable ISA PnP detection for specified soundcard.");
94 module_param(port
, long, 0444);
95 MODULE_PARM_DESC(port
, "WSS port # for opti9xx driver.");
96 module_param(mpu_port
, long, 0444);
97 MODULE_PARM_DESC(mpu_port
, "MPU-401 port # for opti9xx driver.");
98 module_param(fm_port
, long, 0444);
99 MODULE_PARM_DESC(fm_port
, "FM port # for opti9xx driver.");
100 module_param(irq
, int, 0444);
101 MODULE_PARM_DESC(irq
, "WSS irq # for opti9xx driver.");
102 module_param(mpu_irq
, int, 0444);
103 MODULE_PARM_DESC(mpu_irq
, "MPU-401 irq # for opti9xx driver.");
104 module_param(dma1
, int, 0444);
105 MODULE_PARM_DESC(dma1
, "1st dma # for opti9xx driver.");
106 #if defined(CS4231) || defined(OPTi93X)
107 module_param(dma2
, int, 0444);
108 MODULE_PARM_DESC(dma2
, "2nd dma # for opti9xx driver.");
109 #endif /* CS4231 || OPTi93X */
111 #define OPTi9XX_HW_DETECT 0
112 #define OPTi9XX_HW_82C928 1
113 #define OPTi9XX_HW_82C929 2
114 #define OPTi9XX_HW_82C924 3
115 #define OPTi9XX_HW_82C925 4
116 #define OPTi9XX_HW_82C930 5
117 #define OPTi9XX_HW_82C931 6
118 #define OPTi9XX_HW_82C933 7
119 #define OPTi9XX_HW_LAST OPTi9XX_HW_82C933
121 #define OPTi9XX_MC_REG(n) n
123 typedef struct _snd_opti9xx opti9xx_t
;
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
196 typedef struct _snd_opti93x opti93x_t
;
198 struct _snd_opti93x
{
200 struct resource
*res_port
;
206 unsigned short hardware
;
207 unsigned char image
[32];
209 unsigned char mce_bit
;
217 snd_pcm_substream_t
*playback_substream
;
218 snd_pcm_substream_t
*capture_substream
;
219 unsigned int p_dma_size
;
220 unsigned int c_dma_size
;
223 #define OPTi93X_MODE_NONE 0x00
224 #define OPTi93X_MODE_PLAY 0x01
225 #define OPTi93X_MODE_CAPTURE 0x02
226 #define OPTi93X_MODE_OPEN (OPTi93X_MODE_PLAY | OPTi93X_MODE_CAPTURE)
230 struct _snd_opti9xx
{
231 unsigned short hardware
;
232 unsigned char password
;
235 unsigned long mc_base
;
236 struct resource
*res_mc_base
;
237 unsigned long mc_base_size
;
239 unsigned long mc_indir_index
;
241 unsigned long pwd_reg
;
248 #if defined(CS4231) || defined(OPTi93X)
250 #endif /* CS4231 || OPTi93X */
259 struct pnp_dev
*devmpu
;
260 #endif /* CONFIG_PNP */
263 static int snd_opti9xx_first_hit
= 1;
264 static snd_card_t
*snd_opti9xx_legacy
= SNDRV_DEFAULT_PTR1
;
268 static struct pnp_card_device_id snd_opti9xx_pnpids
[] = {
271 { .id
= "OPT0924", .devs
= { { "OPT0000" }, { "OPT0002" } }, .driver_data
= 0x0924 },
273 { .id
= "OPT0925", .devs
= { { "OPT9250" }, { "OPT0002" } }, .driver_data
= 0x0925 },
276 { .id
= "OPT0931", .devs
= { { "OPT9310" }, { "OPT0002" } }, .driver_data
= 0x0931 },
281 MODULE_DEVICE_TABLE(pnp_card
, snd_opti9xx_pnpids
);
283 #endif /* CONFIG_PNP */
286 #define DRIVER_NAME "snd-card-opti93x"
288 #define DRIVER_NAME "snd-card-opti92x"
291 static char * snd_opti9xx_names
[] = {
295 "82C930", "82C931", "82C933"
299 static long snd_legacy_find_free_ioport(long *port_table
, long size
)
301 while (*port_table
!= -1) {
302 struct resource
*res
;
303 if ((res
= request_region(*port_table
, size
, "ALSA test")) != NULL
) {
304 release_resource(res
);
313 static int __devinit
snd_opti9xx_init(opti9xx_t
*chip
, unsigned short hardware
)
315 static int opti9xx_mc_size
[] = {7, 7, 10, 10, 2, 2, 2};
317 chip
->hardware
= hardware
;
318 strcpy(chip
->name
, snd_opti9xx_names
[hardware
]);
320 chip
->mc_base_size
= opti9xx_mc_size
[hardware
];
322 spin_lock_init(&chip
->lock
);
327 #if defined(CS4231) || defined (OPTi93X)
329 #endif /* CS4231 || OPTi93X */
336 case OPTi9XX_HW_82C928
:
337 case OPTi9XX_HW_82C929
:
338 chip
->mc_base
= 0xf8c;
339 chip
->password
= (hardware
== OPTi9XX_HW_82C928
) ? 0xe2 : 0xe3;
343 case OPTi9XX_HW_82C924
:
344 case OPTi9XX_HW_82C925
:
345 chip
->mc_base
= 0xf8c;
346 chip
->password
= 0xe5;
351 case OPTi9XX_HW_82C930
:
352 case OPTi9XX_HW_82C931
:
353 case OPTi9XX_HW_82C933
:
354 chip
->mc_base
= (hardware
== OPTi9XX_HW_82C930
) ? 0xf8f : 0xf8d;
355 chip
->mc_indir_index
= 0xe0e;
356 chip
->password
= 0xe4;
362 snd_printk("chip %d not supported\n", hardware
);
368 static unsigned char snd_opti9xx_read(opti9xx_t
*chip
,
372 unsigned char retval
= 0xff;
374 spin_lock_irqsave(&chip
->lock
, flags
);
375 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
377 switch (chip
->hardware
) {
379 case OPTi9XX_HW_82C924
:
380 case OPTi9XX_HW_82C925
:
382 outb(reg
, chip
->mc_base
+ 8);
383 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
384 retval
= inb(chip
->mc_base
+ 9);
388 case OPTi9XX_HW_82C928
:
389 case OPTi9XX_HW_82C929
:
390 retval
= inb(chip
->mc_base
+ reg
);
394 case OPTi9XX_HW_82C930
:
395 case OPTi9XX_HW_82C931
:
396 case OPTi9XX_HW_82C933
:
397 outb(reg
, chip
->mc_indir_index
);
398 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
399 retval
= inb(chip
->mc_indir_index
+ 1);
404 snd_printk("chip %d not supported\n", chip
->hardware
);
407 spin_unlock_irqrestore(&chip
->lock
, flags
);
411 static void snd_opti9xx_write(opti9xx_t
*chip
, unsigned char reg
,
416 spin_lock_irqsave(&chip
->lock
, flags
);
417 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
419 switch (chip
->hardware
) {
421 case OPTi9XX_HW_82C924
:
422 case OPTi9XX_HW_82C925
:
424 outb(reg
, chip
->mc_base
+ 8);
425 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
426 outb(value
, chip
->mc_base
+ 9);
430 case OPTi9XX_HW_82C928
:
431 case OPTi9XX_HW_82C929
:
432 outb(value
, chip
->mc_base
+ reg
);
436 case OPTi9XX_HW_82C930
:
437 case OPTi9XX_HW_82C931
:
438 case OPTi9XX_HW_82C933
:
439 outb(reg
, chip
->mc_indir_index
);
440 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
441 outb(value
, chip
->mc_indir_index
+ 1);
446 snd_printk("chip %d not supported\n", chip
->hardware
);
449 spin_unlock_irqrestore(&chip
->lock
, flags
);
453 #define snd_opti9xx_write_mask(chip, reg, value, mask) \
454 snd_opti9xx_write(chip, reg, \
455 (snd_opti9xx_read(chip, reg) & ~(mask)) | ((value) & (mask)))
458 static int __devinit
snd_opti9xx_configure(opti9xx_t
*chip
)
460 unsigned char wss_base_bits
;
461 unsigned char irq_bits
;
462 unsigned char dma_bits
;
463 unsigned char mpu_port_bits
= 0;
464 unsigned char mpu_irq_bits
;
466 switch (chip
->hardware
) {
468 case OPTi9XX_HW_82C924
:
469 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(4), 0xf0, 0xfc);
470 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(6), 0x02, 0x02);
472 case OPTi9XX_HW_82C925
:
473 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(1), 0x80, 0x80);
474 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(2), 0x00, 0x20);
475 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(3), 0xf0, 0xff);
477 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x02, 0x02);
479 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x00, 0x02);
483 case OPTi9XX_HW_82C928
:
484 case OPTi9XX_HW_82C929
:
485 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(1), 0x80, 0x80);
486 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(2), 0x00, 0x20);
488 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(3), 0xa2, 0xae);
490 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(4), 0x00, 0x0c);
492 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x02, 0x02);
494 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x00, 0x02);
499 case OPTi9XX_HW_82C930
:
500 case OPTi9XX_HW_82C931
:
501 case OPTi9XX_HW_82C933
:
502 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(6), 0x02, 0x03);
503 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(3), 0x00, 0xff);
504 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(4), 0x10 |
505 (chip
->hardware
== OPTi9XX_HW_82C930
? 0x00 : 0x04),
507 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(5), 0x20, 0xbf);
512 snd_printk("chip %d not supported\n", chip
->hardware
);
516 switch (chip
->wss_base
) {
518 wss_base_bits
= 0x00;
521 wss_base_bits
= 0x03;
524 wss_base_bits
= 0x01;
527 wss_base_bits
= 0x02;
530 snd_printk("WSS port 0x%lx not valid\n", chip
->wss_base
);
533 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(1), wss_base_bits
<< 4, 0x30);
541 //#endif /* OPTi93X */
555 snd_printk("WSS irq # %d not valid\n", chip
->irq
);
556 goto __skip_resources
;
559 switch (chip
->dma1
) {
570 snd_printk("WSS dma1 # %d not valid\n", chip
->dma1
);
571 goto __skip_resources
;
574 #if defined(CS4231) || defined(OPTi93X)
575 if (chip
->dma1
== chip
->dma2
) {
576 snd_printk("don't want to share dmas\n");
580 switch (chip
->dma2
) {
585 snd_printk("WSS dma2 # %d not valid\n", chip
->dma2
);
586 goto __skip_resources
;
589 #endif /* CS4231 || OPTi93X */
592 outb(irq_bits
<< 3 | dma_bits
, chip
->wss_base
);
594 snd_opti9xx_write(chip
, OPTi9XX_MC_REG(3), (irq_bits
<< 3 | dma_bits
));
598 if (chip
->hardware
> OPTi9XX_HW_82C928
) {
599 switch (chip
->mpu_port
) {
604 mpu_port_bits
= 0x03;
607 mpu_port_bits
= 0x02;
610 mpu_port_bits
= 0x01;
613 mpu_port_bits
= 0x00;
616 snd_printk("MPU-401 port 0x%lx not valid\n",
621 switch (chip
->mpu_irq
) {
635 snd_printk("MPU-401 irq # %d not valid\n",
640 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(6),
641 (chip
->mpu_port
<= 0) ? 0x00 :
642 0x80 | mpu_port_bits
<< 5 | mpu_irq_bits
<< 3,
652 static unsigned char snd_opti93x_default_image
[32] =
654 0x00, /* 00/00 - l_mixout_outctrl */
655 0x00, /* 01/01 - r_mixout_outctrl */
656 0x88, /* 02/02 - l_cd_inctrl */
657 0x88, /* 03/03 - r_cd_inctrl */
658 0x88, /* 04/04 - l_a1/fm_inctrl */
659 0x88, /* 05/05 - r_a1/fm_inctrl */
660 0x80, /* 06/06 - l_dac_inctrl */
661 0x80, /* 07/07 - r_dac_inctrl */
662 0x00, /* 08/08 - ply_dataform_reg */
663 0x00, /* 09/09 - if_conf */
664 0x00, /* 0a/10 - pin_ctrl */
665 0x00, /* 0b/11 - err_init_reg */
666 0x0a, /* 0c/12 - id_reg */
667 0x00, /* 0d/13 - reserved */
668 0x00, /* 0e/14 - ply_upcount_reg */
669 0x00, /* 0f/15 - ply_lowcount_reg */
670 0x88, /* 10/16 - reserved/l_a1_inctrl */
671 0x88, /* 11/17 - reserved/r_a1_inctrl */
672 0x88, /* 12/18 - l_line_inctrl */
673 0x88, /* 13/19 - r_line_inctrl */
674 0x88, /* 14/20 - l_mic_inctrl */
675 0x88, /* 15/21 - r_mic_inctrl */
676 0x80, /* 16/22 - l_out_outctrl */
677 0x80, /* 17/23 - r_out_outctrl */
678 0x00, /* 18/24 - reserved */
679 0x00, /* 19/25 - reserved */
680 0x00, /* 1a/26 - reserved */
681 0x00, /* 1b/27 - reserved */
682 0x00, /* 1c/28 - cap_dataform_reg */
683 0x00, /* 1d/29 - reserved */
684 0x00, /* 1e/30 - cap_upcount_reg */
685 0x00 /* 1f/31 - cap_lowcount_reg */
689 static int snd_opti93x_busy_wait(opti93x_t
*chip
)
693 for (timeout
= 250; timeout
-- > 0; udelay(10))
694 if (!(inb(OPTi93X_PORT(chip
, INDEX
)) & OPTi93X_INIT
))
697 snd_printk("chip still busy.\n");
701 static unsigned char snd_opti93x_in(opti93x_t
*chip
, unsigned char reg
)
703 snd_opti93x_busy_wait(chip
);
704 outb(chip
->mce_bit
| (reg
& 0x1f), OPTi93X_PORT(chip
, INDEX
));
705 return inb(OPTi93X_PORT(chip
, DATA
));
708 static void snd_opti93x_out(opti93x_t
*chip
, unsigned char reg
,
711 snd_opti93x_busy_wait(chip
);
712 outb(chip
->mce_bit
| (reg
& 0x1f), OPTi93X_PORT(chip
, INDEX
));
713 outb(value
, OPTi93X_PORT(chip
, DATA
));
716 static void snd_opti93x_out_image(opti93x_t
*chip
, unsigned char reg
,
719 snd_opti93x_out(chip
, reg
, chip
->image
[reg
] = value
);
722 static void snd_opti93x_out_mask(opti93x_t
*chip
, unsigned char reg
,
723 unsigned char mask
, unsigned char value
)
725 snd_opti93x_out_image(chip
, reg
,
726 (chip
->image
[reg
] & ~mask
) | (value
& mask
));
730 static void snd_opti93x_mce_up(opti93x_t
*chip
)
732 snd_opti93x_busy_wait(chip
);
734 chip
->mce_bit
= OPTi93X_MCE
;
735 if (!(inb(OPTi93X_PORT(chip
, INDEX
)) & OPTi93X_MCE
))
736 outb(chip
->mce_bit
, OPTi93X_PORT(chip
, INDEX
));
739 static void snd_opti93x_mce_down(opti93x_t
*chip
)
741 snd_opti93x_busy_wait(chip
);
744 if (inb(OPTi93X_PORT(chip
, INDEX
)) & OPTi93X_MCE
)
745 outb(chip
->mce_bit
, OPTi93X_PORT(chip
, INDEX
));
748 #define snd_opti93x_mute_reg(chip, reg, mute) \
749 snd_opti93x_out(chip, reg, mute ? 0x80 : chip->image[reg]);
751 static void snd_opti93x_mute(opti93x_t
*chip
, int mute
)
754 if (chip
->mute
== mute
)
759 snd_opti93x_mute_reg(chip
, OPTi93X_CD_LEFT_INPUT
, mute
);
760 snd_opti93x_mute_reg(chip
, OPTi93X_CD_RIGHT_INPUT
, mute
);
761 switch (chip
->hardware
) {
762 case OPTi9XX_HW_82C930
:
763 snd_opti93x_mute_reg(chip
, OPTi930_AUX_LEFT_INPUT
, mute
);
764 snd_opti93x_mute_reg(chip
, OPTi930_AUX_RIGHT_INPUT
, mute
);
766 case OPTi9XX_HW_82C931
:
767 case OPTi9XX_HW_82C933
:
768 snd_opti93x_mute_reg(chip
, OPTi931_FM_LEFT_INPUT
, mute
);
769 snd_opti93x_mute_reg(chip
, OPTi931_FM_RIGHT_INPUT
, mute
);
770 snd_opti93x_mute_reg(chip
, OPTi931_AUX_LEFT_INPUT
, mute
);
771 snd_opti93x_mute_reg(chip
, OPTi931_AUX_RIGHT_INPUT
, mute
);
773 snd_opti93x_mute_reg(chip
, OPTi93X_DAC_LEFT
, mute
);
774 snd_opti93x_mute_reg(chip
, OPTi93X_DAC_RIGHT
, mute
);
775 snd_opti93x_mute_reg(chip
, OPTi93X_LINE_LEFT_INPUT
, mute
);
776 snd_opti93x_mute_reg(chip
, OPTi93X_LINE_RIGHT_INPUT
, mute
);
777 snd_opti93x_mute_reg(chip
, OPTi93X_MIC_LEFT_INPUT
, mute
);
778 snd_opti93x_mute_reg(chip
, OPTi93X_MIC_RIGHT_INPUT
, mute
);
779 snd_opti93x_mute_reg(chip
, OPTi93X_OUT_LEFT
, mute
);
780 snd_opti93x_mute_reg(chip
, OPTi93X_OUT_RIGHT
, mute
);
784 static unsigned int snd_opti93x_get_count(unsigned char format
,
787 switch (format
& 0xe0) {
788 case OPTi93X_LINEAR_16_LIT
:
789 case OPTi93X_LINEAR_16_BIG
:
792 case OPTi93X_ADPCM_16
:
795 return (format
& OPTi93X_STEREO
) ? (size
>> 1) : size
;
798 static unsigned int rates
[] = { 5512, 6615, 8000, 9600, 11025, 16000,
799 18900, 22050, 27428, 32000, 33075, 37800,
801 #define RATES ARRAY_SIZE(rates)
803 static snd_pcm_hw_constraint_list_t hw_constraints_rates
= {
809 static unsigned char bits
[] = { 0x01, 0x0f, 0x00, 0x0e, 0x03, 0x02,
810 0x05, 0x07, 0x04, 0x06, 0x0d, 0x09,
813 static unsigned char snd_opti93x_get_freq(unsigned int rate
)
817 for (i
= 0; i
< RATES
; i
++) {
818 if (rate
== rates
[i
])
822 return bits
[RATES
-1];
825 static unsigned char snd_opti93x_get_format(opti93x_t
*chip
,
826 unsigned int format
, int channels
)
828 unsigned char retval
= OPTi93X_LINEAR_8
;
831 case SNDRV_PCM_FORMAT_MU_LAW
:
832 retval
= OPTi93X_ULAW_8
;
834 case SNDRV_PCM_FORMAT_A_LAW
:
835 retval
= OPTi93X_ALAW_8
;
837 case SNDRV_PCM_FORMAT_S16_LE
:
838 retval
= OPTi93X_LINEAR_16_LIT
;
840 case SNDRV_PCM_FORMAT_S16_BE
:
841 retval
= OPTi93X_LINEAR_16_BIG
;
843 case SNDRV_PCM_FORMAT_IMA_ADPCM
:
844 retval
= OPTi93X_ADPCM_16
;
846 return (channels
> 1) ? (retval
| OPTi93X_STEREO
) : retval
;
850 static void snd_opti93x_playback_format(opti93x_t
*chip
, unsigned char fmt
)
854 snd_opti93x_mute(chip
, 1);
856 snd_opti93x_mce_up(chip
);
857 mask
= (chip
->mode
& OPTi93X_MODE_CAPTURE
) ? 0xf0 : 0xff;
858 snd_opti93x_out_mask(chip
, OPTi93X_PLAY_FORMAT
, mask
, fmt
);
859 snd_opti93x_mce_down(chip
);
861 snd_opti93x_mute(chip
, 0);
864 static void snd_opti93x_capture_format(opti93x_t
*chip
, unsigned char fmt
)
866 snd_opti93x_mute(chip
, 1);
868 snd_opti93x_mce_up(chip
);
869 if (!(chip
->mode
& OPTi93X_MODE_PLAY
))
870 snd_opti93x_out_mask(chip
, OPTi93X_PLAY_FORMAT
, 0x0f, fmt
);
872 fmt
= chip
->image
[OPTi93X_PLAY_FORMAT
] & 0xf0;
873 snd_opti93x_out_image(chip
, OPTi93X_CAPT_FORMAT
, fmt
);
874 snd_opti93x_mce_down(chip
);
876 snd_opti93x_mute(chip
, 0);
880 static int snd_opti93x_open(opti93x_t
*chip
, unsigned int mode
)
884 spin_lock_irqsave(&chip
->lock
, flags
);
886 if (chip
->mode
& mode
) {
887 spin_unlock_irqrestore(&chip
->lock
, flags
);
891 if (!(chip
->mode
& OPTi93X_MODE_OPEN
)) {
892 outb(0x00, OPTi93X_PORT(chip
, STATUS
));
893 snd_opti93x_out_mask(chip
, OPTi93X_PIN_CTRL
,
894 OPTi93X_IRQ_ENABLE
, OPTi93X_IRQ_ENABLE
);
900 spin_unlock_irqrestore(&chip
->lock
, flags
);
904 static void snd_opti93x_close(opti93x_t
*chip
, unsigned int mode
)
908 spin_lock_irqsave(&chip
->lock
, flags
);
911 if (chip
->mode
& OPTi93X_MODE_OPEN
) {
912 spin_unlock_irqrestore(&chip
->lock
, flags
);
916 snd_opti93x_mute(chip
, 1);
918 outb(0, OPTi93X_PORT(chip
, STATUS
));
919 snd_opti93x_out_mask(chip
, OPTi93X_PIN_CTRL
, OPTi93X_IRQ_ENABLE
,
920 ~OPTi93X_IRQ_ENABLE
);
922 snd_opti93x_mce_up(chip
);
923 snd_opti93x_out_image(chip
, OPTi93X_IFACE_CONF
, 0x00);
924 snd_opti93x_mce_down(chip
);
927 snd_opti93x_mute(chip
, 0);
928 spin_unlock_irqrestore(&chip
->lock
, flags
);
931 static int snd_opti93x_trigger(snd_pcm_substream_t
*substream
,
932 unsigned char what
, int cmd
)
934 opti93x_t
*chip
= snd_pcm_substream_chip(substream
);
937 case SNDRV_PCM_TRIGGER_START
:
938 case SNDRV_PCM_TRIGGER_STOP
:
940 unsigned int what
= 0;
941 struct list_head
*pos
;
942 snd_pcm_substream_t
*s
;
943 snd_pcm_group_for_each(pos
, substream
) {
944 s
= snd_pcm_group_substream_entry(pos
);
945 if (s
== chip
->playback_substream
) {
946 what
|= OPTi93X_PLAYBACK_ENABLE
;
947 snd_pcm_trigger_done(s
, substream
);
948 } else if (s
== chip
->capture_substream
) {
949 what
|= OPTi93X_CAPTURE_ENABLE
;
950 snd_pcm_trigger_done(s
, substream
);
953 spin_lock(&chip
->lock
);
954 if (cmd
== SNDRV_PCM_TRIGGER_START
) {
955 snd_opti93x_out_mask(chip
, OPTi93X_IFACE_CONF
, what
, what
);
956 if (what
& OPTi93X_CAPTURE_ENABLE
)
959 snd_opti93x_out_mask(chip
, OPTi93X_IFACE_CONF
, what
, 0x00);
960 spin_unlock(&chip
->lock
);
969 static int snd_opti93x_playback_trigger(snd_pcm_substream_t
*substream
, int cmd
)
971 return snd_opti93x_trigger(substream
,
972 OPTi93X_PLAYBACK_ENABLE
, cmd
);
975 static int snd_opti93x_capture_trigger(snd_pcm_substream_t
* substream
, int cmd
)
977 return snd_opti93x_trigger(substream
,
978 OPTi93X_CAPTURE_ENABLE
, cmd
);
981 static int snd_opti93x_hw_params(snd_pcm_substream_t
* substream
,
982 snd_pcm_hw_params_t
* hw_params
)
984 return snd_pcm_lib_malloc_pages(substream
, params_buffer_bytes(hw_params
));
988 static int snd_opti93x_hw_free(snd_pcm_substream_t
* substream
)
990 snd_pcm_lib_free_pages(substream
);
995 static int snd_opti93x_playback_prepare(snd_pcm_substream_t
* substream
)
997 opti93x_t
*chip
= snd_pcm_substream_chip(substream
);
998 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
1000 unsigned char format
;
1001 unsigned int count
= snd_pcm_lib_period_bytes(substream
);
1002 unsigned int size
= snd_pcm_lib_buffer_bytes(substream
);
1004 spin_lock_irqsave(&chip
->lock
, flags
);
1006 chip
->p_dma_size
= size
;
1007 snd_opti93x_out_mask(chip
, OPTi93X_IFACE_CONF
,
1008 OPTi93X_PLAYBACK_ENABLE
| OPTi93X_PLAYBACK_PIO
,
1009 ~(OPTi93X_PLAYBACK_ENABLE
| OPTi93X_PLAYBACK_PIO
));
1011 snd_dma_program(chip
->dma1
, runtime
->dma_addr
, size
,
1012 DMA_MODE_WRITE
| DMA_AUTOINIT
);
1014 format
= snd_opti93x_get_freq(runtime
->rate
);
1015 format
|= snd_opti93x_get_format(chip
, runtime
->format
,
1017 snd_opti93x_playback_format(chip
, format
);
1018 format
= chip
->image
[OPTi93X_PLAY_FORMAT
];
1020 count
= snd_opti93x_get_count(format
, count
) - 1;
1021 snd_opti93x_out_image(chip
, OPTi93X_PLAY_LWR_CNT
, count
);
1022 snd_opti93x_out_image(chip
, OPTi93X_PLAY_UPR_CNT
, count
>> 8);
1024 spin_unlock_irqrestore(&chip
->lock
, flags
);
1028 static int snd_opti93x_capture_prepare(snd_pcm_substream_t
*substream
)
1030 opti93x_t
*chip
= snd_pcm_substream_chip(substream
);
1031 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
1032 unsigned long flags
;
1033 unsigned char format
;
1034 unsigned int count
= snd_pcm_lib_period_bytes(substream
);
1035 unsigned int size
= snd_pcm_lib_buffer_bytes(substream
);
1037 spin_lock_irqsave(&chip
->lock
, flags
);
1039 chip
->c_dma_size
= size
;
1040 snd_opti93x_out_mask(chip
, OPTi93X_IFACE_CONF
,
1041 OPTi93X_CAPTURE_ENABLE
| OPTi93X_CAPTURE_PIO
, 0);
1043 snd_dma_program(chip
->dma2
, runtime
->dma_addr
, size
,
1044 DMA_MODE_READ
| DMA_AUTOINIT
);
1046 format
= snd_opti93x_get_freq(runtime
->rate
);
1047 format
|= snd_opti93x_get_format(chip
, runtime
->format
,
1049 snd_opti93x_capture_format(chip
, format
);
1050 format
= chip
->image
[OPTi93X_CAPT_FORMAT
];
1052 count
= snd_opti93x_get_count(format
, count
) - 1;
1053 snd_opti93x_out_image(chip
, OPTi93X_CAPT_LWR_CNT
, count
);
1054 snd_opti93x_out_image(chip
, OPTi93X_CAPT_UPR_CNT
, count
>> 8);
1056 spin_unlock_irqrestore(&chip
->lock
, flags
);
1060 static snd_pcm_uframes_t
snd_opti93x_playback_pointer(snd_pcm_substream_t
*substream
)
1062 opti93x_t
*chip
= snd_pcm_substream_chip(substream
);
1065 if (!(chip
->image
[OPTi93X_IFACE_CONF
] & OPTi93X_PLAYBACK_ENABLE
))
1068 ptr
= snd_dma_pointer(chip
->dma1
, chip
->p_dma_size
);
1069 return bytes_to_frames(substream
->runtime
, ptr
);
1072 static snd_pcm_uframes_t
snd_opti93x_capture_pointer(snd_pcm_substream_t
*substream
)
1074 opti93x_t
*chip
= snd_pcm_substream_chip(substream
);
1077 if (!(chip
->image
[OPTi93X_IFACE_CONF
] & OPTi93X_CAPTURE_ENABLE
))
1080 ptr
= snd_dma_pointer(chip
->dma2
, chip
->c_dma_size
);
1081 return bytes_to_frames(substream
->runtime
, ptr
);
1085 static void snd_opti93x_overrange(opti93x_t
*chip
)
1087 unsigned long flags
;
1089 spin_lock_irqsave(&chip
->lock
, flags
);
1091 if (snd_opti93x_in(chip
, OPTi93X_ERR_INIT
) & (0x08 | 0x02))
1092 chip
->capture_substream
->runtime
->overrange
++;
1094 spin_unlock_irqrestore(&chip
->lock
, flags
);
1097 static irqreturn_t
snd_opti93x_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
1099 opti93x_t
*codec
= dev_id
;
1100 unsigned char status
;
1102 status
= snd_opti9xx_read(codec
->chip
, OPTi9XX_MC_REG(11));
1103 if ((status
& OPTi93X_IRQ_PLAYBACK
) && codec
->playback_substream
)
1104 snd_pcm_period_elapsed(codec
->playback_substream
);
1105 if ((status
& OPTi93X_IRQ_CAPTURE
) && codec
->capture_substream
) {
1106 snd_opti93x_overrange(codec
);
1107 snd_pcm_period_elapsed(codec
->capture_substream
);
1109 outb(0x00, OPTi93X_PORT(codec
, STATUS
));
1114 static snd_pcm_hardware_t snd_opti93x_playback
= {
1115 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1116 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_SYNC_START
),
1117 .formats
= (SNDRV_PCM_FMTBIT_MU_LAW
| SNDRV_PCM_FMTBIT_A_LAW
| SNDRV_PCM_FMTBIT_IMA_ADPCM
|
1118 SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_S16_BE
),
1119 .rates
= SNDRV_PCM_RATE_KNOT
| SNDRV_PCM_RATE_8000_48000
,
1124 .buffer_bytes_max
= (128*1024),
1125 .period_bytes_min
= 64,
1126 .period_bytes_max
= (128*1024),
1128 .periods_max
= 1024,
1132 static snd_pcm_hardware_t snd_opti93x_capture
= {
1133 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1134 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_SYNC_START
),
1135 .formats
= (SNDRV_PCM_FMTBIT_MU_LAW
| SNDRV_PCM_FMTBIT_A_LAW
| SNDRV_PCM_FMTBIT_IMA_ADPCM
|
1136 SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_S16_BE
),
1137 .rates
= SNDRV_PCM_RATE_8000_48000
,
1142 .buffer_bytes_max
= (128*1024),
1143 .period_bytes_min
= 64,
1144 .period_bytes_max
= (128*1024),
1146 .periods_max
= 1024,
1150 static int snd_opti93x_playback_open(snd_pcm_substream_t
*substream
)
1153 opti93x_t
*chip
= snd_pcm_substream_chip(substream
);
1154 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
1156 if ((error
= snd_opti93x_open(chip
, OPTi93X_MODE_PLAY
)) < 0)
1158 snd_pcm_set_sync(substream
);
1159 chip
->playback_substream
= substream
;
1160 runtime
->hw
= snd_opti93x_playback
;
1161 snd_pcm_limit_isa_dma_size(chip
->dma1
, &runtime
->hw
.buffer_bytes_max
);
1162 snd_pcm_hw_constraint_list(runtime
, 0, SNDRV_PCM_HW_PARAM_RATE
, &hw_constraints_rates
);
1166 static int snd_opti93x_capture_open(snd_pcm_substream_t
*substream
)
1169 opti93x_t
*chip
= snd_pcm_substream_chip(substream
);
1170 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
1172 if ((error
= snd_opti93x_open(chip
, OPTi93X_MODE_CAPTURE
)) < 0)
1174 runtime
->hw
= snd_opti93x_capture
;
1175 snd_pcm_set_sync(substream
);
1176 chip
->capture_substream
= substream
;
1177 snd_pcm_limit_isa_dma_size(chip
->dma2
, &runtime
->hw
.buffer_bytes_max
);
1178 snd_pcm_hw_constraint_list(runtime
, 0, SNDRV_PCM_HW_PARAM_RATE
, &hw_constraints_rates
);
1182 static int snd_opti93x_playback_close(snd_pcm_substream_t
*substream
)
1184 opti93x_t
*chip
= snd_pcm_substream_chip(substream
);
1186 chip
->playback_substream
= NULL
;
1187 snd_opti93x_close(chip
, OPTi93X_MODE_PLAY
);
1191 static int snd_opti93x_capture_close(snd_pcm_substream_t
*substream
)
1193 opti93x_t
*chip
= snd_pcm_substream_chip(substream
);
1195 chip
->capture_substream
= NULL
;
1196 snd_opti93x_close(chip
, OPTi93X_MODE_CAPTURE
);
1201 static void snd_opti93x_init(opti93x_t
*chip
)
1203 unsigned long flags
;
1206 spin_lock_irqsave(&chip
->lock
, flags
);
1207 snd_opti93x_mce_up(chip
);
1209 for (i
= 0; i
< 32; i
++)
1210 snd_opti93x_out_image(chip
, i
, snd_opti93x_default_image
[i
]);
1212 snd_opti93x_mce_down(chip
);
1213 spin_unlock_irqrestore(&chip
->lock
, flags
);
1216 static int snd_opti93x_probe(opti93x_t
*chip
)
1218 unsigned long flags
;
1221 spin_lock_irqsave(&chip
->lock
, flags
);
1222 val
= snd_opti93x_in(chip
, OPTi93X_ID
) & 0x0f;
1223 spin_unlock_irqrestore(&chip
->lock
, flags
);
1225 return (val
== 0x0a) ? 0 : -ENODEV
;
1228 static int snd_opti93x_free(opti93x_t
*chip
)
1230 if (chip
->res_port
) {
1231 release_resource(chip
->res_port
);
1232 kfree_nocheck(chip
->res_port
);
1234 if (chip
->dma1
>= 0) {
1235 disable_dma(chip
->dma1
);
1236 free_dma(chip
->dma1
);
1238 if (chip
->dma2
>= 0) {
1239 disable_dma(chip
->dma2
);
1240 free_dma(chip
->dma2
);
1242 if (chip
->irq
>= 0) {
1243 free_irq(chip
->irq
, chip
);
1249 static int snd_opti93x_dev_free(snd_device_t
*device
)
1251 opti93x_t
*chip
= device
->device_data
;
1252 return snd_opti93x_free(chip
);
1255 static const char *snd_opti93x_chip_id(opti93x_t
*codec
)
1257 switch (codec
->hardware
) {
1258 case OPTi9XX_HW_82C930
: return "82C930";
1259 case OPTi9XX_HW_82C931
: return "82C931";
1260 case OPTi9XX_HW_82C933
: return "82C933";
1261 default: return "???";
1265 static int snd_opti93x_create(snd_card_t
*card
, opti9xx_t
*chip
,
1269 static snd_device_ops_t ops
= {
1270 .dev_free
= snd_opti93x_dev_free
,
1276 codec
= kcalloc(1, sizeof(*codec
), GFP_KERNEL
);
1283 if ((codec
->res_port
= request_region(chip
->wss_base
+ 4, 4, "OPTI93x CODEC")) == NULL
) {
1284 snd_printk(KERN_ERR
"opti9xx: can't grab port 0x%lx\n", chip
->wss_base
+ 4);
1285 snd_opti93x_free(codec
);
1288 if (request_dma(dma1
, "OPTI93x - 1")) {
1289 snd_printk(KERN_ERR
"opti9xx: can't grab DMA1 %d\n", dma1
);
1290 snd_opti93x_free(codec
);
1293 codec
->dma1
= chip
->dma1
;
1294 if (request_dma(dma2
, "OPTI93x - 2")) {
1295 snd_printk(KERN_ERR
"opti9xx: can't grab DMA2 %d\n", dma2
);
1296 snd_opti93x_free(codec
);
1299 codec
->dma2
= chip
->dma2
;
1301 if (request_irq(chip
->irq
, snd_opti93x_interrupt
, SA_INTERRUPT
, DRIVER_NAME
" - WSS", codec
)) {
1302 snd_printk(KERN_ERR
"opti9xx: can't grab IRQ %d\n", chip
->irq
);
1303 snd_opti93x_free(codec
);
1308 codec
->port
= chip
->wss_base
+ 4;
1309 codec
->irq
= chip
->irq
;
1311 spin_lock_init(&codec
->lock
);
1312 codec
->hardware
= chip
->hardware
;
1315 if ((error
= snd_opti93x_probe(codec
))) {
1316 snd_opti93x_free(codec
);
1320 snd_opti93x_init(codec
);
1322 /* Register device */
1323 if ((error
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, codec
, &ops
)) < 0) {
1324 snd_opti93x_free(codec
);
1332 static snd_pcm_ops_t snd_opti93x_playback_ops
= {
1333 .open
= snd_opti93x_playback_open
,
1334 .close
= snd_opti93x_playback_close
,
1335 .ioctl
= snd_pcm_lib_ioctl
,
1336 .hw_params
= snd_opti93x_hw_params
,
1337 .hw_free
= snd_opti93x_hw_free
,
1338 .prepare
= snd_opti93x_playback_prepare
,
1339 .trigger
= snd_opti93x_playback_trigger
,
1340 .pointer
= snd_opti93x_playback_pointer
,
1343 static snd_pcm_ops_t snd_opti93x_capture_ops
= {
1344 .open
= snd_opti93x_capture_open
,
1345 .close
= snd_opti93x_capture_close
,
1346 .ioctl
= snd_pcm_lib_ioctl
,
1347 .hw_params
= snd_opti93x_hw_params
,
1348 .hw_free
= snd_opti93x_hw_free
,
1349 .prepare
= snd_opti93x_capture_prepare
,
1350 .trigger
= snd_opti93x_capture_trigger
,
1351 .pointer
= snd_opti93x_capture_pointer
,
1354 static void snd_opti93x_pcm_free(snd_pcm_t
*pcm
)
1356 opti93x_t
*codec
= pcm
->private_data
;
1358 snd_pcm_lib_preallocate_free_for_all(pcm
);
1361 static int snd_opti93x_pcm(opti93x_t
*codec
, int device
, snd_pcm_t
**rpcm
)
1366 if ((error
= snd_pcm_new(codec
->card
, "OPTi 82C93X", device
, 1, 1, &pcm
)))
1369 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_opti93x_playback_ops
);
1370 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_opti93x_capture_ops
);
1372 pcm
->private_data
= codec
;
1373 pcm
->private_free
= snd_opti93x_pcm_free
;
1374 pcm
->info_flags
= SNDRV_PCM_INFO_JOINT_DUPLEX
;
1376 strcpy(pcm
->name
, snd_opti93x_chip_id(codec
));
1378 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
1380 64*1024, codec
->dma1
> 3 || codec
->dma2
> 3 ? 128*1024 : 64*1024);
1392 static int snd_opti93x_info_mux(snd_kcontrol_t
*kcontrol
, snd_ctl_elem_info_t
* uinfo
)
1394 static char *texts
[4] = {
1395 "Line1", "Aux", "Mic", "Mix"
1398 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
1400 uinfo
->value
.enumerated
.items
= 4;
1401 if (uinfo
->value
.enumerated
.item
> 3)
1402 uinfo
->value
.enumerated
.item
= 3;
1403 strcpy(uinfo
->value
.enumerated
.name
, texts
[uinfo
->value
.enumerated
.item
]);
1407 static int snd_opti93x_get_mux(snd_kcontrol_t
* kcontrol
, snd_ctl_elem_value_t
* ucontrol
)
1409 opti93x_t
*chip
= snd_kcontrol_chip(kcontrol
);
1410 unsigned long flags
;
1412 spin_lock_irqsave(&chip
->lock
, flags
);
1413 ucontrol
->value
.enumerated
.item
[0] = (chip
->image
[OPTi93X_MIXOUT_LEFT
] & OPTi93X_MIXOUT_MIXER
) >> 6;
1414 ucontrol
->value
.enumerated
.item
[1] = (chip
->image
[OPTi93X_MIXOUT_RIGHT
] & OPTi93X_MIXOUT_MIXER
) >> 6;
1415 spin_unlock_irqrestore(&chip
->lock
, flags
);
1419 static int snd_opti93x_put_mux(snd_kcontrol_t
* kcontrol
, snd_ctl_elem_value_t
* ucontrol
)
1421 opti93x_t
*chip
= snd_kcontrol_chip(kcontrol
);
1422 unsigned long flags
;
1423 unsigned short left
, right
;
1426 if (ucontrol
->value
.enumerated
.item
[0] > 3 ||
1427 ucontrol
->value
.enumerated
.item
[1] > 3)
1429 left
= ucontrol
->value
.enumerated
.item
[0] << 6;
1430 right
= ucontrol
->value
.enumerated
.item
[1] << 6;
1431 spin_lock_irqsave(&chip
->lock
, flags
);
1432 left
= (chip
->image
[OPTi93X_MIXOUT_LEFT
] & ~OPTi93X_MIXOUT_MIXER
) | left
;
1433 right
= (chip
->image
[OPTi93X_MIXOUT_RIGHT
] & ~OPTi93X_MIXOUT_MIXER
) | right
;
1434 change
= left
!= chip
->image
[OPTi93X_MIXOUT_LEFT
] ||
1435 right
!= chip
->image
[OPTi93X_MIXOUT_RIGHT
];
1436 snd_opti93x_out_image(chip
, OPTi93X_MIXOUT_LEFT
, left
);
1437 snd_opti93x_out_image(chip
, OPTi93X_MIXOUT_RIGHT
, right
);
1438 spin_unlock_irqrestore(&chip
->lock
, flags
);
1444 #define OPTi93X_SINGLE(xname, xindex, reg, shift, mask, invert) \
1445 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1446 .info = snd_opti93x_info_single, \
1447 .get = snd_opti93x_get_single, .put = snd_opti93x_put_single, \
1448 .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
1450 static int snd_opti93x_info_single(snd_kcontrol_t
*kcontrol
, snd_ctl_elem_info_t
* uinfo
)
1452 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
1454 uinfo
->type
= mask
== 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN
: SNDRV_CTL_ELEM_TYPE_INTEGER
;
1456 uinfo
->value
.integer
.min
= 0;
1457 uinfo
->value
.integer
.max
= mask
;
1461 static int snd_opti93x_get_single(snd_kcontrol_t
* kcontrol
, snd_ctl_elem_value_t
* ucontrol
)
1463 opti93x_t
*chip
= snd_kcontrol_chip(kcontrol
);
1464 unsigned long flags
;
1465 int reg
= kcontrol
->private_value
& 0xff;
1466 int shift
= (kcontrol
->private_value
>> 8) & 0xff;
1467 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
1468 int invert
= (kcontrol
->private_value
>> 24) & 0xff;
1470 spin_lock_irqsave(&chip
->lock
, flags
);
1471 ucontrol
->value
.integer
.value
[0] = (chip
->image
[reg
] >> shift
) & mask
;
1472 spin_unlock_irqrestore(&chip
->lock
, flags
);
1474 ucontrol
->value
.integer
.value
[0] = mask
- ucontrol
->value
.integer
.value
[0];
1478 static int snd_opti93x_put_single(snd_kcontrol_t
* kcontrol
, snd_ctl_elem_value_t
* ucontrol
)
1480 opti93x_t
*chip
= snd_kcontrol_chip(kcontrol
);
1481 unsigned long flags
;
1482 int reg
= kcontrol
->private_value
& 0xff;
1483 int shift
= (kcontrol
->private_value
>> 8) & 0xff;
1484 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
1485 int invert
= (kcontrol
->private_value
>> 24) & 0xff;
1489 val
= (ucontrol
->value
.integer
.value
[0] & mask
);
1493 spin_lock_irqsave(&chip
->lock
, flags
);
1494 val
= (chip
->image
[reg
] & ~(mask
<< shift
)) | val
;
1495 change
= val
!= chip
->image
[reg
];
1496 snd_opti93x_out(chip
, reg
, val
);
1497 spin_unlock_irqrestore(&chip
->lock
, flags
);
1503 #define OPTi93X_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1504 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1505 .info = snd_opti93x_info_double, \
1506 .get = snd_opti93x_get_double, .put = snd_opti93x_put_double, \
1507 .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1509 #define OPTi93X_DOUBLE_INVERT_INVERT(xctl) \
1510 do { xctl.private_value ^= 22; } while (0)
1511 #define OPTi93X_DOUBLE_CHANGE_REGS(xctl, left_reg, right_reg) \
1512 do { xctl.private_value &= ~0x0000ffff; \
1513 xctl.private_value |= left_reg | (right_reg << 8); } while (0)
1515 static int snd_opti93x_info_double(snd_kcontrol_t
*kcontrol
, snd_ctl_elem_info_t
* uinfo
)
1517 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
1519 uinfo
->type
= mask
== 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN
: SNDRV_CTL_ELEM_TYPE_INTEGER
;
1521 uinfo
->value
.integer
.min
= 0;
1522 uinfo
->value
.integer
.max
= mask
;
1526 static int snd_opti93x_get_double(snd_kcontrol_t
* kcontrol
, snd_ctl_elem_value_t
* ucontrol
)
1528 opti93x_t
*chip
= snd_kcontrol_chip(kcontrol
);
1529 unsigned long flags
;
1530 int left_reg
= kcontrol
->private_value
& 0xff;
1531 int right_reg
= (kcontrol
->private_value
>> 8) & 0xff;
1532 int shift_left
= (kcontrol
->private_value
>> 16) & 0x07;
1533 int shift_right
= (kcontrol
->private_value
>> 19) & 0x07;
1534 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
1535 int invert
= (kcontrol
->private_value
>> 22) & 1;
1537 spin_lock_irqsave(&chip
->lock
, flags
);
1538 ucontrol
->value
.integer
.value
[0] = (chip
->image
[left_reg
] >> shift_left
) & mask
;
1539 ucontrol
->value
.integer
.value
[1] = (chip
->image
[right_reg
] >> shift_right
) & mask
;
1540 spin_unlock_irqrestore(&chip
->lock
, flags
);
1542 ucontrol
->value
.integer
.value
[0] = mask
- ucontrol
->value
.integer
.value
[0];
1543 ucontrol
->value
.integer
.value
[1] = mask
- ucontrol
->value
.integer
.value
[1];
1548 static int snd_opti93x_put_double(snd_kcontrol_t
* kcontrol
, snd_ctl_elem_value_t
* ucontrol
)
1550 opti93x_t
*chip
= snd_kcontrol_chip(kcontrol
);
1551 unsigned long flags
;
1552 int left_reg
= kcontrol
->private_value
& 0xff;
1553 int right_reg
= (kcontrol
->private_value
>> 8) & 0xff;
1554 int shift_left
= (kcontrol
->private_value
>> 16) & 0x07;
1555 int shift_right
= (kcontrol
->private_value
>> 19) & 0x07;
1556 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
1557 int invert
= (kcontrol
->private_value
>> 22) & 1;
1559 unsigned short val1
, val2
;
1561 val1
= ucontrol
->value
.integer
.value
[0] & mask
;
1562 val2
= ucontrol
->value
.integer
.value
[1] & mask
;
1567 val1
<<= shift_left
;
1568 val2
<<= shift_right
;
1569 spin_lock_irqsave(&chip
->lock
, flags
);
1570 val1
= (chip
->image
[left_reg
] & ~(mask
<< shift_left
)) | val1
;
1571 val2
= (chip
->image
[right_reg
] & ~(mask
<< shift_right
)) | val2
;
1572 change
= val1
!= chip
->image
[left_reg
] || val2
!= chip
->image
[right_reg
];
1573 snd_opti93x_out_image(chip
, left_reg
, val1
);
1574 snd_opti93x_out_image(chip
, right_reg
, val2
);
1575 spin_unlock_irqrestore(&chip
->lock
, flags
);
1579 static snd_kcontrol_new_t snd_opti93x_controls
[] = {
1580 OPTi93X_DOUBLE("Master Playback Switch", 0, OPTi93X_OUT_LEFT
, OPTi93X_OUT_RIGHT
, 7, 7, 1, 1),
1581 OPTi93X_DOUBLE("Master Playback Volume", 0, OPTi93X_OUT_LEFT
, OPTi93X_OUT_RIGHT
, 1, 1, 31, 1),
1582 OPTi93X_DOUBLE("PCM Playback Switch", 0, OPTi93X_DAC_LEFT
, OPTi93X_DAC_RIGHT
, 7, 7, 1, 1),
1583 OPTi93X_DOUBLE("PCM Playback Volume", 0, OPTi93X_DAC_LEFT
, OPTi93X_DAC_RIGHT
, 0, 0, 31, 1),
1584 OPTi93X_DOUBLE("FM Playback Switch", 0, OPTi931_FM_LEFT_INPUT
, OPTi931_FM_RIGHT_INPUT
, 7, 7, 1, 1),
1585 OPTi93X_DOUBLE("FM Playback Volume", 0, OPTi931_FM_LEFT_INPUT
, OPTi931_FM_RIGHT_INPUT
, 1, 1, 15, 1),
1586 OPTi93X_DOUBLE("Line Playback Switch", 0, OPTi93X_LINE_LEFT_INPUT
, OPTi93X_LINE_RIGHT_INPUT
, 7, 7, 1, 1),
1587 OPTi93X_DOUBLE("Line Playback Volume", 0, OPTi93X_LINE_LEFT_INPUT
, OPTi93X_LINE_RIGHT_INPUT
, 1, 1, 15, 1),
1588 OPTi93X_DOUBLE("Mic Playback Switch", 0, OPTi93X_MIC_LEFT_INPUT
, OPTi93X_MIC_RIGHT_INPUT
, 7, 7, 1, 1),
1589 OPTi93X_DOUBLE("Mic Playback Volume", 0, OPTi93X_MIC_LEFT_INPUT
, OPTi93X_MIC_RIGHT_INPUT
, 1, 1, 15, 1),
1590 OPTi93X_DOUBLE("Mic Boost", 0, OPTi93X_MIXOUT_LEFT
, OPTi93X_MIXOUT_RIGHT
, 5, 5, 1, 1),
1591 OPTi93X_DOUBLE("CD Playback Switch", 0, OPTi93X_CD_LEFT_INPUT
, OPTi93X_CD_RIGHT_INPUT
, 7, 7, 1, 1),
1592 OPTi93X_DOUBLE("CD Playback Volume", 0, OPTi93X_CD_LEFT_INPUT
, OPTi93X_CD_RIGHT_INPUT
, 1, 1, 15, 1),
1593 OPTi93X_DOUBLE("Aux Playback Switch", 0, OPTi931_AUX_LEFT_INPUT
, OPTi931_AUX_RIGHT_INPUT
, 7, 7, 1, 1),
1594 OPTi93X_DOUBLE("Aux Playback Volume", 0, OPTi931_AUX_LEFT_INPUT
, OPTi931_AUX_RIGHT_INPUT
, 1, 1, 15, 1),
1595 OPTi93X_DOUBLE("Capture Volume", 0, OPTi93X_MIXOUT_LEFT
, OPTi93X_MIXOUT_RIGHT
, 0, 0, 15, 0),
1597 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1598 .name
= "Capture Source",
1599 .info
= snd_opti93x_info_mux
,
1600 .get
= snd_opti93x_get_mux
,
1601 .put
= snd_opti93x_put_mux
,
1605 static int snd_opti93x_mixer(opti93x_t
*chip
)
1608 snd_kcontrol_new_t knew
;
1612 snd_assert(chip
!= NULL
&& chip
->card
!= NULL
, return -EINVAL
);
1616 strcpy(card
->mixername
, snd_opti93x_chip_id(chip
));
1618 for (idx
= 0; idx
< ARRAY_SIZE(snd_opti93x_controls
); idx
++) {
1619 knew
= snd_opti93x_controls
[idx
];
1620 if (chip
->hardware
== OPTi9XX_HW_82C930
) {
1621 if (strstr(knew
.name
, "FM")) /* skip FM controls */
1623 else if (strcmp(knew
.name
, "Mic Playback Volume"))
1624 OPTi93X_DOUBLE_INVERT_INVERT(knew
);
1625 else if (strstr(knew
.name
, "Aux"))
1626 OPTi93X_DOUBLE_CHANGE_REGS(knew
, OPTi930_AUX_LEFT_INPUT
, OPTi930_AUX_RIGHT_INPUT
);
1627 else if (strcmp(knew
.name
, "PCM Playback Volume"))
1628 OPTi93X_DOUBLE_INVERT_INVERT(knew
);
1629 else if (strcmp(knew
.name
, "Master Playback Volume"))
1630 OPTi93X_DOUBLE_INVERT_INVERT(knew
);
1632 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&snd_opti93x_controls
[idx
], chip
))) < 0)
1638 #endif /* OPTi93X */
1640 static int __devinit
snd_card_opti9xx_detect(snd_card_t
*card
, opti9xx_t
*chip
)
1645 for (i
= OPTi9XX_HW_82C928
; i
< OPTi9XX_HW_82C930
; i
++) {
1646 unsigned char value
;
1648 if ((err
= snd_opti9xx_init(chip
, i
)) < 0)
1651 if ((chip
->res_mc_base
= request_region(chip
->mc_base
, chip
->mc_base_size
, "OPTi9xx MC")) == NULL
)
1654 value
= snd_opti9xx_read(chip
, OPTi9XX_MC_REG(1));
1655 if ((value
!= 0xff) && (value
!= inb(chip
->mc_base
+ 1)))
1656 if (value
== snd_opti9xx_read(chip
, OPTi9XX_MC_REG(1)))
1659 release_resource(chip
->res_mc_base
);
1660 kfree_nocheck(chip
->res_mc_base
);
1661 chip
->res_mc_base
= NULL
;
1665 for (i
= OPTi9XX_HW_82C931
; i
>= OPTi9XX_HW_82C930
; i
--) {
1666 unsigned long flags
;
1667 unsigned char value
;
1669 if ((err
= snd_opti9xx_init(chip
, i
)) < 0)
1672 if ((chip
->res_mc_base
= request_region(chip
->mc_base
, chip
->mc_base_size
, "OPTi9xx MC")) == NULL
)
1675 spin_lock_irqsave(&chip
->lock
, flags
);
1676 outb(chip
->password
, chip
->mc_base
+ chip
->pwd_reg
);
1677 outb(((chip
->mc_indir_index
& (1 << 8)) >> 4) |
1678 ((chip
->mc_indir_index
& 0xf0) >> 4), chip
->mc_base
);
1679 spin_unlock_irqrestore(&chip
->lock
, flags
);
1681 value
= snd_opti9xx_read(chip
, OPTi9XX_MC_REG(7));
1682 snd_opti9xx_write(chip
, OPTi9XX_MC_REG(7), 0xff - value
);
1683 if (snd_opti9xx_read(chip
, OPTi9XX_MC_REG(7)) == 0xff - value
)
1686 release_resource(chip
->res_mc_base
);
1687 kfree_nocheck(chip
->res_mc_base
);
1688 chip
->res_mc_base
= NULL
;
1690 #endif /* OPTi93X */
1696 static int __devinit
snd_card_opti9xx_pnp(opti9xx_t
*chip
, struct pnp_card_link
*card
,
1697 const struct pnp_card_device_id
*pid
)
1699 struct pnp_dev
*pdev
;
1700 struct pnp_resource_table
*cfg
= kmalloc(sizeof(*cfg
), GFP_KERNEL
);
1703 chip
->dev
= pnp_request_card_device(card
, pid
->devs
[0].id
, NULL
);
1704 if (chip
->dev
== NULL
) {
1708 chip
->devmpu
= pnp_request_card_device(card
, pid
->devs
[1].id
, NULL
);
1711 pnp_init_resource_table(cfg
);
1714 if (port
!= SNDRV_AUTO_PORT
)
1715 pnp_resource_change(&cfg
->port_resource
[0], port
+ 4, 4);
1717 if (pid
->driver_data
!= 0x0924 && port
!= SNDRV_AUTO_PORT
)
1718 pnp_resource_change(&cfg
->port_resource
[1], port
, 4);
1719 #endif /* OPTi93X */
1720 if (irq
!= SNDRV_AUTO_IRQ
)
1721 pnp_resource_change(&cfg
->irq_resource
[0], irq
, 1);
1722 if (dma1
!= SNDRV_AUTO_DMA
)
1723 pnp_resource_change(&cfg
->dma_resource
[0], dma1
, 1);
1724 #if defined(CS4231) || defined(OPTi93X)
1725 if (dma2
!= SNDRV_AUTO_DMA
)
1726 pnp_resource_change(&cfg
->dma_resource
[1], dma2
, 1);
1728 #ifdef snd_opti9xx_fixup_dma2
1729 snd_opti9xx_fixup_dma2(pdev
);
1731 #endif /* CS4231 || OPTi93X */
1733 if (fm_port
> 0 && fm_port
!= SNDRV_AUTO_PORT
)
1734 pnp_resource_change(&cfg
->port_resource
[1], fm_port
, 4);
1736 if (fm_port
> 0 && fm_port
!= SNDRV_AUTO_PORT
)
1737 pnp_resource_change(&cfg
->port_resource
[2], fm_port
, 4);
1739 if (pnp_manual_config_dev(pdev
, cfg
, 0) < 0)
1740 snd_printk(KERN_ERR
"AUDIO the requested resources are invalid, using auto config\n");
1741 err
= pnp_activate_dev(pdev
);
1743 snd_printk(KERN_ERR
"AUDIO pnp configure failure: %d\n", err
);
1749 port
= pnp_port_start(pdev
, 0) - 4;
1750 fm_port
= pnp_port_start(pdev
, 1);
1752 if (pid
->driver_data
!= 0x0924)
1753 port
= pnp_port_start(pdev
, 1);
1754 fm_port
= pnp_port_start(pdev
, 2);
1755 #endif /* OPTi93X */
1756 irq
= pnp_irq(pdev
, 0);
1757 dma1
= pnp_dma(pdev
, 0);
1758 #if defined(CS4231) || defined(OPTi93X)
1759 dma2
= pnp_dma(pdev
, 1);
1760 #endif /* CS4231 || OPTi93X */
1762 pdev
= chip
->devmpu
;
1763 if (pdev
&& mpu_port
> 0) {
1764 pnp_init_resource_table(cfg
);
1766 if (mpu_port
!= SNDRV_AUTO_PORT
)
1767 pnp_resource_change(&cfg
->port_resource
[0], mpu_port
, 2);
1768 if (mpu_irq
!= SNDRV_AUTO_IRQ
)
1769 pnp_resource_change(&cfg
->irq_resource
[0], mpu_irq
, 1);
1771 if (pnp_manual_config_dev(pdev
, cfg
, 0) < 0)
1772 snd_printk(KERN_ERR
"AUDIO the requested resources are invalid, using auto config\n");
1773 err
= pnp_activate_dev(pdev
);
1775 snd_printk(KERN_ERR
"AUDIO pnp configure failure\n");
1777 chip
->devmpu
= NULL
;
1779 mpu_port
= pnp_port_start(pdev
, 0);
1780 mpu_irq
= pnp_irq(pdev
, 0);
1784 return pid
->driver_data
;
1786 #endif /* CONFIG_PNP */
1789 static int __devinit
snd_card_opti9xx_resources(struct snd_card_opti9xx
*chip
,
1792 int error
, i
, pnp
= 0;
1795 pnp
= chip
->dev
!= NULL
;
1796 #endif /* CONFIG_PNP */
1799 if (chip
->chip
->hardware
== OPTi9XX_HW_82C928
)
1801 #endif /* OPTi93X */
1803 if (!pnp
&& (mpu_port
== SNDRV_DEFAULT_PORT1
)) {
1804 for (i
= 0; possible_mpu_ports
[i
] != -1; i
++)
1805 if (!snd_register_ioport(card
, possible_mpu_ports
[i
], 2,
1806 DRIVER_NAME
" - MPU-401", NULL
)) {
1807 mpu_port
= possible_mpu_ports
[i
];
1810 if (mpu_port
== SNDRV_DEFAULT_PORT1
)
1814 error
= (mpu_port
== -1) ? -ENODEV
:
1815 snd_register_ioport(card
, mpu_port
, 2,
1816 DRIVER_NAME
" - MPU-401", NULL
);
1818 chip
->chip
->mpu_port
= -1;
1819 else if (pnp
&& (irq
== mpu_irq
))
1820 chip
->chip
->mpu_irq
= mpu_irq
;
1821 else if (!snd_register_interrupt(card
,
1822 DRIVER_NAME
" - MPU-401",
1823 mpu_irq
, SNDRV_IRQ_TYPE_ISA
,
1824 snd_card_opti9xx_mpu_interrupt
, chip
,
1825 pnp
? no_alternatives
: possible_mpu_irqs
,
1826 &chip
->mpuirqptr
)) {
1827 chip
->chip
->mpu_port
= mpu_port
;
1828 chip
->chip
->mpu_irq
= chip
->mpuirqptr
->irq
;
1831 chip
->chip
->mpu_port
= -1;
1833 if (!pnp
&& (port
== SNDRV_DEFAULT_PORT1
)) {
1834 for (i
= 0; possible_ports
[i
] != -1; i
++)
1835 if (!snd_register_ioport(card
, possible_ports
[i
], 8,
1836 DRIVER_NAME
" - WSS", NULL
)) {
1837 port
= possible_ports
[i
];
1840 if (port
== SNDRV_DEFAULT_PORT1
)
1843 else if ((error
= snd_register_ioport(card
, port
, 8,
1844 DRIVER_NAME
" - WSS", NULL
)) < 0)
1846 chip
->chip
->wss_base
= port
;
1847 if ((error
= snd_register_interrupt(card
, DRIVER_NAME
" - WSS",
1848 irq
, SNDRV_IRQ_TYPE_ISA
,
1849 snd_card_opti9xx_interrupt
, chip
,
1850 pnp
? no_alternatives
: possible_irqs
,
1851 &chip
->irqptr
)) < 0)
1853 chip
->chip
->irq
= chip
->irqptr
->irq
;
1854 if ((error
= snd_register_dma_channel(card
,
1855 #if defined(CS4231) || defined(OPTi93X)
1856 DRIVER_NAME
" - WSS playback",
1858 DRIVER_NAME
" - WSS",
1859 #endif /* CS4231 || OPTi93X */
1860 dma1
, SNDRV_DMA_TYPE_ISA
, dma1_size
,
1861 pnp
? no_alternatives
: possible_dma1s
,
1862 &chip
->dma1ptr
)) < 0)
1864 chip
->chip
->dma1
= chip
->dma1ptr
->dma
;
1865 #if defined(CS4231) || defined(OPTi93X)
1866 if ((error
= snd_register_dma_channel(card
, DRIVER_NAME
" - WSS capture",
1867 dma2
, SNDRV_DMA_TYPE_ISA
, dma2_size
,
1868 pnp
? no_alternatives
:
1869 possible_dma2s
[chip
->dma1ptr
->dma
],
1870 &chip
->dma2ptr
)) < 0)
1872 chip
->chip
->dma2
= chip
->dma2ptr
->dma
;
1873 #endif /* CS4231 || OPTi93X */
1875 if (snd_register_ioport(card
,
1876 pnp
? fm_port
: fm_port
= 0x388, 4,
1877 DRIVER_NAME
" - OPL", NULL
) < 0)
1879 chip
->chip
->fm_port
= fm_port
;
1885 static void snd_card_opti9xx_free(snd_card_t
*card
)
1887 opti9xx_t
*chip
= (opti9xx_t
*)card
->private_data
;
1890 if (chip
->res_mc_base
) {
1891 release_resource(chip
->res_mc_base
);
1892 kfree_nocheck(chip
->res_mc_base
);
1897 static int __devinit
snd_card_opti9xx_probe(struct pnp_card_link
*pcard
,
1898 const struct pnp_card_device_id
*pid
)
1900 static long possible_ports
[] = {0x530, 0xe80, 0xf40, 0x604, -1};
1901 static long possible_mpu_ports
[] = {0x300, 0x310, 0x320, 0x330, -1};
1903 static int possible_irqs
[] = {5, 9, 10, 11, 7, -1};
1905 static int possible_irqs
[] = {9, 10, 11, 7, -1};
1906 #endif /* OPTi93X */
1907 static int possible_mpu_irqs
[] = {5, 9, 10, 7, -1};
1908 static int possible_dma1s
[] = {3, 1, 0, -1};
1909 #if defined(CS4231) || defined(OPTi93X)
1910 static int possible_dma2s
[][2] = {{1,-1}, {0,-1}, {-1,-1}, {0,-1}};
1911 #endif /* CS4231 || OPTi93X */
1914 #if defined(OPTi93X)
1916 #elif defined(CS4231)
1924 snd_rawmidi_t
*rmidi
;
1928 #endif /* CONFIG_PNP */
1930 if (pcard
&& !snd_opti9xx_first_hit
)
1932 if (!(card
= snd_card_new(index
, id
, THIS_MODULE
,
1933 sizeof(opti9xx_t
))))
1935 card
->private_free
= snd_card_opti9xx_free
;
1936 chip
= (opti9xx_t
*)card
->private_data
;
1939 if (isapnp
&& pcard
&& (hw
= snd_card_opti9xx_pnp(chip
, pcard
, pid
)) > 0) {
1942 hw
= OPTi9XX_HW_82C924
;
1945 hw
= OPTi9XX_HW_82C925
;
1948 hw
= OPTi9XX_HW_82C931
;
1951 snd_card_free(card
);
1955 if ((error
= snd_opti9xx_init(chip
, hw
))) {
1956 snd_card_free(card
);
1959 if (hw
<= OPTi9XX_HW_82C930
)
1960 chip
->mc_base
-= 0x80;
1961 snd_card_set_dev(card
, &pcard
->card
->dev
);
1963 #endif /* CONFIG_PNP */
1964 if ((error
= snd_card_opti9xx_detect(card
, chip
)) < 0) {
1965 snd_card_free(card
);
1970 #endif /* CONFIG_PNP */
1972 if (! chip
->res_mc_base
&&
1973 (chip
->res_mc_base
= request_region(chip
->mc_base
, chip
->mc_base_size
, "OPTi9xx MC")) == NULL
) {
1974 snd_card_free(card
);
1978 chip
->wss_base
= port
;
1979 chip
->fm_port
= fm_port
;
1980 chip
->mpu_port
= mpu_port
;
1982 chip
->mpu_irq
= mpu_irq
;
1984 #if defined(CS4231) || defined(OPTi93X)
1988 if (chip
->wss_base
== SNDRV_AUTO_PORT
) {
1989 if ((chip
->wss_base
= snd_legacy_find_free_ioport(possible_ports
, 4)) < 0) {
1990 snd_card_free(card
);
1991 snd_printk("unable to find a free WSS port\n");
1998 if (chip
->mpu_port
== SNDRV_AUTO_PORT
) {
1999 if ((chip
->mpu_port
= snd_legacy_find_free_ioport(possible_mpu_ports
, 2)) < 0) {
2000 snd_card_free(card
);
2001 snd_printk("unable to find a free MPU401 port\n");
2005 if (chip
->irq
== SNDRV_AUTO_IRQ
) {
2006 if ((chip
->irq
= snd_legacy_find_free_irq(possible_irqs
)) < 0) {
2007 snd_card_free(card
);
2008 snd_printk("unable to find a free IRQ\n");
2012 if (chip
->mpu_irq
== SNDRV_AUTO_IRQ
) {
2013 if ((chip
->mpu_irq
= snd_legacy_find_free_irq(possible_mpu_irqs
)) < 0) {
2014 snd_card_free(card
);
2015 snd_printk("unable to find a free MPU401 IRQ\n");
2019 if (chip
->dma1
== SNDRV_AUTO_DMA
) {
2020 if ((chip
->dma1
= snd_legacy_find_free_dma(possible_dma1s
)) < 0) {
2021 snd_card_free(card
);
2022 snd_printk("unable to find a free DMA1\n");
2026 #if defined(CS4231) || defined(OPTi93X)
2027 if (chip
->dma2
== SNDRV_AUTO_DMA
) {
2028 if ((chip
->dma2
= snd_legacy_find_free_dma(possible_dma2s
[chip
->dma1
% 4])) < 0) {
2029 snd_card_free(card
);
2030 snd_printk("unable to find a free DMA2\n");
2040 if ((error
= snd_opti9xx_configure(chip
))) {
2041 snd_card_free(card
);
2045 #if defined(OPTi93X)
2046 if ((error
= snd_opti93x_create(card
, chip
, chip
->dma1
, chip
->dma2
, &codec
))) {
2047 snd_card_free(card
);
2050 if ((error
= snd_opti93x_pcm(codec
, 0, &pcm
)) < 0) {
2051 snd_card_free(card
);
2054 if ((error
= snd_opti93x_mixer(codec
)) < 0) {
2055 snd_card_free(card
);
2058 #elif defined(CS4231)
2059 if ((error
= snd_cs4231_create(card
, chip
->wss_base
+ 4, -1,
2060 chip
->irq
, chip
->dma1
, chip
->dma2
,
2064 snd_card_free(card
);
2067 if ((error
= snd_cs4231_pcm(codec
, 0, &pcm
)) < 0) {
2068 snd_card_free(card
);
2071 if ((error
= snd_cs4231_mixer(codec
)) < 0) {
2072 snd_card_free(card
);
2075 if ((error
= snd_cs4231_timer(codec
, 0, &timer
)) < 0) {
2076 snd_card_free(card
);
2080 if ((error
= snd_ad1848_create(card
, chip
->wss_base
+ 4,
2081 chip
->irq
, chip
->dma1
,
2082 AD1848_HW_DETECT
, &codec
)) < 0) {
2083 snd_card_free(card
);
2086 if ((error
= snd_ad1848_pcm(codec
, 0, &pcm
)) < 0) {
2087 snd_card_free(card
);
2090 if ((error
= snd_ad1848_mixer(codec
)) < 0) {
2091 snd_card_free(card
);
2095 strcpy(card
->driver
, chip
->name
);
2096 sprintf(card
->shortname
, "OPTi %s", card
->driver
);
2097 #if defined(CS4231) || defined(OPTi93X)
2098 sprintf(card
->longname
, "%s, %s at 0x%lx, irq %d, dma %d&%d",
2099 card
->shortname
, pcm
->name
, chip
->wss_base
+ 4,
2100 chip
->irq
, chip
->dma1
, chip
->dma2
);
2102 sprintf(card
->longname
, "%s, %s at 0x%lx, irq %d, dma %d",
2103 card
->shortname
, pcm
->name
, chip
->wss_base
+ 4,
2104 chip
->irq
, chip
->dma1
);
2105 #endif /* CS4231 || OPTi93X */
2107 if (chip
->mpu_port
<= 0 || chip
->mpu_port
== SNDRV_AUTO_PORT
)
2110 if ((error
= snd_mpu401_uart_new(card
, 0, MPU401_HW_MPU401
,
2111 chip
->mpu_port
, 0, chip
->mpu_irq
, SA_INTERRUPT
,
2113 snd_printk("no MPU-401 device at 0x%lx?\n", chip
->mpu_port
);
2115 if (chip
->fm_port
> 0 && chip
->fm_port
!= SNDRV_AUTO_PORT
) {
2116 opl3_t
*opl3
= NULL
;
2118 if (chip
->hardware
== OPTi9XX_HW_82C928
||
2119 chip
->hardware
== OPTi9XX_HW_82C929
||
2120 chip
->hardware
== OPTi9XX_HW_82C924
) {
2122 /* assume we have an OPL4 */
2123 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(2),
2125 if (snd_opl4_create(card
,
2128 2, &opl3
, &opl4
) < 0) {
2129 /* no luck, use OPL3 instead */
2130 snd_opti9xx_write_mask(chip
, OPTi9XX_MC_REG(2),
2134 #endif /* !OPTi93X */
2135 if (!opl3
&& snd_opl3_create(card
,
2138 OPL3_HW_AUTO
, 0, &opl3
) < 0) {
2139 snd_printk("no OPL device at 0x%lx-0x%lx\n",
2140 chip
->fm_port
, chip
->fm_port
+ 4 - 1);
2143 if ((error
= snd_opl3_timer_new(opl3
,
2149 snd_card_free(card
);
2152 if ((error
= snd_opl3_hwdep_new(opl3
, 0, 1, &synth
)) < 0) {
2153 snd_card_free(card
);
2159 if ((error
= snd_card_register(card
))) {
2160 snd_card_free(card
);
2163 snd_opti9xx_first_hit
= 0;
2165 pnp_set_card_drvdata(pcard
, card
);
2167 snd_opti9xx_legacy
= card
;
2172 static void __devexit
snd_opti9xx_pnp_remove(struct pnp_card_link
* pcard
)
2174 snd_card_t
*card
= (snd_card_t
*) pnp_get_card_drvdata(pcard
);
2176 snd_card_disconnect(card
);
2177 snd_card_free_in_thread(card
);
2178 snd_opti9xx_first_hit
= 0;
2181 static struct pnp_card_driver opti9xx_pnpc_driver
= {
2182 .flags
= PNP_DRIVER_RES_DISABLE
,
2184 .id_table
= snd_opti9xx_pnpids
,
2185 .probe
= snd_card_opti9xx_probe
,
2186 .remove
= __devexit_p(snd_opti9xx_pnp_remove
),
2190 static int __init
alsa_card_opti9xx_init(void)
2195 cards
= pnp_register_card_driver(&opti9xx_pnpc_driver
);
2199 if (cards
== 0 && (error
= snd_card_opti9xx_probe(NULL
, NULL
)) < 0) {
2201 pnp_unregister_card_driver(&opti9xx_pnpc_driver
);
2205 printk(KERN_ERR
"no OPTi 82C93x soundcard found\n");
2207 printk(KERN_ERR
"no OPTi 82C92x soundcard found\n");
2208 #endif /* OPTi93X */
2215 static void __exit
alsa_card_opti9xx_exit(void)
2218 pnp_unregister_card_driver(&opti9xx_pnpc_driver
);
2220 if (snd_opti9xx_legacy
)
2221 snd_card_free(snd_opti9xx_legacy
);
2224 module_init(alsa_card_opti9xx_init
)
2225 module_exit(alsa_card_opti9xx_exit
)