← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/oss4/oneiric-proposed

« back to all changes in this revision

Viewing changes to kernel/drv/oss_cmpci/oss_cmpci.c

  • Committer: Bazaar Package Importer
  • Author(s): Stefano Rivera
  • Date: 2011-06-16 20:37:48 UTC
  • mfrom: (5.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20110616203748-jbrxik6ql33z54co
Tags: 4.2-build2004-1ubuntu1
https://launchpad.net/bugs/746048
https://launchpad.net/bugs/770972
* Merge from Debian unstable.
  - Supports our current kernel (LP: #746048)
  Remaining changes:
  - debian/oss4-dkms.dkms.in: s/source/build/ in Kernel headers paths.
* ld-as-needed.patch: Re-order CC arguments to enable building with ld
  --as-needed (LP: #770972)

Show diffs side-by-side

added added

removed removed

Lines of Context:
kernel/drv/oss_cmpci/oss_cmpci.c
 
1
/*
 
2
 * Purpose: Driver for CMEDIA CM8738 PCI audio controller.
 
3
 */
 
4
/*
 
5
 *
 
6
 * This file is part of Open Sound System.
 
7
 *
 
8
 * Copyright (C) 4Front Technologies 1996-2008.
 
9
 *
 
10
 * This this source file is released under GPL v2 license (no other versions).
 
11
 * See the COPYING file included in the main directory of this source
 
12
 * distribution for the license terms and conditions.
 
13
 *
 
14
 */
 
15
 
 
16
#include "oss_cmpci_cfg.h"
 
17
#include "oss_pci.h"
 
18
#include "uart401.h"
 
19
 
 
20
#define CMEDIA_VENDOR_ID        0x13F6
 
21
#define CMEDIA_CM8738           0x0111
 
22
#define CMEDIA_CM8338A          0x0100
 
23
#define CMEDIA_CM8338B          0x0101
 
24
/*
 
25
 * CM8338 registers definition
 
26
 */
 
27
 
 
28
#define FUNCTRL0      (devc->base+0x00)
 
29
#define FUNCTRL1      (devc->base+0x04)
 
30
#define CHFORMAT      (devc->base+0x08)
 
31
#define INT_HLDCLR    (devc->base+0x0C)
 
32
#define INT_STATUS    (devc->base+0x10)
 
33
#define LEGACY_CTRL   (devc->base+0x14)
 
34
#define MISC_CTRL     (devc->base+0x18)
 
35
#define TDMA_POS      (devc->base+0x1C)
 
36
#define MIXER         (devc->base+0x20)
 
37
#define MIXER_DATA    (devc->base+0x22)
 
38
#define MIXER_ADDR    (devc->base+0x23)
 
39
#define MIXER1        (devc->base+0x24)
 
40
#define MIXER2        (devc->base+0x25)
 
41
#define AUX_VOL       (devc->base+0x26)
 
42
#define MIXER3        (devc->base+0x27)
 
43
#define AC97          (devc->base+0x28)
 
44
 
 
45
#define CH0_FRAME1    (devc->base+0x80)
 
46
#define CH0_FRAME2    (devc->base+0x84)
 
47
#define CH1_FRAME1    (devc->base+0x88)
 
48
#define CH1_FRAME2    (devc->base+0x8C)
 
49
 
 
50
#define SPDIF_STAT    (devc->base+0x90)
 
51
#define MISC2_CTRL    (devc->base+0x92)
 
52
 
 
53
#define MPU_MIRROR    (devc->base+0x40)
 
54
#define FM_MIRROR     (devc->base+0x50)
 
55
#define JOY_MIRROR    (devc->base+0x60)
 
56
 
 
57
#define DSP_MIX_DATARESETIDX    (0x00)
 
58
#define DSP_MIX_OUTMIXIDX       (0x3c)
 
59
#define CM_CH0_ENABLE     0x01
 
60
#define CM_CH1_ENABLE     0x02
 
61
#define CM_CH0_RESET      0x04
 
62
#define CM_CH1_RESET      0x08
 
63
#define CM_CH0_RECORD     0x01
 
64
#define CM_CH1_RECORD     0x02
 
65
#define CM_CH0_PLAY       ~0x01
 
66
#define CM_CH1_PLAY       ~0x02
 
67
#define CM_CH0_INT        1
 
68
#define CM_CH1_INT        2
 
69
#define CM_EXTENT_CODEC   0x100
 
70
#define CM_EXTENT_MIDI    0x2
 
71
#define CM_EXTENT_SYNTH   0x4
 
72
#define CM_CFMT_STEREO    0x01
 
73
#define CM_CFMT_16BIT     0x02
 
74
#define CM_CFMT_MASK      0x03
 
75
#define CM_CFMT_DACSHIFT  0
 
76
#define CM_CFMT_ADCSHIFT  2
 
77
 
 
78
#define MUTE_LINE       1
 
79
#define MUTE_CD         2
 
80
#define MUTE_MIC        3
 
81
#define MUTE_AUX        4
 
82
#define REAR2LINE       5
 
83
#define CEN2LINE        6
 
84
#define BASS2LINE       7
 
85
#define CEN2MIC         8
 
86
#define MODE_4SPK       9
 
87
#define DUALDAC         10
 
88
#define MICBOOST        11
 
89
#define SPDIF_PLAY      12
 
90
#define SPDIF_LOOP      13
 
91
#define SPDIF_REC       14
 
92
#define SPDIF_IMON      15
 
93
#define SPDIF_POL       16
 
94
#define SPDIF_COPY      17
 
95
#define SPDIF_OPT       18
 
96
#define SPDIF_AC3       19
 
97
#define AUX_REC         20
 
98
#define AUX_LEVEL       21
 
99
 
 
100
#define CHAN0              0x1
 
101
#define CHAN1              0x2
 
102
 
 
103
static struct
 
104
{
 
105
  unsigned int rate;
 
106
  unsigned int lower;
 
107
  unsigned int upper;
 
108
  unsigned char freq;
 
109
}
 
110
rate_lookup[] =
 
111
{
 
112
  {
 
113
  5512, (0 + 5512) / 2, (5512 + 8000) / 2, 0}
 
114
  ,
 
115
  {
 
116
  8000, (5512 + 8000) / 2, (8000 + 11025) / 2, 4}
 
117
  ,
 
118
  {
 
119
  11025, (8000 + 11025) / 2, (11025 + 16000) / 2, 1}
 
120
  ,
 
121
  {
 
122
  16000, (11025 + 16000) / 2, (16000 + 22050) / 2, 5}
 
123
  ,
 
124
  {
 
125
  22050, (16000 + 22050) / 2, (22050 + 32000) / 2, 2}
 
126
  ,
 
127
  {
 
128
  32000, (22050 + 32000) / 2, (32000 + 44100) / 2, 6}
 
129
  ,
 
130
  {
 
131
  44100, (32000 + 44100) / 2, (44100 + 48000) / 2, 3}
 
132
  ,
 
133
  {
 
134
  48000, (48000 + 44100) / 2, (48000 + 96000) / 2, 7}
 
135
};
 
136
 
 
137
static unsigned char cmpci_recmasks_L[SOUND_MIXER_NRDEVICES] = {
 
138
  0x00,                         /* SOUND_MIXER_VOLUME   */
 
139
  0x00,                         /* SOUND_MIXER_BASS     */
 
140
  0x00,                         /* SOUND_MIXER_TREBLE   */
 
141
  0x40,                         /* SOUND_MIXER_SYNTH    */
 
142
  0x00,                         /* SOUND_MIXER_PCM      */
 
143
  0x00,                         /* SOUND_MIXER_SPEAKER  */
 
144
  0x10,                         /* SOUND_MIXER_LINE     */
 
145
  0x01,                         /* SOUND_MIXER_MIC      */
 
146
  0x04,                         /* SOUND_MIXER_CD       */
 
147
  0x00,                         /* SOUND_MIXER_IMIX     */
 
148
  0x00,                         /* SOUND_MIXER_LINE1    */
 
149
  0x00,                         /* SOUND_MIXER_RECLEV   */
 
150
  0x00,                         /* SOUND_MIXER_IGAIN    */
 
151
  0x00                          /* SOUND_MIXER_OGAIN    */
 
152
};
 
153
 
 
154
static unsigned char cmpci_recmasks_R[SOUND_MIXER_NRDEVICES] = {
 
155
  0x00,                         /* SOUND_MIXER_VOLUME   */
 
156
  0x00,                         /* SOUND_MIXER_BASS     */
 
157
  0x00,                         /* SOUND_MIXER_TREBLE   */
 
158
  0x20,                         /* SOUND_MIXER_SYNTH    */
 
159
  0x00,                         /* SOUND_MIXER_PCM      */
 
160
  0x00,                         /* SOUND_MIXER_SPEAKER  */
 
161
  0x08,                         /* SOUND_MIXER_LINE     */
 
162
  0x01,                         /* SOUND_MIXER_MIC      */
 
163
  0x02,                         /* SOUND_MIXER_CD       */
 
164
  0x00,                         /* SOUND_MIXER_IMIX     */
 
165
  0x00,                         /* SOUND_MIXER_LINE1    */
 
166
  0x00,                         /* SOUND_MIXER_RECLEV   */
 
167
  0x00,                         /* SOUND_MIXER_IGAIN    */
 
168
  0x00                          /* SOUND_MIXER_OGAIN    */
 
169
};
 
170
 
 
171
#define CMEDIA_RECORDING_DEVICES (SOUND_MASK_SYNTH | SOUND_MASK_LINE | \
 
172
                                  SOUND_MASK_MIC | SOUND_MASK_CD | SOUND_MASK_LINE1)
 
173
 
 
174
#define CMEDIA_MIXER_DEVICES (SOUND_MASK_SYNTH | SOUND_MASK_PCM | \
 
175
                             SOUND_MASK_LINE | SOUND_MASK_MIC | \
 
176
                             SOUND_MASK_IGAIN | SOUND_MASK_CD | \
 
177
                             SOUND_MASK_VOLUME | SOUND_MASK_SPEAKER |\
 
178
                             SOUND_MASK_LINE1|SOUND_MASK_RECLEV)
 
179
 
 
180
#define LEFT_CHN        0
 
181
#define RIGHT_CHN       1
 
182
/*
 
183
 * Mixer registers of CMPCI
 
184
 */
 
185
#define CMPCI_IMASK_L    0x3d
 
186
#define CMPCI_IMASK_R    0x3e
 
187
 
 
188
 
 
189
int default_levels[32] = {
 
190
  0x5a5a,                       /* Master Volume */
 
191
  0x4b4b,                       /* Bass */
 
192
  0x4b4b,                       /* Treble */
 
193
  0x4b4b,                       /* FM */
 
194
  0x4b4b,                       /* PCM */
 
195
  0x4b4b,                       /* PC Speaker */
 
196
  0x4b4b,                       /* Ext Line */
 
197
  0x2020,                       /* Mic */
 
198
  0x4b4b,                       /* CD */
 
199
  0x0000,                       /* Recording monitor */
 
200
  0x4b4b,                       /* SB PCM */
 
201
  0x4b4b,                       /* Recording level */
 
202
  0x4b4b,                       /* Input gain */
 
203
  0x4b4b,                       /* Output gain */
 
204
  0x4040,                       /* Line1 */
 
205
  0x4040,                       /* Line2 */
 
206
  0x1515                        /* Line3 */
 
207
};
 
208
 
 
209
typedef struct cmpci_portc
 
210
{
 
211
  int speed, bits, channels;
 
212
  int open_mode;
 
213
  int trigger_bits;
 
214
  int audio_enabled;
 
215
  int audiodev;
 
216
  int dacfmt, adcfmt;
 
217
  int chan0_play, chan0_rec;
 
218
  int chan1_play, chan1_rec;
 
219
}
 
220
cmpci_portc;
 
221
 
 
222
#define MAX_PORTC 2
 
223
 
 
224
typedef struct cmpci_devc
 
225
{
 
226
  oss_device_t *osdev;
 
227
  oss_native_word base;
 
228
  int fm_attached;
 
229
  int irq;
 
230
  int max_channels;
 
231
  volatile unsigned char intr_mask;
 
232
  int model;
 
233
#define MDL_CM8738              1
 
234
#define MDL_CM8338A             2
 
235
#define MDL_CM8338B             3
 
236
#define MDL_CM8768              4
 
237
  char *chip_name;
 
238
  int chiprev;
 
239
  int mode_4spk;
 
240
  int dev_mode;
 
241
#define DEFAULT_MODE            1
 
242
#define DUALDAC_MODE            2
 
243
#define SPDIFIN_MODE            4
 
244
  unsigned char spdif_control_bits[24];
 
245
  /* Audio parameters */
 
246
  oss_mutex_t mutex;
 
247
  oss_mutex_t low_mutex;
 
248
  int open_mode;
 
249
  int audio_initialized;
 
250
  cmpci_portc portc[MAX_PORTC];
 
251
 
 
252
  /* spdif/ac3 stuff */
 
253
  int spdif_enabled;
 
254
  int can_ac3;
 
255
 
 
256
  /* Mixer parameters */
 
257
  int mixer_dev;
 
258
  int *levels;
 
259
  int recmask;
 
260
 
 
261
  /* uart401 */
 
262
  int uart401_attached;
 
263
  uart401_devc uart401devc;
 
264
}
 
265
cmpci_devc;
 
266
 
 
267
 
 
268
static void
 
269
set_spdif_rate (cmpci_devc * devc, cmpci_portc * portc)
 
270
{
 
271
  if (portc->speed == 48000)
 
272
    {
 
273
      /* setup MISC control reg */
 
274
      OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) | (1 << 24) | (1 << 15),
 
275
            MISC_CTRL);
 
276
    }
 
277
  else
 
278
    {
 
279
      OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) & ~(1 << 15),
 
280
            MISC_CTRL);
 
281
      OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) & ~(1 << 24),
 
282
            MISC_CTRL);
 
283
    }
 
284
}
 
285
 
 
286
static void
 
287
setup_ac3 (cmpci_devc * devc, cmpci_portc * portc, int value)
 
288
{
 
289
  if (value && (portc->speed == 48000 || portc->speed == 44100))
 
290
    {
 
291
      if (devc->chiprev == 37)
 
292
        {
 
293
          OUTL (devc->osdev, INL (devc->osdev, CHFORMAT) | (1 << 20),
 
294
                CHFORMAT);
 
295
        }
 
296
      else
 
297
        {
 
298
          /* Enable AC3 */
 
299
          OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) | (1 << 18),
 
300
                MISC_CTRL);
 
301
        }
 
302
    }
 
303
  else
 
304
    {
 
305
      if (devc->chiprev == 37)
 
306
        {
 
307
          OUTL (devc->osdev, INL (devc->osdev, CHFORMAT) & ~(1 << 20),
 
308
                CHFORMAT);
 
309
        }
 
310
      else
 
311
        {
 
312
          /* Disable AC3 */
 
313
          OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) & ~(1 << 18),
 
314
                MISC_CTRL);
 
315
        }
 
316
    }
 
317
}
 
318
 
 
319
 
 
320
static void
 
321
cmpci_setmixer (cmpci_devc * devc, unsigned int port, unsigned int value)
 
322
{
 
323
  oss_native_word flags;
 
324
  MUTEX_ENTER_IRQDISABLE (devc->low_mutex, flags);
 
325
  OUTB (devc->osdev, (unsigned char) (port & 0xff), MIXER_ADDR);
 
326
  oss_udelay (20);
 
327
  OUTB (devc->osdev, (unsigned char) (value & 0xff), MIXER_DATA);
 
328
  MUTEX_EXIT_IRQRESTORE (devc->low_mutex, flags);
 
329
  oss_udelay (20);
 
330
}
 
331
 
 
332
static unsigned int
 
333
cmpci_getmixer (cmpci_devc * devc, unsigned int port)
 
334
{
 
335
  unsigned int val;
 
336
 
 
337
  oss_native_word flags;
 
338
  MUTEX_ENTER_IRQDISABLE (devc->low_mutex, flags);
 
339
  OUTB (devc->osdev, (unsigned char) (port & 0xff), MIXER_ADDR);
 
340
 
 
341
 
 
342
  oss_udelay (20);
 
343
  val = INB (devc->osdev, MIXER_DATA);
 
344
  MUTEX_EXIT_IRQRESTORE (devc->low_mutex, flags);
 
345
  oss_udelay (20);
 
346
  return val;
 
347
}
 
348
 
 
349
struct mixer_def
 
350
{
 
351
  unsigned int regno:8;
 
352
  unsigned int bitoffs:4;
 
353
  unsigned int nbits:4;
 
354
};
 
355
 
 
356
typedef struct mixer_def mixer_tab[32][2];
 
357
typedef struct mixer_def mixer_ent;
 
358
 
 
359
#define MIX_ENT(name, reg_l, bit_l, len_l, reg_r, bit_r, len_r) \
 
360
        {{reg_l, bit_l, len_l}, {reg_r, bit_r, len_r}}
 
361
 
 
362
static mixer_tab cmpci_mix = {
 
363
  MIX_ENT (SOUND_MIXER_VOLUME, 0x30, 7, 5, 0x31, 7, 5),
 
364
  MIX_ENT (SOUND_MIXER_BASS, 0x46, 7, 4, 0x47, 7, 4),
 
365
  MIX_ENT (SOUND_MIXER_TREBLE, 0x44, 7, 4, 0x45, 7, 4),
 
366
  MIX_ENT (SOUND_MIXER_SYNTH, 0x34, 7, 5, 0x35, 7, 5),
 
367
  MIX_ENT (SOUND_MIXER_PCM, 0x32, 7, 5, 0x33, 7, 5),
 
368
  MIX_ENT (SOUND_MIXER_SPEAKER, 0x3b, 7, 2, 0x00, 0, 0),
 
369
  MIX_ENT (SOUND_MIXER_LINE, 0x38, 7, 5, 0x39, 7, 5),
 
370
  MIX_ENT (SOUND_MIXER_MIC, 0x3a, 7, 5, 0x00, 0, 0),
 
371
  MIX_ENT (SOUND_MIXER_CD, 0x36, 7, 5, 0x37, 7, 5),
 
372
  MIX_ENT (SOUND_MIXER_IMIX, 0x3c, 0, 1, 0x00, 0, 0),
 
373
  MIX_ENT (SOUND_MIXER_LINE1, 0, 0, 0, 0, 0, 0),
 
374
  MIX_ENT (SOUND_MIXER_RECLEV, 0x3f, 7, 2, 0x40, 7, 2),
 
375
  MIX_ENT (SOUND_MIXER_IGAIN, 0x3f, 7, 2, 0x40, 7, 2),
 
376
  MIX_ENT (SOUND_MIXER_OGAIN, 0x41, 7, 2, 0x42, 7, 2)
 
377
};
 
378
 
 
379
/*ARGSUSED*/
 
380
static void
 
381
change_bits (cmpci_devc * devc, unsigned char *regval, int dev, int chn,
 
382
             int newval)
 
383
{
 
384
  unsigned char mask;
 
385
  int shift;
 
386
 
 
387
  mask = (1 << cmpci_mix[dev][chn].nbits) - 1;
 
388
  newval = (int) ((newval * mask) + 50) / 100;  /* Scale */
 
389
 
 
390
  shift = cmpci_mix[dev][chn].bitoffs - cmpci_mix[dev][LEFT_CHN].nbits + 1;
 
391
 
 
392
  *regval &= ~(mask << shift);  /* Mask out previous value */
 
393
  *regval |= (newval & mask) << shift;  /* Set the new value */
 
394
}
 
395
 
 
396
static int set_recmask (int dev, int mask);
 
397
 
 
398
static int
 
399
cmpci_mixer_set (cmpci_devc * devc, int chan, int value)
 
400
{
 
401
  int left = value & 0x000000ff;
 
402
  int right = (value & 0x0000ff00) >> 8;
 
403
 
 
404
  int regoffs;
 
405
  unsigned char val;
 
406
 
 
407
  if (left > 100)
 
408
    left = 100;
 
409
  if (right > 100)
 
410
    right = 100;
 
411
 
 
412
  if (chan > 31)
 
413
    return OSS_EINVAL;
 
414
 
 
415
  if (!(CMEDIA_MIXER_DEVICES & (1 << chan)))    /*
 
416
                                                 * Not supported
 
417
                                                 */
 
418
    return OSS_EINVAL;
 
419
 
 
420
  regoffs = cmpci_mix[chan][LEFT_CHN].regno;
 
421
 
 
422
  if (regoffs == 0)
 
423
    return OSS_EINVAL;
 
424
 
 
425
  val = cmpci_getmixer (devc, regoffs);
 
426
  change_bits (devc, &val, chan, LEFT_CHN, left);
 
427
 
 
428
  devc->levels[chan] = left | (left << 8);
 
429
 
 
430
  if (cmpci_mix[chan][RIGHT_CHN].regno != regoffs)      /*
 
431
                                                         * Change register
 
432
                                                         */
 
433
    {
 
434
      cmpci_setmixer (devc, regoffs, val);      /*
 
435
                                                 * Save the old one
 
436
                                                 */
 
437
      regoffs = cmpci_mix[chan][RIGHT_CHN].regno;
 
438
 
 
439
      if (regoffs == 0)
 
440
        return left | (left << 8);      /*
 
441
                                         * Just left channel present
 
442
                                         */
 
443
 
 
444
      val = cmpci_getmixer (devc, regoffs);     /*
 
445
                                                 * Read the new one
 
446
                                                 */
 
447
    }
 
448
 
 
449
  change_bits (devc, &val, chan, RIGHT_CHN, right);
 
450
 
 
451
  cmpci_setmixer (devc, regoffs, val);
 
452
 
 
453
  devc->levels[chan] = left | (right << 8);
 
454
  return left | (right << 8);
 
455
}
 
456
 
 
457
static int cmpci_outsw (int dev, int ctrl, unsigned int cmd, int value);
 
458
 
 
459
/*ARGSUSED*/
 
460
static int
 
461
cmpci_mixer_ioctl (int dev, int audiodev, unsigned int cmd, ioctl_arg arg)
 
462
{
 
463
  cmpci_devc *devc = mixer_devs[dev]->devc;
 
464
  int val;
 
465
 
 
466
  if (((cmd >> 8) & 0xff) == 'M')
 
467
    {
 
468
      if (IOC_IS_OUTPUT (cmd))
 
469
        switch (cmd & 0xff)
 
470
          {
 
471
          case SOUND_MIXER_RECSRC:
 
472
            val = *arg;
 
473
            if (val == SOUND_MASK_LINE1)
 
474
              *arg = cmpci_outsw (dev, AUX_REC, SNDCTL_MIX_WRITE, 1);
 
475
            else
 
476
              *arg = cmpci_outsw (dev, AUX_REC, SNDCTL_MIX_WRITE, 0);
 
477
            return *arg = set_recmask (dev, val);
 
478
            break;
 
479
 
 
480
          case SOUND_MIXER_LINE1:
 
481
            val = *arg;
 
482
            return *arg = cmpci_outsw (dev, AUX_LEVEL, SNDCTL_MIX_WRITE, val);
 
483
            break;
 
484
 
 
485
          default:
 
486
            val = *arg;
 
487
            return *arg = cmpci_mixer_set (devc, cmd & 0xff, val);
 
488
          }
 
489
      else
 
490
        switch (cmd & 0xff)
 
491
          {
 
492
 
 
493
          case SOUND_MIXER_RECSRC:
 
494
            return *arg = devc->recmask;
 
495
            break;
 
496
 
 
497
          case SOUND_MIXER_DEVMASK:
 
498
            return *arg = CMEDIA_MIXER_DEVICES;
 
499
            break;
 
500
 
 
501
          case SOUND_MIXER_STEREODEVS:
 
502
            return *arg = CMEDIA_MIXER_DEVICES &
 
503
              ~(SOUND_MASK_MIC | SOUND_MASK_SPEAKER | SOUND_MASK_IMIX);
 
504
            break;
 
505
 
 
506
          case SOUND_MIXER_RECMASK:
 
507
            return *arg = CMEDIA_RECORDING_DEVICES;
 
508
            break;
 
509
 
 
510
          case SOUND_MIXER_LINE1:
 
511
            val = cmpci_outsw (dev, AUX_LEVEL, SNDCTL_MIX_READ, 0);
 
512
            return *arg = val;
 
513
            break;
 
514
 
 
515
          case SOUND_MIXER_CAPS:
 
516
            return *arg = SOUND_CAP_EXCL_INPUT;
 
517
            break;
 
518
 
 
519
          default:
 
520
            return *arg = devc->levels[cmd & 0x1f];
 
521
          }
 
522
    }
 
523
  else
 
524
    return OSS_EINVAL;
 
525
}
 
526
 
 
527
static int
 
528
set_recmask (int dev, int mask)
 
529
{
 
530
  cmpci_devc *devc = mixer_devs[dev]->devc;
 
531
  int devmask = mask & CMEDIA_RECORDING_DEVICES;
 
532
  int i;
 
533
  unsigned char regimageL, regimageR;
 
534
 
 
535
  if (!devmask)
 
536
    devmask = SOUND_MASK_MIC;
 
537
 
 
538
  regimageL = regimageR = 0;
 
539
  for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
 
540
    if ((1 << i) & devmask)
 
541
      {
 
542
        regimageL |= cmpci_recmasks_L[i];
 
543
        regimageR |= cmpci_recmasks_R[i];
 
544
      }
 
545
  cmpci_setmixer (devc, CMPCI_IMASK_L, regimageL);
 
546
  cmpci_setmixer (devc, CMPCI_IMASK_R, regimageR);
 
547
  devc->recmask = devmask;
 
548
  return devc->recmask;
 
549
}
 
550
 
 
551
static int
 
552
cmpci_outsw (int dev, int ctrl, unsigned int cmd, int value)
 
553
{
 
554
/*
 
555
 * Access function for CMPCI mixer extension bits
 
556
 */
 
557
  cmpci_devc *devc = mixer_devs[dev]->devc;
 
558
  int left, right, tmp;
 
559
 
 
560
  if (cmd == SNDCTL_MIX_READ)
 
561
    {
 
562
      value = 0;
 
563
      switch (ctrl)
 
564
        {
 
565
        case MUTE_LINE: /* Left line in to output connection */
 
566
          value = (cmpci_getmixer (devc, 0x3c) & 0x18) ? 0 : 1;
 
567
          break;
 
568
 
 
569
        case MUTE_CD:           /* Cd in to output connection */
 
570
          value = (cmpci_getmixer (devc, 0x3c) & 0x06) ? 0 : 1;
 
571
          break;
 
572
 
 
573
        case MUTE_MIC:          /* Mic in to output connection */
 
574
          value = (cmpci_getmixer (devc, 0x3c) & 0x01) ? 0 : 1;
 
575
          break;
 
576
 
 
577
        case MODE_4SPK: /* 4Speaker out */
 
578
          value = INL (devc->osdev, MISC_CTRL) & (1 << 26) ? 1 : 0;
 
579
          break;
 
580
 
 
581
        case DUALDAC:           /* dual dac */
 
582
          value = devc->dev_mode & DUALDAC_MODE ? 1 : 0;
 
583
          break;
 
584
 
 
585
        case REAR2LINE: /* rear to line in */
 
586
          value = INB (devc->osdev, MIXER1) & (1 << 5) ? 1 : 0;
 
587
          break;
 
588
 
 
589
        case CEN2LINE:          /* center to line in */
 
590
          value = INL (devc->osdev, LEGACY_CTRL) & (1 << 14) ? 1 : 0;
 
591
          break;
 
592
 
 
593
        case BASS2LINE: /* basss to line in */
 
594
          value = INL (devc->osdev, LEGACY_CTRL) & (1 << 13) ? 1 : 0;
 
595
          break;
 
596
 
 
597
        case SPDIF_PLAY:        /* spdif out */
 
598
          value = INL (devc->osdev, LEGACY_CTRL) & (1 << 23) ? 1 : 0;
 
599
          break;
 
600
 
 
601
        case SPDIF_LOOP:        /* S/PDIF I/O Loop */
 
602
          value = (INL (devc->osdev, FUNCTRL1) & (1 << 7)) ? 1 : 0;
 
603
          break;
 
604
 
 
605
        case SPDIF_REC: /* spdif record mode */
 
606
          value = devc->dev_mode & SPDIFIN_MODE ? 1 : 0;
 
607
          break;
 
608
 
 
609
        case SPDIF_IMON:        /* spdif input monitor */
 
610
          value = INB (devc->osdev, MIXER1) & 0x1 ? 1 : 0;
 
611
          break;
 
612
 
 
613
        case SPDIF_POL: /* spdif input reverse */
 
614
          if (devc->chiprev < 39)
 
615
            value = INB (devc->osdev, MIXER3) & 0x06 ? 1 : 0;
 
616
          else
 
617
            value = INL (devc->osdev, CHFORMAT) & 0x80 ? 1 : 0;
 
618
          break;
 
619
 
 
620
        case SPDIF_AC3: /* ac3 */
 
621
          value = INL (devc->osdev, MISC_CTRL) & (1 << 18) ? 1 : 0;
 
622
          break;
 
623
 
 
624
        case SPDIF_COPY:        /* copy protect (indirect) */
 
625
          value = INL (devc->osdev, LEGACY_CTRL) & (1 << 22) ? 1 : 0;
 
626
          break;
 
627
 
 
628
        case SPDIF_OPT: /* Coax/Optical Select */
 
629
          value = INL (devc->osdev, MISC_CTRL) & (1 << 25) ? 1 : 0;
 
630
          break;
 
631
 
 
632
        case CEN2MIC:           /* Center2MIC */
 
633
          if (devc->chiprev >= 39)
 
634
            value = INB (devc->osdev, MIXER3) & 0x4 ? 1 : 0;
 
635
          break;
 
636
 
 
637
        case MICBOOST:          /* MIC Boost */
 
638
          value = INB (devc->osdev, MIXER2) & 0x1 ? 0 : 1;
 
639
          break;
 
640
 
 
641
        case AUX_LEVEL:
 
642
          value = devc->levels[SOUND_MIXER_LINE1];
 
643
          break;
 
644
 
 
645
        case AUX_REC:           /* set LINE1 as rec source - handled by set_recmask */
 
646
          break;
 
647
 
 
648
        case MUTE_AUX:          /* AUX mute */
 
649
          value = INB (devc->osdev, MIXER2) & 0x30 ? 0 : 1;
 
650
          break;
 
651
 
 
652
        default:
 
653
          return OSS_EINVAL;
 
654
        }
 
655
 
 
656
      return value;
 
657
    }
 
658
 
 
659
  if (cmd == SNDCTL_MIX_WRITE)
 
660
    {
 
661
      switch (ctrl)
 
662
        {
 
663
        case MUTE_LINE: /* L/R line in to output connection */
 
664
          if (!value)
 
665
            cmpci_setmixer (devc, 0x3c, cmpci_getmixer (devc, 0x3c) | 0x18);
 
666
          else
 
667
            cmpci_setmixer (devc, 0x3c, cmpci_getmixer (devc, 0x3c) & ~0x18);
 
668
          break;
 
669
 
 
670
        case MUTE_CD:           /* Cd in to output connection */
 
671
          if (!value)
 
672
            cmpci_setmixer (devc, 0x3c, cmpci_getmixer (devc, 0x3c) | 0x06);
 
673
          else
 
674
            cmpci_setmixer (devc, 0x3c, cmpci_getmixer (devc, 0x3c) & ~0x06);
 
675
          break;
 
676
 
 
677
        case MUTE_MIC:          /* Mic in to output connection */
 
678
          if (!value)
 
679
            cmpci_setmixer (devc, 0x3c, cmpci_getmixer (devc, 0x3c) | 0x01);
 
680
          else
 
681
            cmpci_setmixer (devc, 0x3c, cmpci_getmixer (devc, 0x3c) & ~0x01);
 
682
          break;
 
683
 
 
684
        case MODE_4SPK: /* 4Speaker out */
 
685
          if (value)
 
686
            {
 
687
              OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) | (1 << 26),
 
688
                    MISC_CTRL);
 
689
              devc->mode_4spk = 1;
 
690
            }
 
691
          else
 
692
            OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) & ~(1 << 26),
 
693
                  MISC_CTRL);
 
694
          devc->mode_4spk = 0;
 
695
          break;
 
696
 
 
697
        case DUALDAC:           /* DUAL DAC mode */
 
698
          if (value)
 
699
            {
 
700
              OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) | (1 << 23),
 
701
                    MISC_CTRL);
 
702
              /* Disable 4Speaker mode */
 
703
              OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) & ~(1 << 26),
 
704
                    MISC_CTRL);
 
705
              devc->dev_mode = DUALDAC_MODE;
 
706
            }
 
707
          else
 
708
            {
 
709
              OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) & ~(1 << 23),
 
710
                    MISC_CTRL);
 
711
 
 
712
              /* enable back the 4Speaker mode */
 
713
              OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) | 1 << 26,
 
714
                    MISC_CTRL);
 
715
 
 
716
              devc->dev_mode = DEFAULT_MODE;
 
717
            }
 
718
          break;
 
719
 
 
720
        case REAR2LINE: /* REAR TO LINEIN */
 
721
          if (value)
 
722
            {
 
723
              OUTB (devc->osdev, (INB (devc->osdev, MIXER1) | (1 << 5)),
 
724
                    MIXER1);
 
725
            }
 
726
          else
 
727
            OUTB (devc->osdev, (INB (devc->osdev, MIXER1) & ~(1 << 5)),
 
728
                  MIXER1);
 
729
          break;
 
730
 
 
731
        case CEN2LINE:          /* CENTER TO LINEIN */
 
732
          if (value)
 
733
            {
 
734
              OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) | (1 << 14),
 
735
                    LEGACY_CTRL);
 
736
            }
 
737
          else
 
738
            OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) & ~(1 << 14),
 
739
                  LEGACY_CTRL);
 
740
          break;
 
741
 
 
742
        case BASS2LINE: /* BASS TO LINEIN */
 
743
          if (value)
 
744
            {
 
745
              OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) | (1 << 13),
 
746
                    LEGACY_CTRL);
 
747
            }
 
748
          else
 
749
            OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) & ~(1 << 13),
 
750
                  LEGACY_CTRL);
 
751
          break;
 
752
 
 
753
        case SPDIF_PLAY:        /* SPDIF ENABLE */
 
754
          if (value)
 
755
            {
 
756
              OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) | (1 << 23),
 
757
                    LEGACY_CTRL);
 
758
 
 
759
              /* enable wave/fm/midi to spdif OUT DAC2SPDO on rev 33/37 */
 
760
              if (devc->chiprev < 39)
 
761
                OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) | (1 << 21),
 
762
                      LEGACY_CTRL);
 
763
              devc->spdif_enabled = 1;
 
764
            }
 
765
          else
 
766
            {
 
767
              OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) & ~(1 << 23),
 
768
                    LEGACY_CTRL);
 
769
              /* Disable wave/fm/midi to spdif OUT (DAC2SPDO) */
 
770
              if (devc->chiprev < 39)
 
771
                OUTL (devc->osdev,
 
772
                      INL (devc->osdev, LEGACY_CTRL) & ~(1 << 21),
 
773
                      LEGACY_CTRL);
 
774
              devc->spdif_enabled = 0;
 
775
            }
 
776
          break;
 
777
 
 
778
        case SPDIF_LOOP:        /* S/PDIF I/O Loop */
 
779
          if (value)
 
780
            {
 
781
              OUTL (devc->osdev, INL (devc->osdev, FUNCTRL1) | (1 << 7),
 
782
                    FUNCTRL1);
 
783
            }
 
784
          else
 
785
            OUTL (devc->osdev, INL (devc->osdev, FUNCTRL1) & ~(1 << 7),
 
786
                  FUNCTRL1);
 
787
          break;
 
788
 
 
789
        case SPDIF_REC: /* SPDIF Record Mode */
 
790
          if (value)
 
791
            {
 
792
              devc->dev_mode = SPDIFIN_MODE;
 
793
            }
 
794
          else
 
795
            devc->dev_mode = DEFAULT_MODE;
 
796
          break;
 
797
 
 
798
        case SPDIF_IMON:        /*  spdif monitor */
 
799
          if (value)
 
800
            {
 
801
              OUTB (devc->osdev, INB (devc->osdev, MIXER1) | 0x0D, MIXER1);
 
802
            }
 
803
          else
 
804
            OUTB (devc->osdev, INB (devc->osdev, MIXER1) & ~0xD, MIXER1);
 
805
          break;
 
806
 
 
807
        case SPDIF_POL: /* spdif reverse */
 
808
          if (value)
 
809
            {
 
810
              if (devc->chiprev < 39)
 
811
                {
 
812
                  OUTB (devc->osdev, INB (devc->osdev, MIXER3) | 0x06,
 
813
                        MIXER3);
 
814
                }
 
815
              else
 
816
                OUTL (devc->osdev, INL (devc->osdev, CHFORMAT) | 0x80,
 
817
                      CHFORMAT);
 
818
            }
 
819
          else
 
820
            {
 
821
              if (devc->chiprev < 39)
 
822
                {
 
823
                  OUTB (devc->osdev, INB (devc->osdev, MIXER3) & ~0x06,
 
824
                        MIXER3);
 
825
                }
 
826
              else
 
827
                OUTL (devc->osdev, INL (devc->osdev, CHFORMAT) & ~0x80,
 
828
                      CHFORMAT);
 
829
            }
 
830
          break;
 
831
 
 
832
        case SPDIF_AC3: /* AC3 enabled on S/PDIF */
 
833
          if (value)
 
834
            {
 
835
              OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) | (1 << 18),
 
836
                    MISC_CTRL);
 
837
            }
 
838
          else
 
839
            OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) & ~(1 << 18),
 
840
                  MISC_CTRL);
 
841
          break;
 
842
 
 
843
        case SPDIF_COPY:        /* Copy protect */
 
844
          if (value)
 
845
            {
 
846
              OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) | (1 << 22),
 
847
                    LEGACY_CTRL);
 
848
            }
 
849
          else
 
850
            OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) & ~(1 << 22),
 
851
                  LEGACY_CTRL);
 
852
          break;
 
853
 
 
854
        case SPDIF_OPT: /* Coax/Optical */
 
855
          if (value)
 
856
            {
 
857
              OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) | (1 << 25),
 
858
                    MISC_CTRL);
 
859
            }
 
860
          else
 
861
            OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) & ~(1 << 25),
 
862
                  MISC_CTRL);
 
863
          break;
 
864
 
 
865
        case CEN2MIC:           /* Center -> Mic OUT */
 
866
          if (value)
 
867
            {
 
868
              if (devc->chiprev >= 39)
 
869
                {
 
870
                  OUTB (devc->osdev, INB (devc->osdev, MIXER3) | 0x4, MIXER3);
 
871
                }
 
872
            }
 
873
          else if (devc->chiprev >= 39)
 
874
            {
 
875
              OUTB (devc->osdev, INB (devc->osdev, MIXER3) & ~0x4, MIXER3);
 
876
            }
 
877
          break;
 
878
 
 
879
        case MICBOOST:          /* Mic Boost */
 
880
          if (!value)
 
881
            {
 
882
              OUTB (devc->osdev, INB (devc->osdev, MIXER2) | 0x1, MIXER2);
 
883
            }
 
884
          else
 
885
            OUTB (devc->osdev, INB (devc->osdev, MIXER2) & ~0x1, MIXER2);
 
886
          break;
 
887
 
 
888
        case AUX_LEVEL: /* Aux levels */
 
889
          left = value & 0xff;
 
890
          right = (value >> 8) & 0xff;
 
891
          if (left > 100)
 
892
            left = 100;
 
893
          if (right > 100)
 
894
            right = 100;
 
895
          value = left | (right << 8);
 
896
          left = mix_cvt[left];
 
897
          right = mix_cvt[right];
 
898
 
 
899
          tmp = ((right * ((1 << 4) - 1) / 100) << 4) |
 
900
            (left * ((1 << 4) - 1) / 100);
 
901
 
 
902
          OUTB (devc->osdev, tmp, AUX_VOL);
 
903
          devc->levels[SOUND_MIXER_LINE1] = value;
 
904
          break;
 
905
 
 
906
        case AUX_REC:           /* line1 record select */
 
907
          if (value)
 
908
            {
 
909
              OUTB (devc->osdev, INB (devc->osdev, MIXER2) | 0xc0, MIXER2);
 
910
            }
 
911
          else
 
912
            OUTB (devc->osdev, INB (devc->osdev, MIXER2) & ~0xc0, MIXER2);
 
913
          break;
 
914
 
 
915
        case MUTE_AUX:          /* line1 mute control */
 
916
          if (!value)
 
917
            {
 
918
              OUTB (devc->osdev, INB (devc->osdev, MIXER2) | 0x30, MIXER2);
 
919
            }
 
920
          else
 
921
            OUTB (devc->osdev, INB (devc->osdev, MIXER2) & ~0x30, MIXER2);
 
922
          break;
 
923
 
 
924
        default:
 
925
          return OSS_EINVAL;
 
926
        }
 
927
 
 
928
      return (value);
 
929
    }
 
930
  return OSS_EINVAL;
 
931
}
 
932
 
 
933
static int
 
934
cmpci_mix_init (int dev)
 
935
{
 
936
  int group, err;
 
937
 
 
938
  if ((group = mixer_ext_create_group (dev, 0, "CMPCI_MUTECTL")) < 0)
 
939
    return group;
 
940
 
 
941
  if ((err =
 
942
       mixer_ext_create_control (dev, group, MUTE_LINE, cmpci_outsw,
 
943
                                 MIXT_ONOFF, "CMPCI_LINEMUTE", 1,
 
944
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
945
    return err;
 
946
 
 
947
  if ((err =
 
948
       mixer_ext_create_control (dev, group, MUTE_CD, cmpci_outsw, MIXT_ONOFF,
 
949
                                 "CMPCI_CDMUTE", 1,
 
950
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
951
    return err;
 
952
 
 
953
  if ((err =
 
954
       mixer_ext_create_control (dev, group, MUTE_MIC, cmpci_outsw,
 
955
                                 MIXT_ONOFF, "CMPCI_MICMUTE", 1,
 
956
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
957
    return err;
 
958
 
 
959
  if ((err =
 
960
       mixer_ext_create_control (dev, group, MUTE_AUX, cmpci_outsw,
 
961
                                 MIXT_ONOFF, "CMPCI_LINE1MUTE", 1,
 
962
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
963
    return err;
 
964
 
 
965
  if ((group = mixer_ext_create_group (dev, 0, "CMPCI_JACKCTL")) < 0)
 
966
    return group;
 
967
  if ((err =
 
968
       mixer_ext_create_control (dev, group, REAR2LINE, cmpci_outsw,
 
969
                                 MIXT_ONOFF, "CMPCI_REAR2LINE", 1,
 
970
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
971
    return err;
 
972
  if ((err =
 
973
       mixer_ext_create_control (dev, group, CEN2LINE, cmpci_outsw,
 
974
                                 MIXT_ONOFF, "CMPCI_CEN2LINE", 1,
 
975
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
976
    return err;
 
977
  if ((err =
 
978
       mixer_ext_create_control (dev, group, BASS2LINE, cmpci_outsw,
 
979
                                 MIXT_ONOFF, "CMPCI_BASS2LINE", 1,
 
980
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
981
    return err;
 
982
 
 
983
  if ((err =
 
984
       mixer_ext_create_control (dev, group, CEN2MIC, cmpci_outsw, MIXT_ONOFF,
 
985
                                 "CMPCI_CEN2MIC", 1,
 
986
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
987
    return err;
 
988
 
 
989
 
 
990
  if ((group = mixer_ext_create_group (dev, 0, "CMPCI_MIXEXT")) < 0)
 
991
    return group;
 
992
 
 
993
  if ((err =
 
994
       mixer_ext_create_control (dev, group, MODE_4SPK, cmpci_outsw,
 
995
                                 MIXT_ENUM, "CMPCI_SPKMODE", 2,
 
996
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
997
    return err;
 
998
 
 
999
  if ((err =
 
1000
       mixer_ext_create_control (dev, group, DUALDAC, cmpci_outsw, MIXT_ONOFF,
 
1001
                                 "CMPCI_DUALDAC", 1,
 
1002
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
1003
    return err;
 
1004
 
 
1005
  if ((err =
 
1006
       mixer_ext_create_control (dev, group, MICBOOST, cmpci_outsw,
 
1007
                                 MIXT_ONOFF, "CMPCI_MICBOOST", 1,
 
1008
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
1009
    return err;
 
1010
 
 
1011
  /* Create a new SPDIF group */
 
1012
  if ((group = mixer_ext_create_group (dev, 0, "CMPCI_SPDIF")) < 0)
 
1013
    return group;
 
1014
 
 
1015
  if ((err =
 
1016
       mixer_ext_create_control (dev, group, SPDIF_PLAY, cmpci_outsw,
 
1017
                                 MIXT_ONOFF, "CMPCI_Play", 1,
 
1018
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
1019
    return err;
 
1020
 
 
1021
  if ((err =
 
1022
       mixer_ext_create_control (dev, group, SPDIF_LOOP, cmpci_outsw,
 
1023
                                 MIXT_ONOFF, "CMPCI_LOOP", 1,
 
1024
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
1025
    return err;
 
1026
 
 
1027
  /* Having this in mixer doesn't make any sense */
 
1028
  if ((err =
 
1029
       mixer_ext_create_control (dev, group, SPDIF_REC, cmpci_outsw,
 
1030
                                 MIXT_ONOFF, "CMPCI_RECORD", 1,
 
1031
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
1032
    return err;
 
1033
 
 
1034
  if ((err =
 
1035
       mixer_ext_create_control (dev, group, SPDIF_IMON, cmpci_outsw,
 
1036
                                 MIXT_ONOFF, "CMPCI_IMON", 1,
 
1037
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
1038
    return err;
 
1039
 
 
1040
  if ((err =
 
1041
       mixer_ext_create_control (dev, group, SPDIF_POL, cmpci_outsw,
 
1042
                                 MIXT_ONOFF, "CMPCI_POLREV", 1,
 
1043
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
1044
    return err;
 
1045
 
 
1046
#if 0
 
1047
  /* Having this in mixer doesn't make any sense */
 
1048
  if ((err =
 
1049
       mixer_ext_create_control (dev, group, SPDIF_AC3, cmpci_outsw,
 
1050
                                 MIXT_ONOFF, "CMPCI_AC3", 1,
 
1051
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
1052
    return err;
 
1053
#endif
 
1054
 
 
1055
  if ((err =
 
1056
       mixer_ext_create_control (dev, group, SPDIF_COPY, cmpci_outsw,
 
1057
                                 MIXT_ONOFF, "CMPCI_COPYPROT", 1,
 
1058
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
1059
    return err;
 
1060
 
 
1061
  if ((err =
 
1062
       mixer_ext_create_control (dev, group, SPDIF_OPT, cmpci_outsw,
 
1063
                                 MIXT_ONOFF, "CMPCI_OPTICAL", 1,
 
1064
                                 MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
1065
    return err;
 
1066
 
 
1067
  return 0;
 
1068
}
 
1069
 
 
1070
static void
 
1071
cmpci_mixer_reset (int dev)
 
1072
{
 
1073
  int i;
 
1074
  cmpci_devc *devc = mixer_devs[dev]->devc;
 
1075
 
 
1076
  devc->levels = load_mixer_volumes ("CM8738_Mixer", default_levels, 1);
 
1077
  devc->recmask = 0;
 
1078
 
 
1079
  for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
 
1080
    cmpci_mixer_set (devc, i, devc->levels[i]);
 
1081
 
 
1082
  set_recmask (dev, SOUND_MASK_MIC);
 
1083
}
 
1084
 
 
1085
 
 
1086
static mixer_driver_t cmpci_mixer_driver = {
 
1087
  cmpci_mixer_ioctl
 
1088
};
 
1089
 
 
1090
 
 
1091
static int
 
1092
cmpciintr (oss_device_t * osdev)
 
1093
{
 
1094
  cmpci_devc *devc = (cmpci_devc *) osdev->devc;
 
1095
  unsigned int intstat, intsrc;
 
1096
  int i;
 
1097
  int serviced = 0;
 
1098
 
 
1099
  /* see if this is our interrupt */
 
1100
  intsrc = INL (devc->osdev, INT_STATUS);
 
1101
  if (intsrc & (CM_CH0_INT | CM_CH1_INT))
 
1102
    {
 
1103
      /* Handle playback */
 
1104
      serviced = 1;
 
1105
 
 
1106
      intstat = INB (devc->osdev, INT_HLDCLR + 2);
 
1107
 
 
1108
      for (i = 0; i < MAX_PORTC; i++)
 
1109
        {
 
1110
          cmpci_portc *portc = &devc->portc[i];
 
1111
 
 
1112
          if (intstat & CM_CH1_INT)
 
1113
            {
 
1114
              /* do chan1 playback */
 
1115
              if ((portc->chan1_play) &&
 
1116
                  (portc->trigger_bits & PCM_ENABLE_OUTPUT))
 
1117
                {
 
1118
                  OUTB (devc->osdev, intstat & ~CM_CH1_INT, INT_HLDCLR + 2);
 
1119
                  OUTB (devc->osdev, intstat | CM_CH1_INT, INT_HLDCLR + 2);
 
1120
                  oss_audio_outputintr (portc->audiodev, 0);
 
1121
                }
 
1122
 
 
1123
              /* do chan1 record */
 
1124
              if ((portc->chan1_rec) &&
 
1125
                  (portc->trigger_bits & PCM_ENABLE_INPUT))
 
1126
                {
 
1127
                  OUTB (devc->osdev, intstat & ~CM_CH1_INT, INT_HLDCLR + 2);
 
1128
                  OUTB (devc->osdev, intstat | CM_CH1_INT, INT_HLDCLR + 2);
 
1129
                  oss_audio_inputintr (portc->audiodev, 0);
 
1130
                }
 
1131
            }
 
1132
 
 
1133
          if (intstat & CM_CH0_INT)
 
1134
            {
 
1135
              /* do chan0 playback */
 
1136
              if ((portc->chan0_play) &&
 
1137
                  (portc->trigger_bits & PCM_ENABLE_OUTPUT))
 
1138
                {
 
1139
                  OUTB (devc->osdev, intstat & ~CM_CH0_INT, INT_HLDCLR + 2);
 
1140
                  OUTB (devc->osdev, intstat | CM_CH0_INT, INT_HLDCLR + 2);
 
1141
                  oss_audio_outputintr (portc->audiodev, 0);
 
1142
                }
 
1143
 
 
1144
              /* do chan0 record */
 
1145
              if ((portc->chan0_rec) &&
 
1146
                  (portc->trigger_bits & PCM_ENABLE_INPUT))
 
1147
                {
 
1148
                  OUTB (devc->osdev, intstat & ~CM_CH0_INT, INT_HLDCLR + 2);
 
1149
                  OUTB (devc->osdev, intstat | CM_CH0_INT, INT_HLDCLR + 2);
 
1150
                  oss_audio_inputintr (portc->audiodev, 0);
 
1151
                }
 
1152
            }
 
1153
        }
 
1154
    }
 
1155
 
 
1156
  if (intsrc & 0x10000)
 
1157
    {
 
1158
      serviced = 1;
 
1159
      uart401_irq (&devc->uart401devc);
 
1160
    }
 
1161
 
 
1162
  return serviced;
 
1163
}
 
1164
 
 
1165
static int
 
1166
cmpci_audio_set_rate (int dev, int arg)
 
1167
{
 
1168
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1169
 
 
1170
  if (arg == 0)
 
1171
    return portc->speed;
 
1172
 
 
1173
  if (arg > 48000)
 
1174
    arg = 48000;
 
1175
  if (arg < 5000)
 
1176
    arg = 5000;
 
1177
  portc->speed = arg;
 
1178
  return portc->speed;
 
1179
}
 
1180
 
 
1181
static short
 
1182
cmpci_audio_set_channels (int dev, short arg)
 
1183
{
 
1184
  cmpci_devc *devc = audio_engines[dev]->devc;
 
1185
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1186
 
 
1187
  if (devc->model == MDL_CM8768)
 
1188
    {
 
1189
      if (arg>8)
 
1190
         arg=8;
 
1191
 
 
1192
      if ((arg != 1) && (arg != 2) && (arg != 4) && (arg != 6) && (arg != 8))
 
1193
        return portc->channels;
 
1194
    }
 
1195
  else
 
1196
    {
 
1197
      if (arg>6)
 
1198
         arg=6;
 
1199
 
 
1200
      if ((arg != 1) && (arg != 2) && (arg != 4) && (arg != 6))
 
1201
        return portc->channels;
 
1202
    }
 
1203
  portc->channels = arg;
 
1204
 
 
1205
  return portc->channels;
 
1206
}
 
1207
 
 
1208
static unsigned int
 
1209
cmpci_audio_set_format (int dev, unsigned int arg)
 
1210
{
 
1211
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1212
 
 
1213
  if (arg == 0)
 
1214
    return portc->bits;
 
1215
 
 
1216
  if (!(arg & (AFMT_U8 | AFMT_S16_LE | AFMT_AC3)))
 
1217
    return portc->bits;
 
1218
  portc->bits = arg;
 
1219
 
 
1220
  return portc->bits;
 
1221
}
 
1222
 
 
1223
/*ARGSUSED*/
 
1224
static int
 
1225
cmpci_audio_ioctl (int dev, unsigned int cmd, ioctl_arg arg)
 
1226
{
 
1227
  return OSS_EINVAL;
 
1228
}
 
1229
 
 
1230
static void cmpci_audio_trigger (int dev, int state);
 
1231
 
 
1232
static void
 
1233
cmpci_audio_reset (int dev)
 
1234
{
 
1235
  cmpci_audio_trigger (dev, 0);
 
1236
}
 
1237
 
 
1238
static void
 
1239
cmpci_audio_reset_input (int dev)
 
1240
{
 
1241
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1242
  cmpci_audio_trigger (dev, portc->trigger_bits & ~PCM_ENABLE_INPUT);
 
1243
}
 
1244
 
 
1245
static void
 
1246
cmpci_audio_reset_output (int dev)
 
1247
{
 
1248
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1249
  cmpci_audio_trigger (dev, portc->trigger_bits & ~PCM_ENABLE_OUTPUT);
 
1250
}
 
1251
 
 
1252
/*ARGSUSED*/
 
1253
static int
 
1254
cmpci_audio_open (int dev, int mode, int open_flags)
 
1255
{
 
1256
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1257
  cmpci_devc *devc = audio_engines[dev]->devc;
 
1258
  oss_native_word flags;
 
1259
 
 
1260
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
1261
  if (portc->open_mode)
 
1262
    {
 
1263
      MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
1264
      return OSS_EBUSY;
 
1265
    }
 
1266
 
 
1267
  if (!(devc->dev_mode & DUALDAC_MODE))
 
1268
    {
 
1269
      if (devc->open_mode & mode)
 
1270
        {
 
1271
          MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
1272
          return OSS_EBUSY;
 
1273
        }
 
1274
 
 
1275
      devc->open_mode |= mode;
 
1276
    }
 
1277
  portc->open_mode = mode;
 
1278
  portc->audio_enabled &= ~mode;
 
1279
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
1280
  return 0;
 
1281
}
 
1282
 
 
1283
static void
 
1284
cmpci_audio_close (int dev, int mode)
 
1285
{
 
1286
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1287
  cmpci_devc *devc = audio_engines[dev]->devc;
 
1288
 
 
1289
  cmpci_audio_reset (dev);
 
1290
  portc->open_mode = 0;
 
1291
  devc->open_mode &= ~mode;
 
1292
  portc->audio_enabled &= ~mode;
 
1293
 
 
1294
  if ((devc->spdif_enabled) || (devc->dev_mode & SPDIFIN_MODE))
 
1295
    OUTL (devc->osdev, INL (devc->osdev, FUNCTRL1) & ~(1 << 9), FUNCTRL1);
 
1296
 
 
1297
  if (portc->chan0_play)
 
1298
    portc->chan0_play = 0;
 
1299
 
 
1300
  if (portc->chan1_play)
 
1301
    portc->chan1_play = 0;
 
1302
 
 
1303
  if (portc->chan0_rec)
 
1304
    portc->chan0_rec = 0;
 
1305
 
 
1306
  if (portc->chan1_rec)
 
1307
    portc->chan1_rec = 0;
 
1308
}
 
1309
 
 
1310
/*ARGSUSED*/
 
1311
static void
 
1312
cmpci_audio_output_block (int dev, oss_native_word buf, int count,
 
1313
                          int fragsize, int intrflag)
 
1314
{
 
1315
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1316
 
 
1317
  portc->audio_enabled |= PCM_ENABLE_OUTPUT;
 
1318
  portc->trigger_bits &= ~PCM_ENABLE_OUTPUT;
 
1319
}
 
1320
 
 
1321
/*ARGSUSED*/
 
1322
static void
 
1323
cmpci_audio_start_input (int dev, oss_native_word buf, int count,
 
1324
                         int fragsize, int intrflag)
 
1325
{
 
1326
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1327
 
 
1328
  portc->audio_enabled |= PCM_ENABLE_INPUT;
 
1329
  portc->trigger_bits &= ~PCM_ENABLE_INPUT;
 
1330
}
 
1331
 
 
1332
static void
 
1333
cmpci_audio_trigger (int dev, int state)
 
1334
{
 
1335
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1336
  cmpci_devc *devc = audio_engines[dev]->devc;
 
1337
  oss_native_word flags;
 
1338
 
 
1339
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
1340
  if (portc->open_mode & OPEN_WRITE)
 
1341
    {
 
1342
      if (state & PCM_ENABLE_OUTPUT)
 
1343
        {
 
1344
          if ((portc->audio_enabled & PCM_ENABLE_OUTPUT) &&
 
1345
              !(portc->trigger_bits & PCM_ENABLE_OUTPUT))
 
1346
            {
 
1347
              if (portc->chan0_play)
 
1348
                {
 
1349
                  /* enable the channel0 */
 
1350
                  OUTB (devc->osdev,
 
1351
                        INB (devc->osdev, FUNCTRL0 + 2) | CM_CH0_ENABLE,
 
1352
                        FUNCTRL0 + 2);
 
1353
                  OUTB (devc->osdev,
 
1354
                        INB (devc->osdev, INT_HLDCLR + 2) | CM_CH0_INT,
 
1355
                        INT_HLDCLR + 2);
 
1356
                }
 
1357
 
 
1358
              if (portc->chan1_play)
 
1359
                {
 
1360
                  /* enable the channel1 */
 
1361
                  OUTB (devc->osdev,
 
1362
                        INB (devc->osdev, FUNCTRL0 + 2) | CM_CH1_ENABLE,
 
1363
                        FUNCTRL0 + 2);
 
1364
                  OUTB (devc->osdev,
 
1365
                        INB (devc->osdev, INT_HLDCLR + 2) | CM_CH1_INT,
 
1366
                        INT_HLDCLR + 2);
 
1367
                }
 
1368
              portc->trigger_bits |= PCM_ENABLE_OUTPUT;
 
1369
            }
 
1370
        }
 
1371
      else
 
1372
        {
 
1373
          if ((portc->audio_enabled & PCM_ENABLE_OUTPUT) &&
 
1374
              (portc->trigger_bits & PCM_ENABLE_OUTPUT))
 
1375
            {
 
1376
              portc->audio_enabled &= ~PCM_ENABLE_OUTPUT;
 
1377
              portc->trigger_bits &= ~PCM_ENABLE_OUTPUT;
 
1378
 
 
1379
              if (portc->chan0_play)
 
1380
                {
 
1381
                  /* disable interrupt */
 
1382
                  OUTB (devc->osdev,
 
1383
                        INB (devc->osdev, INT_HLDCLR + 2) & ~CM_CH0_INT,
 
1384
                        INT_HLDCLR + 2);
 
1385
 
 
1386
                  /* disable channel0 */
 
1387
                  OUTB (devc->osdev,
 
1388
                        INB (devc->osdev, FUNCTRL0 + 2) & ~CM_CH0_ENABLE,
 
1389
                        FUNCTRL0 + 2);
 
1390
                }
 
1391
              if (portc->chan1_play)
 
1392
                {
 
1393
                  /* disable interrupt */
 
1394
                  OUTB (devc->osdev,
 
1395
                        INB (devc->osdev, INT_HLDCLR + 2) & ~CM_CH1_INT,
 
1396
                        INT_HLDCLR + 2);
 
1397
 
 
1398
                  /* disable channel */
 
1399
                  OUTB (devc->osdev,
 
1400
                        INB (devc->osdev, FUNCTRL0 + 2) & ~CM_CH1_ENABLE,
 
1401
                        FUNCTRL0 + 2);
 
1402
                }
 
1403
            }
 
1404
        }
 
1405
    }
 
1406
 
 
1407
  if (portc->open_mode & OPEN_READ)
 
1408
    {
 
1409
      if (state & PCM_ENABLE_INPUT)
 
1410
        {
 
1411
          if ((portc->audio_enabled & PCM_ENABLE_INPUT) &&
 
1412
              !(portc->trigger_bits & PCM_ENABLE_INPUT))
 
1413
            {
 
1414
              if (portc->chan1_rec)
 
1415
                {
 
1416
                  /* enable the channel1 */
 
1417
                  OUTB (devc->osdev,
 
1418
                        INB (devc->osdev, FUNCTRL0 + 2) | CM_CH1_ENABLE,
 
1419
                        FUNCTRL0 + 2);
 
1420
                  OUTB (devc->osdev,
 
1421
                        INB (devc->osdev, INT_HLDCLR + 2) | CM_CH1_INT,
 
1422
                        INT_HLDCLR + 2);
 
1423
                }
 
1424
              if (portc->chan0_rec)
 
1425
                {
 
1426
                  /* enable the channel0 */
 
1427
                  OUTB (devc->osdev,
 
1428
                        INB (devc->osdev, FUNCTRL0 + 2) | CM_CH0_ENABLE,
 
1429
                        FUNCTRL0 + 2);
 
1430
                  OUTB (devc->osdev,
 
1431
                        INB (devc->osdev, INT_HLDCLR + 2) | CM_CH0_INT,
 
1432
                        INT_HLDCLR + 2);
 
1433
                }
 
1434
              portc->trigger_bits |= PCM_ENABLE_INPUT;
 
1435
            }
 
1436
        }
 
1437
      else
 
1438
        {
 
1439
          if ((portc->audio_enabled & PCM_ENABLE_INPUT) &&
 
1440
              (portc->trigger_bits & PCM_ENABLE_INPUT))
 
1441
            {
 
1442
              portc->trigger_bits &= ~PCM_ENABLE_INPUT;
 
1443
              portc->audio_enabled &= ~PCM_ENABLE_INPUT;
 
1444
              if (portc->chan1_rec)
 
1445
                {
 
1446
                  /* disable interrupt */
 
1447
                  OUTB (devc->osdev,
 
1448
                        INB (devc->osdev, INT_HLDCLR + 2) & ~CM_CH1_INT,
 
1449
                        INT_HLDCLR + 2);
 
1450
 
 
1451
                  /* disable channel 1 */
 
1452
                  OUTB (devc->osdev,
 
1453
                        INB (devc->osdev, FUNCTRL0 + 2) & ~CM_CH1_ENABLE,
 
1454
                        FUNCTRL0 + 2);
 
1455
                }
 
1456
              if (portc->chan0_rec)
 
1457
                {
 
1458
                  /* disable interrupt */
 
1459
                  OUTB (devc->osdev,
 
1460
                        INB (devc->osdev, INT_HLDCLR + 2) & ~CM_CH0_INT,
 
1461
                        INT_HLDCLR + 2);
 
1462
 
 
1463
                  /* disable channel 0 */
 
1464
                  OUTB (devc->osdev,
 
1465
                        INB (devc->osdev, FUNCTRL0 + 2) & ~CM_CH0_ENABLE,
 
1466
                        FUNCTRL0 + 2);
 
1467
 
 
1468
                }
 
1469
            }
 
1470
        }
 
1471
    }
 
1472
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
1473
}
 
1474
 
 
1475
static void
 
1476
set_dac_rate (int dev, int chan_type)
 
1477
{
 
1478
  cmpci_devc *devc = audio_engines[dev]->devc;
 
1479
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1480
  unsigned char freq = 4, val;
 
1481
  int i;
 
1482
  int rate = portc->speed;
 
1483
 
 
1484
  if (rate > 48000)
 
1485
    rate = 48000;
 
1486
  if (rate < 5512)
 
1487
    rate = 5512;
 
1488
 
 
1489
  for (i = 0; i < sizeof (rate_lookup) / sizeof (rate_lookup[0]); i++)
 
1490
    {
 
1491
      if (rate > rate_lookup[i].lower && rate <= rate_lookup[i].upper)
 
1492
        {
 
1493
          rate = rate_lookup[i].rate;
 
1494
          freq = rate_lookup[i].freq;
 
1495
          break;
 
1496
        }
 
1497
    }
 
1498
  if (chan_type == CHAN0)
 
1499
    {
 
1500
      val = INB (devc->osdev, FUNCTRL1 + 1) & ~0x1c;
 
1501
      OUTB (devc->osdev, val | freq << 2, FUNCTRL1 + 1);
 
1502
    }
 
1503
  else
 
1504
    {
 
1505
      val = INB (devc->osdev, FUNCTRL1 + 1) & ~0xe0;
 
1506
      OUTB (devc->osdev, val | freq << 5, FUNCTRL1 + 1);
 
1507
    }
 
1508
  if (devc->spdif_enabled)
 
1509
    set_spdif_rate (devc, portc);
 
1510
}
 
1511
 
 
1512
static void
 
1513
set_dac_fmt (int dev, int chan_type)
 
1514
{
 
1515
  unsigned char val;
 
1516
  cmpci_devc *devc = audio_engines[dev]->devc;
 
1517
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1518
  int channels = portc->channels;
 
1519
  int bits = portc->bits;
 
1520
 
 
1521
  if (chan_type == CHAN0)
 
1522
    {
 
1523
      /* Set the format on Channl 0 */
 
1524
      val = INB (devc->osdev, CHFORMAT) & ~0x3;
 
1525
 
 
1526
      if ((channels == 1) && (bits == 8))
 
1527
        {
 
1528
          OUTB (devc->osdev, 0x00 | val, CHFORMAT);
 
1529
          portc->dacfmt = 0;
 
1530
        }
 
1531
 
 
1532
      if ((channels == 2) && (bits == 8))
 
1533
        {
 
1534
          OUTB (devc->osdev, 0x01 | val, CHFORMAT);
 
1535
          portc->dacfmt = 1;
 
1536
        }
 
1537
 
 
1538
      if ((channels == 1) && (bits == 16))
 
1539
        {
 
1540
          OUTB (devc->osdev, 0x02 | val, CHFORMAT);
 
1541
          portc->dacfmt = 1;
 
1542
        }
 
1543
 
 
1544
      if ((channels > 1) && (bits == 16))
 
1545
        {
 
1546
          OUTB (devc->osdev, 0x03 | val, CHFORMAT);
 
1547
          portc->dacfmt = 2;
 
1548
        }
 
1549
    }
 
1550
  else
 
1551
    {
 
1552
      /* Set the format on Channel 1 */
 
1553
      val = INB (devc->osdev, CHFORMAT) & ~0xC;
 
1554
 
 
1555
      if ((channels == 1) && (bits == 8))
 
1556
        {
 
1557
          OUTB (devc->osdev, 0x00 | val, CHFORMAT);
 
1558
          portc->dacfmt = 0;
 
1559
        }
 
1560
 
 
1561
      if ((channels == 2) && (bits == 8))
 
1562
        {
 
1563
          OUTB (devc->osdev, 0x04 | val, CHFORMAT);
 
1564
          portc->dacfmt = 1;
 
1565
        }
 
1566
 
 
1567
      if ((channels == 1) && (bits == 16))
 
1568
        {
 
1569
          OUTB (devc->osdev, 0x08 | val, CHFORMAT);
 
1570
          portc->dacfmt = 1;
 
1571
        }
 
1572
 
 
1573
      if ((channels > 1) && (bits == 16))
 
1574
        {
 
1575
          OUTB (devc->osdev, 0x0C | val, CHFORMAT);
 
1576
          portc->dacfmt = 2;
 
1577
        }
 
1578
    }
 
1579
}
 
1580
 
 
1581
 
 
1582
static void
 
1583
set_adc_rate (int dev, int chan_type)
 
1584
{
 
1585
  cmpci_devc *devc = audio_engines[dev]->devc;
 
1586
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1587
  unsigned char freq = 4, val;
 
1588
  int i;
 
1589
  int rate = portc->speed;
 
1590
 
 
1591
  if (rate > 48000)
 
1592
    rate = 48000;
 
1593
  if (rate < 5512)
 
1594
    rate = 5512;
 
1595
  for (i = 0; i < sizeof (rate_lookup) / sizeof (rate_lookup[0]); i++)
 
1596
    {
 
1597
      if (rate > rate_lookup[i].lower && rate <= rate_lookup[i].upper)
 
1598
        {
 
1599
          rate = rate_lookup[i].rate;
 
1600
          freq = rate_lookup[i].freq;
 
1601
          break;
 
1602
        }
 
1603
    }
 
1604
  if (chan_type == CHAN1)
 
1605
    {
 
1606
      val = INB (devc->osdev, FUNCTRL1 + 1) & ~0xe0;
 
1607
      OUTB (devc->osdev, val | freq << 5, FUNCTRL1 + 1);
 
1608
    }
 
1609
  else
 
1610
    {
 
1611
      val = INB (devc->osdev, FUNCTRL1 + 1) & ~0x1c;
 
1612
      OUTB (devc->osdev, val | freq << 2, FUNCTRL1 + 1);
 
1613
    }
 
1614
 
 
1615
  if (devc->dev_mode & SPDIFIN_MODE)
 
1616
    set_spdif_rate (devc, portc);
 
1617
}
 
1618
 
 
1619
static void
 
1620
set_adc_fmt (int dev, int chan_type)
 
1621
{
 
1622
  unsigned char val;
 
1623
  cmpci_devc *devc = audio_engines[dev]->devc;
 
1624
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1625
  int channels = portc->channels;
 
1626
  int bits = portc->bits;
 
1627
 
 
1628
  if (chan_type == CHAN1)
 
1629
    {
 
1630
      /* Set the format on Channel 1 */
 
1631
      val = INB (devc->osdev, CHFORMAT) & ~0xC;
 
1632
 
 
1633
      if ((channels == 1) && (bits == 8))
 
1634
        {
 
1635
          OUTB (devc->osdev, 0x00 | val, CHFORMAT);
 
1636
          portc->adcfmt = 0;
 
1637
        }
 
1638
 
 
1639
      if ((channels == 2) && (bits == 8))
 
1640
        {
 
1641
          OUTB (devc->osdev, 0x04 | val, CHFORMAT);
 
1642
          portc->adcfmt = 1;
 
1643
        }
 
1644
 
 
1645
      if ((channels == 1) && (bits == 16))
 
1646
        {
 
1647
          OUTB (devc->osdev, 0x08 | val, CHFORMAT);
 
1648
          portc->adcfmt = 1;
 
1649
        }
 
1650
 
 
1651
      if ((channels > 1) && (bits == 16))
 
1652
        {
 
1653
          OUTB (devc->osdev, 0x0C | val, CHFORMAT);
 
1654
          portc->adcfmt = 2;
 
1655
        }
 
1656
    }
 
1657
  else
 
1658
    {
 
1659
      /* Set the format on Channl 0 */
 
1660
      val = INB (devc->osdev, CHFORMAT) & ~0x3;
 
1661
 
 
1662
      if ((channels == 1) && (bits == 8))
 
1663
        {
 
1664
          OUTB (devc->osdev, 0x00 | val, CHFORMAT);
 
1665
          portc->adcfmt = 0;
 
1666
        }
 
1667
 
 
1668
      if ((channels == 2) && (bits == 8))
 
1669
        {
 
1670
          OUTB (devc->osdev, 0x01 | val, CHFORMAT);
 
1671
          portc->adcfmt = 1;
 
1672
        }
 
1673
 
 
1674
      if ((channels == 1) && (bits == 16))
 
1675
        {
 
1676
          OUTB (devc->osdev, 0x02 | val, CHFORMAT);
 
1677
          portc->adcfmt = 1;
 
1678
        }
 
1679
 
 
1680
      if ((channels == 2) && (bits == 16))
 
1681
        {
 
1682
          OUTB (devc->osdev, 0x03 | val, CHFORMAT);
 
1683
          portc->adcfmt = 2;
 
1684
        }
 
1685
    }
 
1686
}
 
1687
 
 
1688
static void
 
1689
setup_record (int dev, int chan_type)
 
1690
{
 
1691
  cmpci_devc *devc = audio_engines[dev]->devc;
 
1692
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1693
  dmap_t *dmap = audio_engines[dev]->dmap_in;
 
1694
 
 
1695
  if (chan_type == CHAN1)       /* SPDIF Record can only occur on CHAN1 */
 
1696
    {
 
1697
      /* reset and disable channel */
 
1698
      OUTB (devc->osdev,
 
1699
            INB (devc->osdev, FUNCTRL0 + 2) | CM_CH1_RESET, FUNCTRL0 + 2);
 
1700
      oss_udelay (10);
 
1701
      OUTB (devc->osdev,
 
1702
            INB (devc->osdev, FUNCTRL0 + 2) & ~CM_CH1_RESET, FUNCTRL0 + 2);
 
1703
 
 
1704
      cmpci_outsw (devc->mixer_dev, SPDIF_PLAY, SNDCTL_MIX_WRITE, 0);
 
1705
 
 
1706
      OUTL (devc->osdev, dmap->dmabuf_phys, CH1_FRAME1);
 
1707
      OUTW (devc->osdev, (dmap->bytes_in_use >> portc->adcfmt) - 1,
 
1708
            CH1_FRAME2);
 
1709
      OUTW (devc->osdev, (dmap->fragment_size >> portc->adcfmt),
 
1710
            CH1_FRAME2 + 2);
 
1711
 
 
1712
      /* set channel 1 to record mode */
 
1713
      OUTB (devc->osdev, INB (devc->osdev, FUNCTRL0) | CM_CH1_RECORD,
 
1714
            FUNCTRL0);
 
1715
      portc->chan1_rec = 1;
 
1716
 
 
1717
      /* setup SPDIF in on CHAN A */
 
1718
      OUTL (devc->osdev, INL (devc->osdev, FUNCTRL1) | (1 << 9), FUNCTRL1);
 
1719
    }
 
1720
  else                          /* Normal PCM record on Channel 0 */
 
1721
    {
 
1722
      /* reset and disable channel */
 
1723
      OUTB (devc->osdev,
 
1724
            INB (devc->osdev, FUNCTRL0 + 2) | CM_CH0_RESET, FUNCTRL0 + 2);
 
1725
      oss_udelay (10);
 
1726
      OUTB (devc->osdev,
 
1727
            INB (devc->osdev, FUNCTRL0 + 2) & ~CM_CH0_RESET, FUNCTRL0 + 2);
 
1728
 
 
1729
      OUTL (devc->osdev, dmap->dmabuf_phys, CH0_FRAME1);
 
1730
      OUTW (devc->osdev, (dmap->bytes_in_use >> portc->adcfmt) - 1,
 
1731
            CH0_FRAME2);
 
1732
      OUTW (devc->osdev, (dmap->fragment_size >> portc->adcfmt),
 
1733
            CH0_FRAME2 + 2);
 
1734
 
 
1735
      /* set channel 0 to record mode */
 
1736
      OUTB (devc->osdev, INB (devc->osdev, FUNCTRL0) | CM_CH0_RECORD,
 
1737
            FUNCTRL0);
 
1738
      portc->chan0_rec = 1;
 
1739
    }
 
1740
}
 
1741
 
 
1742
/*ARGSUSED*/
 
1743
static int
 
1744
cmpci_audio_prepare_for_input (int dev, int bsize, int bcount)
 
1745
{
 
1746
  cmpci_devc *devc = audio_engines[dev]->devc;
 
1747
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1748
  oss_native_word flags;
 
1749
 
 
1750
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
1751
 
 
1752
  switch (devc->dev_mode)
 
1753
    {
 
1754
    case DEFAULT_MODE:
 
1755
      set_adc_rate (dev, CHAN0);
 
1756
      set_adc_fmt (dev, CHAN0);
 
1757
      setup_record (dev, CHAN0);
 
1758
      break;
 
1759
 
 
1760
    case DUALDAC_MODE:
 
1761
      cmn_err (CE_WARN, "Cannot record because DUALDAC mode is ON.\n");
 
1762
      MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
1763
      return OSS_EIO;
 
1764
 
 
1765
    case SPDIFIN_MODE:
 
1766
      if (portc->speed < 44100)
 
1767
        {
 
1768
          cmn_err (CE_WARN,
 
1769
                   "Cannot record spdif at sampling rate less than 44.1Khz.\n");
 
1770
          MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
1771
          return OSS_EIO;
 
1772
        }
 
1773
      set_adc_rate (dev, CHAN1);
 
1774
      set_adc_fmt (dev, CHAN1);
 
1775
      setup_record (dev, CHAN1);
 
1776
      break;
 
1777
    }
 
1778
  portc->audio_enabled &= ~PCM_ENABLE_INPUT;
 
1779
  portc->trigger_bits &= ~PCM_ENABLE_INPUT;
 
1780
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
1781
  return 0;
 
1782
}
 
1783
 
 
1784
static void
 
1785
setup_play (int dev, int chan_type)
 
1786
{
 
1787
  cmpci_devc *devc = audio_engines[dev]->devc;
 
1788
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1789
  dmap_t *dmap = audio_engines[dev]->dmap_out;
 
1790
 
 
1791
  if (chan_type == CHAN0)
 
1792
    {
 
1793
      /* reset channel */
 
1794
      OUTB (devc->osdev,
 
1795
            INB (devc->osdev, FUNCTRL0 + 2) | CM_CH0_RESET, FUNCTRL0 + 2);
 
1796
      oss_udelay (10);
 
1797
      OUTB (devc->osdev,
 
1798
            INB (devc->osdev, FUNCTRL0 + 2) & ~CM_CH0_RESET, FUNCTRL0 + 2);
 
1799
      oss_udelay (10);
 
1800
 
 
1801
      /* Now set the buffer address/sizes */
 
1802
      OUTL (devc->osdev, dmap->dmabuf_phys, CH0_FRAME1);
 
1803
      OUTW (devc->osdev, (dmap->bytes_in_use >> portc->dacfmt) - 1,
 
1804
            CH0_FRAME2);
 
1805
      OUTW (devc->osdev, (dmap->fragment_size >> portc->dacfmt),
 
1806
            CH0_FRAME2 + 2);
 
1807
 
 
1808
      /* set channel 0 to play mode */
 
1809
      OUTB (devc->osdev, INB (devc->osdev, FUNCTRL0) & CM_CH0_PLAY, FUNCTRL0);
 
1810
      portc->chan0_play = 1;
 
1811
 
 
1812
      /* setup spdif output on CHAN A , disable CHAN B spdif */
 
1813
      if (devc->spdif_enabled)
 
1814
        {
 
1815
          OUTL (devc->osdev, INL (devc->osdev, FUNCTRL1) | (1 << 8),
 
1816
                FUNCTRL1);
 
1817
          OUTL (devc->osdev, INL (devc->osdev, FUNCTRL1) & ~(1 << 9),
 
1818
                FUNCTRL1);
 
1819
        }
 
1820
    }
 
1821
  else
 
1822
    {
 
1823
      /* reset and disable channel */
 
1824
      OUTB (devc->osdev,
 
1825
            INB (devc->osdev, FUNCTRL0 + 2) | CM_CH1_RESET, FUNCTRL0 + 2);
 
1826
      oss_udelay (10);
 
1827
      OUTB (devc->osdev,
 
1828
            INB (devc->osdev, FUNCTRL0 + 2) & ~CM_CH1_RESET, FUNCTRL0 + 2);
 
1829
      oss_udelay (10);
 
1830
 
 
1831
      /* Handle 4/5/6 channel mode */
 
1832
      if (portc->channels < 4)
 
1833
        {
 
1834
          /* check if 4speaker mode is enabled from mixer or not */
 
1835
          if (devc->mode_4spk)
 
1836
            OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) & ~(1 << 26),
 
1837
                  MISC_CTRL);
 
1838
 
 
1839
          /* disable 4channel mode on CHAN B */
 
1840
          OUTL (devc->osdev, INL (devc->osdev, CHFORMAT) & ~(1 << 29),
 
1841
                CHFORMAT);
 
1842
          /* disable 5 channel mode on CHAN B */
 
1843
          OUTL (devc->osdev, INL (devc->osdev, CHFORMAT) & ~(0x80000000),
 
1844
                CHFORMAT);
 
1845
          /* disable 6channel mode out CHAN B */
 
1846
          OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) & ~(1 << 15),
 
1847
                LEGACY_CTRL);
 
1848
          /* disable 8 channel decode on CHAN B - only for CMI8768 */
 
1849
          if (devc->model == MDL_CM8768)
 
1850
            OUTB (devc->osdev, INB (devc->osdev, MISC2_CTRL) & ~0x20,
 
1851
                  MISC2_CTRL);
 
1852
          /* Set NXCNG */
 
1853
          OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) & ~(0x80000000),
 
1854
                LEGACY_CTRL);
 
1855
        }
 
1856
 
 
1857
      if ((portc->channels == 4) && (devc->chiprev > 37))
 
1858
        {
 
1859
          /* disable 4 speaker mode */
 
1860
          OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) & ~(1 << 26),
 
1861
                MISC_CTRL);
 
1862
          /* enable 4channel mode on CHAN B */
 
1863
          OUTL (devc->osdev, INL (devc->osdev, CHFORMAT) | (1 << 29),
 
1864
                CHFORMAT);
 
1865
 
 
1866
          /* disable 5 channel mode on CHAN B */
 
1867
          OUTL (devc->osdev, INL (devc->osdev, CHFORMAT) & ~(0x80000000),
 
1868
                CHFORMAT);
 
1869
          /* disable 6channel mode out CHAN B */
 
1870
          OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) & ~(1 << 15),
 
1871
                LEGACY_CTRL);
 
1872
          /* disable center/bass channel */
 
1873
          OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) & ~(1 << 7),
 
1874
                MISC_CTRL);
 
1875
          /* disable bass */
 
1876
          OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) & ~(1 << 12),
 
1877
                LEGACY_CTRL);
 
1878
 
 
1879
          /* disable 8 channel decode on CHAN B - only for CMI8768 */
 
1880
          if (devc->model == MDL_CM8768)
 
1881
            OUTB (devc->osdev, INB (devc->osdev, MISC2_CTRL) & ~0x20,
 
1882
                  MISC2_CTRL);
 
1883
          /* Set NXCNG */
 
1884
          OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) & ~(0x80000000),
 
1885
                LEGACY_CTRL);
 
1886
        }
 
1887
 
 
1888
      if ((portc->channels == 6) && (devc->chiprev > 37))
 
1889
        {
 
1890
          /* disable 4 speaker mode */
 
1891
          OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) & ~(1 << 26),
 
1892
                MISC_CTRL);
 
1893
          /* disable 4channel mode on CHAN B */
 
1894
          OUTL (devc->osdev, INL (devc->osdev, CHFORMAT) & ~(1 << 29),
 
1895
                CHFORMAT);
 
1896
 
 
1897
          /* enable center channel */
 
1898
          OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) | (1 << 7),
 
1899
                MISC_CTRL);
 
1900
          /* enable bass */
 
1901
          OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) | (1 << 12),
 
1902
                LEGACY_CTRL);
 
1903
          /* enable 5 channel mode on CHAN B */
 
1904
          OUTL (devc->osdev, INL (devc->osdev, CHFORMAT) | (0x80000000),
 
1905
                CHFORMAT);
 
1906
          /* enable 6 channel decode on CHAN B */
 
1907
          OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) | (1 << 15),
 
1908
                LEGACY_CTRL);
 
1909
 
 
1910
          /* disable 8 channel decode on CHAN B - only for CMI8768 */
 
1911
          if (devc->model == MDL_CM8768)
 
1912
            OUTB (devc->osdev, INB (devc->osdev, MISC2_CTRL) & ~0x20,
 
1913
                  MISC2_CTRL);
 
1914
 
 
1915
          /* Set NXCNG */
 
1916
          OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) | (0x80000000),
 
1917
                LEGACY_CTRL);
 
1918
        }
 
1919
 
 
1920
      if ((portc->channels == 8) && (devc->model == MDL_CM8768))
 
1921
        {
 
1922
          /* disable 4 speaker mode */
 
1923
          OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) & ~(1 << 26),
 
1924
                MISC_CTRL);
 
1925
          /* disable 4channel mode on CHAN B */
 
1926
          OUTL (devc->osdev, INL (devc->osdev, CHFORMAT) & ~(1 << 29),
 
1927
                CHFORMAT);
 
1928
 
 
1929
          /* enable center channel */
 
1930
          OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) | (1 << 7),
 
1931
                MISC_CTRL);
 
1932
          /* enable bass channel */
 
1933
          OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) | (1 << 12),
 
1934
                LEGACY_CTRL);
 
1935
          /* disable 5 channel mode on CHAN B */
 
1936
          OUTL (devc->osdev, INL (devc->osdev, CHFORMAT) & ~(0x80000000),
 
1937
                CHFORMAT);
 
1938
          /* disable 6 channel decode on CHAN B */
 
1939
          OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) & ~(1 << 15),
 
1940
                LEGACY_CTRL);
 
1941
 
 
1942
          /* enable 8 channel decode on CHAN B */
 
1943
          OUTB (devc->osdev, INB (devc->osdev, MISC2_CTRL) | 0x20,
 
1944
                MISC2_CTRL);
 
1945
          /* Set NXCNG */
 
1946
          OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) | (0x80000000),
 
1947
                LEGACY_CTRL);
 
1948
        }
 
1949
 
 
1950
      /* Now set the buffer address/sizes */
 
1951
      OUTL (devc->osdev, dmap->dmabuf_phys, CH1_FRAME1);
 
1952
      OUTW (devc->osdev, (dmap->bytes_in_use >> portc->dacfmt) - 1,
 
1953
            CH1_FRAME2);
 
1954
      OUTW (devc->osdev, (dmap->fragment_size >> portc->dacfmt),
 
1955
            CH1_FRAME2 + 2);
 
1956
 
 
1957
 
 
1958
      /* set channel 1 to play mode */
 
1959
      OUTB (devc->osdev, INB (devc->osdev, FUNCTRL0) & CM_CH1_PLAY, FUNCTRL0);
 
1960
      portc->chan1_play = 1;
 
1961
 
 
1962
      /* setup spdif output on CHAN B , disable CHAN A spdif */
 
1963
      if (devc->spdif_enabled)
 
1964
        {
 
1965
          OUTL (devc->osdev, INL (devc->osdev, FUNCTRL1) | (1 << 9),
 
1966
                FUNCTRL1);
 
1967
          OUTL (devc->osdev, INL (devc->osdev, FUNCTRL1) & ~(1 << 8),
 
1968
                FUNCTRL1);
 
1969
        }
 
1970
    }
 
1971
}
 
1972
 
 
1973
/*ARGSUSED*/
 
1974
static int
 
1975
cmpci_audio_prepare_for_output (int dev, int bsize, int bcount)
 
1976
{
 
1977
  cmpci_devc *devc = audio_engines[dev]->devc;
 
1978
  cmpci_portc *portc = audio_engines[dev]->portc;
 
1979
  oss_native_word flags;
 
1980
 
 
1981
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
1982
 
 
1983
  if ((portc->bits == AFMT_AC3) && devc->can_ac3)
 
1984
    {
 
1985
      portc->bits = 16;
 
1986
      portc->channels = 2;
 
1987
      cmpci_outsw (devc->mixer_dev, SPDIF_PLAY, SNDCTL_MIX_WRITE, 1);
 
1988
      setup_ac3 (devc, portc, 1);
 
1989
    }
 
1990
  else
 
1991
    setup_ac3 (devc, portc, 0);
 
1992
 
 
1993
  switch (devc->dev_mode)
 
1994
    {
 
1995
    case DEFAULT_MODE:
 
1996
      /* set speed */
 
1997
      set_dac_rate (dev, CHAN1);
 
1998
      /* set format */
 
1999
      set_dac_fmt (dev, CHAN1);
 
2000
      /* set buffer address/size and other setups */
 
2001
      setup_play (dev, CHAN1);
 
2002
      break;
 
2003
 
 
2004
    case DUALDAC_MODE:
 
2005
      if (dev == devc->portc[0].audiodev)
 
2006
        {
 
2007
          set_dac_rate (dev, CHAN1);
 
2008
          set_dac_fmt (dev, CHAN1);
 
2009
          setup_play (dev, CHAN1);
 
2010
          setup_ac3 (devc, portc, 0);
 
2011
        }
 
2012
      if (dev == devc->portc[1].audiodev)
 
2013
        {
 
2014
          set_dac_rate (dev, CHAN0);
 
2015
          set_dac_fmt (dev, CHAN0);
 
2016
          setup_play (dev, CHAN0);
 
2017
          setup_ac3 (devc, portc, 0);
 
2018
        }
 
2019
      break;
 
2020
 
 
2021
    case SPDIFIN_MODE:
 
2022
      set_dac_rate (dev, CHAN0);
 
2023
      set_dac_fmt (dev, CHAN0);
 
2024
      setup_play (dev, CHAN0);
 
2025
      setup_ac3 (devc, portc, 0);
 
2026
      break;
 
2027
    }
 
2028
 
 
2029
  portc->audio_enabled &= ~PCM_ENABLE_OUTPUT;
 
2030
  portc->trigger_bits &= ~PCM_ENABLE_OUTPUT;
 
2031
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
2032
  return 0;
 
2033
}
 
2034
 
 
2035
static int
 
2036
cmpci_get_buffer_pointer (int dev, dmap_t * dmap, int direction)
 
2037
{
 
2038
  cmpci_devc *devc = audio_engines[dev]->devc;
 
2039
  cmpci_portc *portc = audio_engines[dev]->portc;
 
2040
  unsigned int ptr = 0;
 
2041
  oss_native_word flags;
 
2042
 
 
2043
  if (!(portc->open_mode & direction))
 
2044
    return 0;
 
2045
 
 
2046
  MUTEX_ENTER_IRQDISABLE (devc->low_mutex, flags);
 
2047
  if (direction == PCM_ENABLE_INPUT)
 
2048
    {
 
2049
      if (portc->chan0_rec)
 
2050
        ptr = INW (devc->osdev, CH0_FRAME1);
 
2051
      if (portc->chan1_rec)
 
2052
        ptr = INW (devc->osdev, CH1_FRAME1);
 
2053
    }
 
2054
 
 
2055
  if (direction == PCM_ENABLE_OUTPUT)
 
2056
    {
 
2057
      if (portc->chan0_play)
 
2058
        ptr = INW (devc->osdev, CH0_FRAME1);
 
2059
      if (portc->chan1_play)
 
2060
        ptr = INW (devc->osdev, CH1_FRAME1);
 
2061
    }
 
2062
  MUTEX_EXIT_IRQRESTORE (devc->low_mutex, flags);
 
2063
  return ptr % dmap->bytes_in_use;
 
2064
}
 
2065
 
 
2066
static audiodrv_t cmpci_audio_driver = {
 
2067
  cmpci_audio_open,
 
2068
  cmpci_audio_close,
 
2069
  cmpci_audio_output_block,
 
2070
  cmpci_audio_start_input,
 
2071
  cmpci_audio_ioctl,
 
2072
  cmpci_audio_prepare_for_input,
 
2073
  cmpci_audio_prepare_for_output,
 
2074
  cmpci_audio_reset,
 
2075
  NULL,
 
2076
  NULL,
 
2077
  cmpci_audio_reset_input,
 
2078
  cmpci_audio_reset_output,
 
2079
  cmpci_audio_trigger,
 
2080
  cmpci_audio_set_rate,
 
2081
  cmpci_audio_set_format,
 
2082
  cmpci_audio_set_channels,
 
2083
  NULL,
 
2084
  NULL,
 
2085
  NULL,
 
2086
  NULL,
 
2087
  NULL,                         /* cmpci_alloc_buffer, */
 
2088
  NULL,                         /* cmpci_free_buffer, */
 
2089
  NULL,
 
2090
  NULL,
 
2091
  cmpci_get_buffer_pointer
 
2092
};
 
2093
 
 
2094
#ifdef OBSOLETED_STUFF
 
2095
static void
 
2096
attach_mpu (cmpci_devc * devc)
 
2097
{
 
2098
  unsigned int base;
 
2099
 
 
2100
  if (devc->chiprev == 33)
 
2101
    base = 0x330;               /* Chiprev033 doen't have bas+0x40 */
 
2102
  else
 
2103
    base = MPU_MIRROR;          /* base+0x40 is MPU PCI mirror */
 
2104
 
 
2105
  uart401_init (&devc->uart401devc, devc->osdev, base, "Cmedia MIDI UART");
 
2106
  devc->uart401_attached = 1;
 
2107
}
 
2108
#endif
 
2109
 
 
2110
static int
 
2111
init_cmpci (cmpci_devc * devc)
 
2112
{
 
2113
  oss_native_word val;
 
2114
  int first_dev = 0;
 
2115
  int i;
 
2116
 
 
2117
  devc->fm_attached = 0;
 
2118
 
 
2119
/*
 
2120
 * Enable BusMasterMode and IOSpace Access
 
2121
 */
 
2122
  /* Check the model number of the chip */
 
2123
  val = INL (devc->osdev, INT_HLDCLR) & 0xff000000;
 
2124
 
 
2125
  if (!val)
 
2126
    {
 
2127
      val = INL (devc->osdev, CHFORMAT) & 0x1f000000;
 
2128
      if (!val)
 
2129
        {
 
2130
          devc->chiprev = 33;
 
2131
          devc->can_ac3 = 0;
 
2132
          devc->max_channels = 6;
 
2133
        }
 
2134
      else
 
2135
        {
 
2136
          devc->chiprev = 37;
 
2137
          devc->can_ac3 = 1;
 
2138
          devc->max_channels = 6;
 
2139
        }
 
2140
    }
 
2141
  else
 
2142
    {
 
2143
      if (val & 0x04000000)
 
2144
        {
 
2145
          devc->chiprev = 39;
 
2146
          devc->can_ac3 = 1;
 
2147
          devc->max_channels = 6;
 
2148
        }
 
2149
      if (val & 0x08000000)
 
2150
        {
 
2151
          devc->chiprev = 55;
 
2152
          devc->can_ac3 = 1;
 
2153
          devc->max_channels = 6;
 
2154
        }
 
2155
      if (val & 0x28000000)
 
2156
        {
 
2157
          devc->chiprev = 68;
 
2158
          devc->can_ac3 = 1;
 
2159
          devc->model = MDL_CM8768;
 
2160
          devc->max_channels = 8;
 
2161
          devc->chip_name = "CMedia CM8768";
 
2162
        }
 
2163
    }
 
2164
 
 
2165
  /* enable uart, joystick in Function Control Reg1 */
 
2166
  OUTB (devc->osdev, INB (devc->osdev, FUNCTRL1) | 0x06, FUNCTRL1);
 
2167
  /* enable FM */
 
2168
  OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) | (1 << 19), MISC_CTRL);
 
2169
  OUTB (devc->osdev, 0, INT_HLDCLR + 2);        /* disable ints */
 
2170
  OUTB (devc->osdev, 0, FUNCTRL0 + 2);  /* reset channels */
 
2171
 
 
2172
#ifdef OBSOLETED_STUFF
 
2173
  attach_mpu (devc);
 
2174
#endif
 
2175
 
 
2176
  /* install the CMPCI mixer */
 
2177
  if ((devc->mixer_dev = oss_install_mixer (OSS_MIXER_DRIVER_VERSION,
 
2178
                                            devc->osdev,
 
2179
                                            devc->osdev,
 
2180
                                            "CMedia CMPCI",
 
2181
                                            &cmpci_mixer_driver,
 
2182
                                            sizeof (mixer_driver_t),
 
2183
                                            devc)) < 0)
 
2184
    {
 
2185
      return 0;
 
2186
    }
 
2187
 
 
2188
  mixer_devs[devc->mixer_dev]->hw_devc = devc;
 
2189
  mixer_devs[devc->mixer_dev]->priority = 1;    /* Possible default mixer candidate */
 
2190
 
 
2191
  cmpci_mixer_reset (devc->mixer_dev);
 
2192
  mixer_ext_set_init_fn (devc->mixer_dev, cmpci_mix_init, 25);
 
2193
  OUTB (devc->osdev, 0xF, MIXER2);
 
2194
 
 
2195
  /* setup 4speaker output */
 
2196
  OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) | (1 << 26), MISC_CTRL);
 
2197
  /* enable subwoofer/center channel */
 
2198
  OUTL (devc->osdev, INL (devc->osdev, LEGACY_CTRL) | (1 << 12), LEGACY_CTRL);
 
2199
  OUTL (devc->osdev, INL (devc->osdev, MISC_CTRL) | (1 << 7), MISC_CTRL);
 
2200
 
 
2201
  for (i = 0; i < MAX_PORTC; i++)
 
2202
    {
 
2203
      char tmp_name[100];
 
2204
      cmpci_portc *portc = &devc->portc[i];
 
2205
      int caps = ADEV_AUTOMODE;
 
2206
 
 
2207
      if (i == 0)
 
2208
        {
 
2209
          sprintf (tmp_name, "%s (rev %0d)", devc->chip_name, devc->chiprev);
 
2210
          caps |= ADEV_DUPLEX;
 
2211
        }
 
2212
      else
 
2213
        {
 
2214
          sprintf (tmp_name, "%s (playback only)", devc->chip_name);
 
2215
          caps |= ADEV_NOINPUT;
 
2216
        }
 
2217
      if ((portc->audiodev = oss_install_audiodev (OSS_AUDIO_DRIVER_VERSION,
 
2218
                                                   devc->osdev,
 
2219
                                                   devc->osdev,
 
2220
                                                   tmp_name,
 
2221
                                                   &cmpci_audio_driver,
 
2222
                                                   sizeof (audiodrv_t),
 
2223
                                                   caps,
 
2224
                                                   AFMT_U8 | AFMT_S16_LE |
 
2225
                                                   AFMT_AC3, devc, -1)) < 0)
 
2226
        {
 
2227
          return 0;
 
2228
        }
 
2229
      else
 
2230
        {
 
2231
          if (i == 0)
 
2232
            first_dev = portc->audiodev;
 
2233
          audio_engines[portc->audiodev]->portc = portc;
 
2234
          audio_engines[portc->audiodev]->rate_source = first_dev;
 
2235
          audio_engines[portc->audiodev]->caps =
 
2236
            PCM_CAP_ANALOGOUT | PCM_CAP_ANALOGIN | PCM_CAP_DIGITALOUT |
 
2237
            PCM_CAP_DIGITALIN;
 
2238
          audio_engines[portc->audiodev]->min_rate = 5000;
 
2239
          audio_engines[portc->audiodev]->max_rate = 48000;
 
2240
          audio_engines[portc->audiodev]->caps |= PCM_CAP_FREERATE;
 
2241
          audio_engines[portc->audiodev]->min_channels = 2;
 
2242
          audio_engines[portc->audiodev]->max_channels = devc->max_channels;
 
2243
          audio_engines[portc->audiodev]->vmix_flags = VMIX_MULTIFRAG;
 
2244
          audio_engines[portc->audiodev]->dmabuf_alloc_flags |=
 
2245
            DMABUF_SIZE_16BITS;
 
2246
          portc->open_mode = 0;
 
2247
          portc->audio_enabled = 0;
 
2248
          audio_engines[portc->audiodev]->mixer_dev = devc->mixer_dev;
 
2249
          devc->dev_mode = DEFAULT_MODE;
 
2250
          devc->spdif_enabled = 0;
 
2251
#ifdef CONFIG_OSS_VMIX
 
2252
          if (i == 0)
 
2253
             vmix_attach_audiodev(devc->osdev, portc->audiodev, -1, 0);
 
2254
#endif
 
2255
        }
 
2256
    }
 
2257
  return 1;
 
2258
}
 
2259
 
 
2260
int
 
2261
oss_cmpci_attach (oss_device_t * osdev)
 
2262
{
 
2263
  unsigned char pci_irq_line, pci_revision;
 
2264
  unsigned short pci_command, vendor, device;
 
2265
  unsigned int pci_ioaddr;
 
2266
  int err;
 
2267
  cmpci_devc *devc;
 
2268
 
 
2269
  DDB (cmn_err (CE_CONT, "Entered CMEDIA CMPCI attach routine\n"));
 
2270
  pci_read_config_word (osdev, PCI_VENDOR_ID, &vendor);
 
2271
  pci_read_config_word (osdev, PCI_DEVICE_ID, &device);
 
2272
 
 
2273
  if (vendor != CMEDIA_VENDOR_ID
 
2274
      || ((device != CMEDIA_CM8738) && (device != CMEDIA_CM8338A)
 
2275
          && (device != CMEDIA_CM8338B)))
 
2276
    return 0;
 
2277
 
 
2278
  pci_read_config_byte (osdev, PCI_REVISION_ID, &pci_revision);
 
2279
  pci_read_config_word (osdev, PCI_COMMAND, &pci_command);
 
2280
  pci_read_config_irq (osdev, PCI_INTERRUPT_LINE, &pci_irq_line);
 
2281
  pci_read_config_dword (osdev, PCI_BASE_ADDRESS_0, &pci_ioaddr);
 
2282
 
 
2283
  DDB (cmn_err (CE_WARN, "CMPCI I/O base %04x\n", pci_ioaddr));
 
2284
 
 
2285
  if (pci_ioaddr == 0)
 
2286
    {
 
2287
      cmn_err (CE_WARN, "I/O address not assigned by BIOS.\n");
 
2288
      return 0;
 
2289
    }
 
2290
 
 
2291
  if (pci_irq_line == 0)
 
2292
    {
 
2293
      cmn_err (CE_WARN, "IRQ not assigned by BIOS (%d).\n", pci_irq_line);
 
2294
      return 0;
 
2295
    }
 
2296
 
 
2297
  if ((devc = PMALLOC (osdev, sizeof (*devc))) == NULL)
 
2298
    {
 
2299
      cmn_err (CE_WARN, "Out of memory\n");
 
2300
      return 0;
 
2301
    }
 
2302
 
 
2303
 
 
2304
  devc->osdev = osdev;
 
2305
  osdev->devc = devc;
 
2306
  devc->irq = pci_irq_line;
 
2307
 
 
2308
  /* Map the IO Base address */
 
2309
  devc->base = MAP_PCI_IOADDR (devc->osdev, 0, pci_ioaddr);
 
2310
 
 
2311
  /* Remove I/O space marker in bit 0. */
 
2312
  devc->base &= ~3;
 
2313
 
 
2314
  /* set the PCI_COMMAND register to master mode */
 
2315
  pci_command |= PCI_COMMAND_MASTER | PCI_COMMAND_IO;
 
2316
  pci_write_config_word (osdev, PCI_COMMAND, pci_command);
 
2317
 
 
2318
  switch (device)
 
2319
    {
 
2320
    case CMEDIA_CM8738:
 
2321
      devc->model = MDL_CM8738;
 
2322
      devc->chip_name = "CMedia CM8738";
 
2323
      devc->max_channels = 6;
 
2324
      break;
 
2325
 
 
2326
    case CMEDIA_CM8338A:
 
2327
      devc->model = MDL_CM8338A;
 
2328
      devc->chip_name = "CMedia CM8338A";
 
2329
      devc->max_channels = 6;
 
2330
      break;
 
2331
 
 
2332
    case CMEDIA_CM8338B:
 
2333
      devc->model = MDL_CM8338B;
 
2334
      devc->chip_name = "CMedia CM8338B";
 
2335
      devc->max_channels = 6;
 
2336
      break;
 
2337
    }
 
2338
 
 
2339
  MUTEX_INIT (devc->osdev, devc->mutex, MH_DRV);
 
2340
  MUTEX_INIT (devc->osdev, devc->low_mutex, MH_DRV + 1);
 
2341
 
 
2342
  oss_register_device (osdev, devc->chip_name);
 
2343
 
 
2344
  if ((err = oss_register_interrupts (devc->osdev, 0, cmpciintr, NULL)) < 0)
 
2345
    {
 
2346
      cmn_err (CE_WARN, "Can't allocate IRQ%d, err=%d\n", pci_irq_line, err);
 
2347
      return 0;
 
2348
    }
 
2349
 
 
2350
  return init_cmpci (devc);     /* Detected */
 
2351
}
 
2352
 
 
2353
int
 
2354
oss_cmpci_detach (oss_device_t * osdev)
 
2355
{
 
2356
  cmpci_devc *devc = (cmpci_devc *) osdev->devc;
 
2357
 
 
2358
  if (oss_disable_device (osdev) < 0)
 
2359
    return 0;
 
2360
 
 
2361
  /* disable Interrupts */
 
2362
  OUTB (devc->osdev, 0, INT_HLDCLR + 2);
 
2363
 
 
2364
  /* disable channels */
 
2365
  OUTB (devc->osdev, 0, FUNCTRL0 + 2);
 
2366
 
 
2367
  /* uninstall UART401 */
 
2368
  if (devc->uart401_attached)
 
2369
    uart401_disable (&devc->uart401devc);
 
2370
 
 
2371
  oss_unregister_interrupts (devc->osdev);
 
2372
 
 
2373
  MUTEX_CLEANUP (devc->mutex);
 
2374
  MUTEX_CLEANUP (devc->low_mutex);
 
2375
  UNMAP_PCI_IOADDR (devc->osdev, 0);
 
2376
 
 
2377
  oss_unregister_device (osdev);
 
2378
  return 1;
 
2379
}