← Back to branch summary

~ubuntu-branches/ubuntu/vivid/oss4/vivid

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Romain Beauxis, Samuel Thibault, Romain Beauxis, Sebastien NOEL
  • Date: 2011-06-14 10:06:56 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20110614100656-cx4oc7u426zn812z
Tags: 4.2-build2004-1
http://bugs.debian.org/589127
http://bugs.debian.org/604679
http://bugs.debian.org/595298
http://bugs.debian.org/619272
http://bugs.debian.org/627149
http://bugs.debian.org/628879
[ Samuel Thibault ]
* debian/control: Add liboss4-salsa2, liboss4-salsa-dev and
  liboss4-salsa-asound2 packages, equivalent to (and will replace) those from
  the oss-libsalsa package (Closes: #589127).
* debian/patches/liboss4-salsa.patch: New patch to rename libsalsa into
  liboss4-salsa to avoid conflicts in the archive for no good reason.
* debian/rules: Make in libOSSlib and libsalsa.
* debian/liboss4-salsa-dev.install, debian/liboss4-salsa2.install,
  debian/liboss4-salsa-asound2.links, debian/liboss4-salsa-dev.links:
  Install liboss4-salsa libraries like was done in the oss-libsalsa package.
* include-alsa: Add a copy of ALSA 1.0.5 headers: Cf ALSA_1.0.* symbols in
  libsalsa, this is the roughly supported version.
* debian/copyright: Update for new include-alsa files.
* alsa.pc: New file for compatibility with libasound-dev.
* debian/control:
  - Add Vcs-Browser and Vcs-Svn fields.
  - Use linux-any instead of the list of Linux archs (Closes: #604679).
  - Make dkms dependency linux-any only.
* debian/patches/hurd_iot.patch: New patch to fix soundcard.h usage in
  libsalsa on hurd-i386.
* debian/patches/libsalsa_fixes.patch: New patch to fix some printf usages
  and ioctl declaration in libsalsa.
* debian/patches/no_EBADE.patch: New patch to cope with hurd-i386 not having
  EBADE.
* debian/patches/CFLAGS.patch: New patch to make oss4 take debian/rules
  CFLAGS into account.
* debian/patches/snd_asoundlib_version.patch: New patch to add
  snd_asoundlib_version().
* debian/patches/generic_srccconf.patch: New patch to fix source
  configuration on unknown archs.

[ Romain Beauxis ]
* Fixed README.Debian to only mention dkms' modules.
* Switch to dpkg-source 3.0 (quilt) format
* Added DM-Upload-Allowed: yes

[ Sebastien NOEL ]
* New upstream release (Closes: #595298, #619272).
* Fix typo in initscript (Closes: #627149).
* debian/control: adjust linux-headers dependencies (Closes: #628879).

Show diffs side-by-side

added added

removed removed

Lines of Context:
kernel/drv/oss_audigyls/oss_audigyls.c
 
1
/*
 
2
 * Purpose: Driver for Creative Audigy LS audio controller
 
3
 *
 
4
 * This sound card has been sold under many different names.
 
5
 */
 
6
/*
 
7
 *
 
8
 * This file is part of Open Sound System.
 
9
 *
 
10
 * Copyright (C) 4Front Technologies 1996-2008.
 
11
 *
 
12
 * This this source file is released under GPL v2 license (no other versions).
 
13
 * See the COPYING file included in the main directory of this source
 
14
 * distribution for the license terms and conditions.
 
15
 *
 
16
 */
 
17
 
 
18
#include "oss_audigyls_cfg.h"
 
19
#include "oss_pci.h"
 
20
#include "ac97.h"
 
21
#include "midi_core.h"
 
22
#include "remux.h"
 
23
 
 
24
#define DEFAULT_RATE 48000
 
25
 
 
26
#undef  USE_ITIMER
 
27
 
 
28
#define PCI_VENDOR_ID_CREATIVE          0x1102
 
29
#define PCI_DEVICE_ID_CREATIVE_AUDIGYLS 0x0007
 
30
 
 
31
/*
 
32
 * Indirect registers
 
33
 */
 
34
 
 
35
#define PTBA    0x000
 
36
#define PTBS    0x001
 
37
#define PTCA    0x002
 
38
#define PFBA    0x004
 
39
#define PFBS    0x005
 
40
#define CPFA    0x006
 
41
#define PFEA    0x007
 
42
#define CPCAV   0x008
 
43
#define RFBA    0x010
 
44
#define RFBS    0x011
 
45
#define CRFA    0x012
 
46
#define CRCAV   0x013
 
47
#define CDL     0x020
 
48
#define SA      0x040
 
49
#define SCS3    0x041
 
50
#define SCS0    0x042
 
51
#define SCS1    0x043
 
52
#define SCS2    0x044
 
53
#define SPC     0x045
 
54
#define WMARK   0x046
 
55
#define SPSC    0x049
 
56
#define RCD     0x050           /* 0x50-0z5f */
 
57
#define P17RECSEL       0x060
 
58
#define P17RECVOLL      0x061
 
59
#define P17RECVOLH      0x062
 
60
 
 
61
#define HMIXMAP_SPDIF 0x63
 
62
#define SMIXMAP_SPDIF 0x64
 
63
#define MIXCTL_SPDIF 0x65
 
64
#define MIXVOL_SPDIF 0x66
 
65
#define HMIXMAP_I2S 0x67
 
66
#define SMIXMAP_I2S 0x68
 
67
#define MIXCTL_I2S 0x69
 
68
#define MIXVOL_I2S 0x6a
 
69
 
 
70
/* MIDI UART */
 
71
#define MUDATA  0x06c
 
72
#define MUCMDA  0x06d
 
73
#define MUDATB  0x06e
 
74
#define MUCMDB  0x06f
 
75
 
 
76
#define SRT     0x070
 
77
#define SRCTL   0x071
 
78
#define AUDCTL  0x072
 
79
#define CHIP_ID 0x074
 
80
#define AINT_ENABLE     0x075
 
81
#define AINT_STATUS     0x076
 
82
#define Wall192         0x077
 
83
#define Wall441         0x078
 
84
#define IT              0x079
 
85
#define SPI             0x07a
 
86
#define I2C_A           0x07b
 
87
#define I2C_0           0x07c
 
88
#define I2C_1           0x07d
 
89
 
 
90
/*
 
91
 * Global Interrupt bits
 
92
 */
 
93
 
 
94
#define IE 0x0c
 
95
#define INTR_PCI        (1<<  0)
 
96
#define INTR_TXA        (1<<  1)
 
97
#define INTR_RXA        (1<<  2)
 
98
#define INTR_IT1        (1<<  3)
 
99
#define INTR_IT2        (1<<  4)
 
100
#define INTR_SS_        (1<<  5)
 
101
#define INTR_SRT        (1<<  6)
 
102
#define INTR_GP         (1<<  7)
 
103
#define INTR_AI         (1<<  8)
 
104
#define INTR_I2Cdac     (1<<  9)
 
105
#define INTR_I2CEE      (1<< 10)
 
106
#define INTR_SPI        (1<< 11)
 
107
#define INTR_SPF        (1<< 12)
 
108
#define INTR_SUO        (1<< 13)
 
109
#define INTR_SUI        (1<< 14)
 
110
#define INTR_TXB        (1<< 16)
 
111
#define INTR_RXB        (1<< 17)
 
112
 
 
113
/*
 
114
 * Audio interrupt bits
 
115
 */
 
116
 
 
117
#define AI_PFH          (1<<  0)
 
118
#define AI_PFF          (1<<  4)
 
119
#define AI_TFH          (1<<  8)
 
120
#define AI_TFF          (1<< 12)
 
121
#define AI_RFH          (1<< 16)
 
122
#define AI_RFF          (1<< 20)
 
123
#define AI_EAI          (1<< 24)
 
124
 
 
125
 
 
126
#define MAX_PORTC       3
 
127
 
 
128
extern int audigyls_spdif_enable;
 
129
 
 
130
typedef struct
 
131
{
 
132
  int audio_dev;
 
133
  int play_port;
 
134
  int rec_port;
 
135
  int open_mode;
 
136
  int trigger_bits;
 
137
  int audio_enabled;
 
138
  int channels;
 
139
  int bits;
 
140
  int speed;
 
141
#ifdef USE_ITIMER
 
142
  int frag_192khz;
 
143
#endif
 
144
  int port_type;
 
145
  int play_ptr, rec_ptr;
 
146
}
 
147
audigyls_portc;
 
148
 
 
149
typedef struct
 
150
{
 
151
  oss_device_t *osdev;
 
152
  oss_native_word base;
 
153
  oss_mutex_t mutex;
 
154
  oss_mutex_t low_mutex;
 
155
  char *card_name;
 
156
  unsigned int subvendor;
 
157
  int rec_src;                  /* record channel src spdif/i2s/ac97/src */
 
158
#define RECSEL_SPDIFOUT   0
 
159
#define RECSEL_I2SOUT     1
 
160
#define RECSEL_SPDIFIN    2
 
161
#define RECSEL_I2SIN      3
 
162
#define RECSEL_AC97       4
 
163
#define RECSEL_SRC        5
 
164
 
 
165
  int mixer_dev;
 
166
  ac97_devc ac97devc;
 
167
  int has_ac97;
 
168
  int spread;                   /* copy front to surr/center channels */
 
169
  int loopback;                 /* record channel input from /dev/dspXX */
 
170
  int input_source;             /* input from mic/line/aux/etc */
 
171
  int captmon;         /* hear what you record*/ 
 
172
  int fbvol;         /* recording monitor volume */ 
 
173
/*
 
174
 * UART
 
175
 */
 
176
  oss_midi_inputbyte_t midi_input_intr;
 
177
  int midi_opened, midi_disabled;
 
178
  volatile unsigned char input_byte;
 
179
  int midi_dev;
 
180
  int mpu_attached;
 
181
  int playvol[4];
 
182
  int recvol;
 
183
  audigyls_portc portc[MAX_PORTC];
 
184
 
 
185
}
 
186
audigyls_devc;
 
187
 
 
188
 
 
189
static void audigylsuartintr (audigyls_devc * devc);
 
190
 
 
191
static unsigned int
 
192
read_reg (audigyls_devc * devc, int reg, int chn)
 
193
{
 
194
  oss_native_word flags;
 
195
  unsigned int val;
 
196
 
 
197
  MUTEX_ENTER_IRQDISABLE (devc->low_mutex, flags);
 
198
  OUTL (devc->osdev, (reg << 16) | (chn & 0xffff), devc->base + 0x00);  /* Pointer */
 
199
  val = INL (devc->osdev, devc->base + 0x04);   /* Data */
 
200
  MUTEX_EXIT_IRQRESTORE (devc->low_mutex, flags);
 
201
 
 
202
/*printk("Read reg %03x (ch %d) = %08x\n", reg, chn, val);*/
 
203
  return val;
 
204
}
 
205
 
 
206
static void
 
207
write_reg (audigyls_devc * devc, int reg, int chn, unsigned int value)
 
208
{
 
209
  oss_native_word flags;
 
210
 
 
211
  /*printk("Write reg %03x (ch %d) = %08x\n", reg, chn, value); */
 
212
  MUTEX_ENTER_IRQDISABLE (devc->low_mutex, flags);
 
213
  OUTL (devc->osdev, (reg << 16) | (chn & 0xffff), devc->base + 0x00);  /* Pointer */
 
214
  OUTL (devc->osdev, value, devc->base + 0x04); /* Data */
 
215
  MUTEX_EXIT_IRQRESTORE (devc->low_mutex, flags);
 
216
#if 0
 
217
  {
 
218
    char tmp[100];
 
219
    int ok = 1;
 
220
    sprintf (tmp, "@w%d %04x/%s %x", chn, reg, emu_regname (reg, &ok), value);
 
221
    if (ok)
 
222
      oss_do_timing (tmp);
 
223
  }
 
224
#endif
 
225
}
 
226
 
 
227
 
 
228
static int
 
229
audigyls_ac97_read (void *devc_, int wAddr)
 
230
{
 
231
  audigyls_devc *devc = devc_;
 
232
  int dtemp = 0, i;
 
233
 
 
234
  oss_native_word flags;
 
235
 
 
236
  MUTEX_ENTER_IRQDISABLE (devc->low_mutex, flags);
 
237
  OUTB (devc->osdev, wAddr, devc->base + 0x1e);
 
238
  for (i = 0; i < 10000; i++)
 
239
    if (INB (devc->osdev, devc->base + 0x1e) & 0x80)
 
240
      break;
 
241
  if (i == 10000)
 
242
    {
 
243
      MUTEX_EXIT_IRQRESTORE (devc->low_mutex, flags);
 
244
      return OSS_EIO;
 
245
    }
 
246
  dtemp = INW (devc->osdev, devc->base + 0x1c);
 
247
  MUTEX_EXIT_IRQRESTORE (devc->low_mutex, flags);
 
248
 
 
249
  return dtemp & 0xffff;
 
250
}
 
251
 
 
252
static int
 
253
audigyls_ac97_write (void *devc_, int wAddr, int wData)
 
254
{
 
255
  audigyls_devc *devc = devc_;
 
256
  oss_native_word flags;
 
257
  int i;
 
258
 
 
259
  MUTEX_ENTER_IRQDISABLE (devc->low_mutex, flags);
 
260
  OUTB (devc->osdev, wAddr, devc->base + 0x1e);
 
261
  for (i = 0; i < 10000; i++)
 
262
    if (INB (devc->osdev, devc->base + 0x1e) & 0x80)
 
263
      break;
 
264
  if (i == 10000)
 
265
    {
 
266
      MUTEX_EXIT_IRQRESTORE (devc->low_mutex, flags);
 
267
      return OSS_EIO;
 
268
    }
 
269
  OUTW (devc->osdev, wData, devc->base + 0x1c);
 
270
  MUTEX_EXIT_IRQRESTORE (devc->low_mutex, flags);
 
271
 
 
272
  return 0;
 
273
}
 
274
 
 
275
static void
 
276
check_recording_intr (audigyls_devc * devc, audigyls_portc * portc)
 
277
{
 
278
#if 1
 
279
  int pos, n = 0;
 
280
  dmap_p dmap;
 
281
 
 
282
  dmap = audio_engines[portc->audio_dev]->dmap_in;
 
283
 
 
284
  pos = read_reg (devc, CRFA, portc->rec_port);
 
285
  pos /= dmap->fragment_size;
 
286
  while (dmap_get_qtail (dmap) != pos && n++ < dmap->nfrags)
 
287
#endif
 
288
    oss_audio_inputintr (portc->audio_dev, 0);
 
289
}
 
290
 
 
291
static void
 
292
check_playback_intr (audigyls_devc * devc, audigyls_portc * portc)
 
293
{
 
294
#if 1
 
295
  int pos, n = 0;
 
296
  dmap_p dmap;
 
297
 
 
298
  dmap = audio_engines[portc->audio_dev]->dmap_out;
 
299
 
 
300
  pos = read_reg (devc, CPFA, portc->play_port);
 
301
  pos /= dmap->fragment_size;
 
302
  while (dmap_get_qhead (dmap) != pos && n++ < dmap->nfrags)
 
303
#endif
 
304
    oss_audio_outputintr (portc->audio_dev, 0);
 
305
}
 
306
 
 
307
static int
 
308
audigylsintr (oss_device_t * osdev)
 
309
{
 
310
  int serviced = 0;
 
311
  unsigned int status;
 
312
  unsigned int astatus = 0;
 
313
  int i;
 
314
  audigyls_devc *devc = osdev->devc;
 
315
  audigyls_portc *portc;
 
316
  oss_native_word flags;
 
317
 
 
318
  flags = 0;                    /* To fix compiler warnings about unused variable */
 
319
  MUTEX_ENTER (devc->mutex, flags);
 
320
 
 
321
  status = INL (devc->osdev, devc->base + 0x08);
 
322
 
 
323
  if (status & INTR_RXA)        /* MIDI RX interrupt */
 
324
    {
 
325
      audigylsuartintr (devc);
 
326
    }
 
327
 
 
328
  if (status & INTR_AI)
 
329
    {
 
330
      astatus = read_reg (devc, AINT_STATUS, 0);
 
331
      for (i = 0; i < MAX_PORTC; i++)
 
332
        {
 
333
          portc = &devc->portc[i];
 
334
 
 
335
          if ((portc->trigger_bits & PCM_ENABLE_OUTPUT) &&
 
336
              (astatus & ((AI_PFF | AI_PFH) << portc->play_port)))
 
337
            {
 
338
              dmap_t *dmap = audio_engines[portc->audio_dev]->dmap_out;
 
339
 
 
340
              if (astatus & (AI_PFF << portc->play_port))
 
341
                portc->play_ptr = 0;
 
342
              if (astatus & (AI_PFH << portc->play_port))
 
343
                portc->play_ptr = dmap->bytes_in_use / 2;
 
344
 
 
345
              oss_audio_outputintr (portc->audio_dev, 0);
 
346
            }
 
347
          if ((portc->trigger_bits & PCM_ENABLE_INPUT) &&
 
348
              (astatus & ((AI_RFF | AI_RFH) << portc->rec_port)))
 
349
            {
 
350
              dmap_t *dmap = audio_engines[portc->audio_dev]->dmap_in;
 
351
 
 
352
              if (astatus & (AI_RFF << portc->rec_port))
 
353
                portc->rec_ptr = 0;
 
354
              if (astatus & (AI_RFH << portc->rec_port))
 
355
                portc->rec_ptr = dmap->bytes_in_use / 2;
 
356
 
 
357
              oss_audio_inputintr (portc->audio_dev, 0);
 
358
            }
 
359
        }
 
360
      write_reg (devc, AINT_STATUS, 0, astatus);
 
361
    }
 
362
 
 
363
  if (status & INTR_IT1)
 
364
    {
 
365
      for (i = 0; i < MAX_PORTC; i++)
 
366
        {
 
367
          portc = &devc->portc[i];
 
368
 
 
369
          if ((portc->trigger_bits & PCM_ENABLE_OUTPUT))
 
370
            check_playback_intr (devc, portc);
 
371
 
 
372
          if ((portc->trigger_bits & PCM_ENABLE_INPUT))
 
373
            check_recording_intr (devc, portc);
 
374
        }
 
375
    }
 
376
 
 
377
  serviced = 1;
 
378
  OUTL (devc->osdev, status, devc->base + 0x08);        /* Acknowledge */
 
379
  MUTEX_EXIT (devc->mutex, flags);
 
380
  return serviced;
 
381
}
 
382
 
 
383
static int
 
384
audigyls_set_rate (int dev, int arg)
 
385
{
 
386
  audigyls_portc *portc = audio_engines[dev]->portc;
 
387
 
 
388
  if (arg == 0)
 
389
    return portc->speed;
 
390
 
 
391
  if (audio_engines[dev]->flags & ADEV_FIXEDRATE)
 
392
    arg = DEFAULT_RATE;
 
393
 
 
394
  if (arg != 44100 && arg != 48000 && arg != 96000 && arg != 192000)
 
395
    arg = 48000;
 
396
 
 
397
  portc->speed = arg;
 
398
  return portc->speed;
 
399
}
 
400
 
 
401
static short
 
402
audigyls_set_channels (int dev, short arg)
 
403
{
 
404
  audigyls_portc *portc = audio_engines[dev]->portc;
 
405
 
 
406
  if (arg == 0)
 
407
    return portc->channels;
 
408
 
 
409
  if ((arg == 1))
 
410
    arg = 2;
 
411
 
 
412
  if (portc->open_mode & OPEN_READ)
 
413
    return portc->channels = 2;
 
414
 
 
415
  if (arg != 1 && arg != 2)
 
416
    return portc->channels = 2;
 
417
  return portc->channels = arg;
 
418
}
 
419
 
 
420
static unsigned int
 
421
audigyls_set_format (int dev, unsigned int arg)
 
422
{
 
423
  audigyls_portc *portc = audio_engines[dev]->portc;
 
424
 
 
425
  if (arg == 0)
 
426
    return portc->bits;
 
427
 
 
428
  if (arg != AFMT_AC3 && arg != AFMT_S16_LE)
 
429
    return portc->bits = AFMT_S16_LE;
 
430
 
 
431
  return portc->bits = arg;
 
432
}
 
433
 
 
434
/*ARGSUSED*/
 
435
static int
 
436
audigyls_ioctl (int dev, unsigned int cmd, ioctl_arg arg)
 
437
{
 
438
  return OSS_EINVAL;
 
439
}
 
440
 
 
441
static void audigyls_trigger (int dev, int state);
 
442
 
 
443
static void
 
444
audigyls_reset (int dev)
 
445
{
 
446
  audigyls_trigger (dev, 0);
 
447
}
 
448
 
 
449
/*ARGSUSED*/
 
450
static int
 
451
audigyls_open (int dev, int mode, int open_flags)
 
452
{
 
453
  audigyls_portc *portc = audio_engines[dev]->portc;
 
454
  audigyls_devc *devc = audio_engines[dev]->devc;
 
455
  oss_native_word flags;
 
456
 
 
457
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
458
  if (portc->open_mode)
 
459
    {
 
460
      MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
461
      return OSS_EBUSY;
 
462
    }
 
463
  portc->open_mode = mode;
 
464
  portc->audio_enabled = ~mode;
 
465
  portc->play_ptr = portc->rec_ptr = 0;
 
466
 
 
467
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
468
  return 0;
 
469
}
 
470
 
 
471
static void
 
472
audigyls_close (int dev, int mode)
 
473
{
 
474
  audigyls_portc *portc = audio_engines[dev]->portc;
 
475
 
 
476
  audigyls_reset (dev);
 
477
  portc->open_mode = 0;
 
478
  portc->audio_enabled &= ~mode;
 
479
}
 
480
 
 
481
/*ARGSUSED*/
 
482
static void
 
483
audigyls_output_block (int dev, oss_native_word buf, int count, int fragsize,
 
484
                       int intrflag)
 
485
{
 
486
}
 
487
 
 
488
/*ARGSUSED*/
 
489
static void
 
490
audigyls_start_input (int dev, oss_native_word buf, int count, int fragsize,
 
491
                      int intrflag)
 
492
{
 
493
  audigyls_portc *portc = audio_engines[dev]->portc;
 
494
 
 
495
  portc->audio_enabled |= PCM_ENABLE_INPUT;
 
496
  portc->trigger_bits &= ~PCM_ENABLE_INPUT;
 
497
}
 
498
 
 
499
#ifdef USE_ITIMER
 
500
static void
 
501
check_itimer (audigyls_devc * devc)
 
502
{
 
503
  int i;
 
504
  unsigned int t = 0x1fffffff;
 
505
  audigyls_portc *portc;
 
506
  int tmp;
 
507
 
 
508
  for (i = 0; i < MAX_PORTC; i++)
 
509
    {
 
510
      portc = &devc->portc[i];
 
511
      if (portc->frag_192khz != 0 && portc->frag_192khz < t)
 
512
        t = portc->frag_192khz;
 
513
    }
 
514
  if (t == 0x1fffffff)          /* No audio devices active */
 
515
    {
 
516
      tmp = INL (devc->osdev, devc->base + IE);
 
517
      tmp &= ~INTR_IT1;
 
518
      OUTL (devc->osdev, tmp, devc->base + IE);
 
519
    }
 
520
  else
 
521
    {
 
522
      t /= 16;
 
523
      if (t < 1)
 
524
        t = 1;
 
525
      write_reg (devc, IT, 0, t);
 
526
      tmp = INL (devc->osdev, devc->base + IE);
 
527
      tmp |= INTR_IT1;
 
528
      OUTL (devc->osdev, tmp, devc->base + IE);
 
529
    }
 
530
}
 
531
 
 
532
static void
 
533
adjust_itimer (audigyls_devc * devc, audigyls_portc * portc, dmap_p dmap)
 
534
{
 
535
  unsigned int t;
 
536
 
 
537
  /* Compute byte rate */
 
538
 
 
539
  t = portc->speed * portc->channels;
 
540
 
 
541
  switch (portc->bits)
 
542
    {
 
543
    case AFMT_S16_LE:
 
544
    case AFMT_S16_BE:
 
545
    case AFMT_AC3:
 
546
      t *= 2;
 
547
      break;
 
548
 
 
549
    case AFMT_S32_LE:
 
550
    case AFMT_S32_BE:
 
551
    case AFMT_S24_LE:
 
552
    case AFMT_S24_BE:
 
553
      t *= 4;
 
554
      break;
 
555
    }
 
556
 
 
557
/* Compute the number of 192kHz ticks per fragment */
 
558
 
 
559
  t = (dmap->fragment_size * 192000) / t;       /* msecs / fragment */
 
560
  if (t < 1)
 
561
    t = 1;
 
562
 
 
563
  portc->frag_192khz = t;
 
564
  check_itimer (devc);
 
565
}
 
566
#endif
 
567
 
 
568
static void
 
569
audigyls_trigger (int dev, int state)
 
570
{
 
571
  audigyls_devc *devc = audio_engines[dev]->devc;
 
572
  audigyls_portc *portc = audio_engines[dev]->portc;
 
573
  int tmp;
 
574
  oss_native_word flags;
 
575
 
 
576
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
577
 
 
578
  if (portc->open_mode & OPEN_WRITE)
 
579
    {
 
580
      if (state & PCM_ENABLE_OUTPUT)
 
581
        {
 
582
          if ((portc->audio_enabled & PCM_ENABLE_OUTPUT) &&
 
583
              !(portc->trigger_bits & PCM_ENABLE_OUTPUT))
 
584
            {
 
585
              tmp = read_reg (devc, SA, 0);
 
586
              tmp |= 1 << portc->play_port;
 
587
              write_reg (devc, SA, 0, tmp);
 
588
#ifdef USE_ITIMER
 
589
              check_itimer (devc);
 
590
#else
 
591
              tmp = read_reg (devc, AINT_ENABLE, 0);
 
592
              tmp |= ((AI_PFH | AI_PFF) << portc->play_port);
 
593
              write_reg (devc, AINT_ENABLE, 0, tmp);
 
594
#endif
 
595
              portc->trigger_bits |= PCM_ENABLE_OUTPUT;
 
596
            }
 
597
        }
 
598
 
 
599
      else
 
600
        {
 
601
          if ((portc->audio_enabled & PCM_ENABLE_OUTPUT) &&
 
602
              (portc->trigger_bits & PCM_ENABLE_OUTPUT))
 
603
            {
 
604
              portc->audio_enabled &= ~PCM_ENABLE_OUTPUT;
 
605
              portc->trigger_bits &= ~PCM_ENABLE_OUTPUT;
 
606
#ifdef USE_ITIMER
 
607
              portc->frag_192khz = 0;
 
608
              check_itimer (devc);
 
609
#endif
 
610
              /* Disable Play channel */
 
611
              tmp = read_reg (devc, SA, 0);
 
612
              tmp &= ~(1 << portc->play_port);
 
613
              write_reg (devc, SA, 0, tmp);
 
614
#ifndef USE_ITIMER
 
615
              tmp = read_reg (devc, AINT_ENABLE, 0);
 
616
              tmp &= ~((AI_PFH | AI_PFF) << portc->play_port);
 
617
              write_reg (devc, AINT_ENABLE, 0, tmp);
 
618
#endif
 
619
            }
 
620
        }
 
621
    }
 
622
 
 
623
  if (portc->open_mode & OPEN_READ)
 
624
    {
 
625
      if (state & PCM_ENABLE_INPUT)
 
626
        {
 
627
          if ((portc->audio_enabled & PCM_ENABLE_INPUT) &&
 
628
              !(portc->trigger_bits & PCM_ENABLE_INPUT))
 
629
            {
 
630
              /* Enable Rec Channel */
 
631
              tmp = read_reg (devc, SA, 0);
 
632
              tmp |= 0x100 << portc->rec_port;  /* enable record */
 
633
              write_reg (devc, SA, 0, tmp);
 
634
#ifdef USE_ITIMER
 
635
              check_itimer (devc);
 
636
#else
 
637
              tmp = read_reg (devc, AINT_ENABLE, 0);
 
638
              tmp |= ((AI_RFF | AI_RFH) << portc->rec_port);
 
639
              write_reg (devc, AINT_ENABLE, 0, tmp);
 
640
#endif
 
641
              portc->trigger_bits |= PCM_ENABLE_INPUT;
 
642
            }
 
643
        }
 
644
      else
 
645
        {
 
646
          if ((portc->audio_enabled & PCM_ENABLE_INPUT) &&
 
647
              (portc->trigger_bits & PCM_ENABLE_INPUT))
 
648
            {
 
649
              portc->audio_enabled &= ~PCM_ENABLE_INPUT;
 
650
              portc->trigger_bits &= ~PCM_ENABLE_INPUT;
 
651
#ifdef USE_ITIMER
 
652
              portc->frag_192khz = 0;
 
653
              check_itimer (devc);
 
654
#endif
 
655
              /* disable channel */
 
656
              tmp = read_reg (devc, SA, 0);
 
657
              tmp &= ~(0x100 << portc->rec_port);
 
658
              write_reg (devc, SA, 0, tmp);
 
659
#ifndef USE_ITIMER
 
660
              tmp = read_reg (devc, AINT_ENABLE, 0);
 
661
              tmp &= ~((AI_RFF | AI_RFH) << portc->rec_port);
 
662
              write_reg (devc, AINT_ENABLE, 0, tmp);
 
663
#endif
 
664
            }
 
665
        }
 
666
    }
 
667
 
 
668
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
669
}
 
670
 
 
671
/*ARGSUSED*/
 
672
static int
 
673
audigyls_prepare_for_input (int dev, int bsize, int bcount)
 
674
{
 
675
  unsigned int tmp, recmap, reg;
 
676
   /*LINTED*/ unsigned int oversample;
 
677
  audigyls_devc *devc = audio_engines[dev]->devc;
 
678
  audigyls_portc *portc = audio_engines[dev]->portc;
 
679
  dmap_p dmap = audio_engines[dev]->dmap_in;
 
680
  oss_native_word flags;
 
681
 
 
682
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
683
  write_reg (devc, CRFA, portc->rec_port, 0);
 
684
  write_reg (devc, CRCAV, portc->rec_port, 0);
 
685
 
 
686
  write_reg (devc, RFBA, portc->rec_port, dmap->dmabuf_phys);
 
687
  write_reg (devc, RFBS, portc->rec_port, (dmap->bytes_in_use) << 16);
 
688
 
 
689
  /* set 16/24 bits */
 
690
  tmp = INL (devc->osdev, devc->base + 0x14);
 
691
  if (portc->bits == AFMT_S16_LE)
 
692
    tmp &= ~0x400;              /*16 bit */
 
693
  else
 
694
    tmp |= 0x400;               /*24 bit */
 
695
  OUTL (devc->osdev, tmp, devc->base + 0x14);
 
696
 
 
697
  /* set recording speed */
 
698
  reg = read_reg (devc, SRCTL, 0) & ~0xc000;
 
699
 
 
700
  switch (portc->speed)
 
701
    {
 
702
    case 48000:
 
703
      reg |= 0x0;
 
704
      oversample = 0x2;
 
705
      break;
 
706
 
 
707
    case 96000:
 
708
      reg |= 0x8000;
 
709
      oversample = 0xa;
 
710
      break;
 
711
 
 
712
    case 192000:
 
713
      reg |= 0xc000;
 
714
      oversample = 0xa;
 
715
      break;
 
716
 
 
717
    default:
 
718
      reg |= 0;
 
719
      oversample = 0x2;
 
720
      break;
 
721
    }
 
722
 
 
723
  write_reg (devc, SRCTL, 0, reg);
 
724
/*  audigyls_i2c_write(devc, 0xc, oversample);*/
 
725
 
 
726
/* setup record input */
 
727
  if (devc->loopback)
 
728
    {
 
729
      devc->rec_src = RECSEL_I2SOUT;
 
730
      recmap = 0;
 
731
    }
 
732
  else
 
733
    {
 
734
      if (devc->has_ac97)
 
735
        {
 
736
          devc->rec_src = RECSEL_AC97;  /* audigy LS */
 
737
        }
 
738
      else
 
739
        {
 
740
          devc->rec_src = RECSEL_I2SIN; /* sb 7.1 value */
 
741
        }
 
742
      recmap = 0x00; 
 
743
    }
 
744
  tmp = recmap;                 /* default record input map */
 
745
  tmp |= devc->rec_src << 28 | devc->rec_src << 24 | devc->rec_src << 20 | devc->rec_src << 16; 
 
746
//write_reg (devc, SMIXMAP_SPDIF, 0, 0x76767676); 
 
747
  write_reg (devc, P17RECSEL, 0, tmp);
 
748
  portc->audio_enabled &= ~PCM_ENABLE_INPUT;
 
749
  portc->trigger_bits &= ~PCM_ENABLE_INPUT;
 
750
 
 
751
#ifdef USE_ITIMER
 
752
  adjust_itimer (devc, portc, dmap);
 
753
#endif
 
754
 
 
755
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
756
 
 
757
  return 0;
 
758
}
 
759
 
 
760
/*ARGSUSED*/
 
761
static int
 
762
audigyls_prepare_for_output (int dev, int bsize, int bcount)
 
763
{
 
764
  audigyls_devc *devc = audio_engines[dev]->devc;
 
765
  audigyls_portc *portc = audio_engines[dev]->portc;
 
766
  dmap_p dmap = audio_engines[dev]->dmap_out;
 
767
  unsigned int tmp, reg;
 
768
  oss_native_word flags;
 
769
 
 
770
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
771
  if (portc->bits == AFMT_AC3)
 
772
    portc->channels = 2;
 
773
 
 
774
  write_reg (devc, PTBA, portc->play_port, 0);
 
775
  write_reg (devc, PTBS, portc->play_port, 0);
 
776
  write_reg (devc, PTCA, portc->play_port, 0);
 
777
 
 
778
  write_reg (devc, CPFA, portc->play_port, 0);
 
779
  write_reg (devc, PFEA, portc->play_port, 0);
 
780
  write_reg (devc, CPCAV, portc->play_port, 0);
 
781
 
 
782
 
 
783
  /* set 16/24 bits */
 
784
  tmp = INL (devc->osdev, devc->base + 0x14);
 
785
  if (portc->bits == AFMT_S16_LE)
 
786
    tmp &= ~0x800;              /*16 bit */
 
787
  else
 
788
    tmp |= 0x800;               /*24 bit */
 
789
  OUTL (devc->osdev, tmp, devc->base + 0x14);
 
790
 
 
791
  /* set playback rate */
 
792
  tmp = read_reg (devc, SA, 0) & ~0xff0000;
 
793
  reg = read_reg (devc, SRCTL, 0) & ~0x0303000f;
 
794
#if 0
 
795
  switch (portc->speed)
 
796
    {
 
797
    case 48000:
 
798
      tmp |= 0;
 
799
      reg |= 0;
 
800
      break;
 
801
 
 
802
    case 44100:
 
803
      tmp |= 0x10000;
 
804
      reg |= 0x01010005;
 
805
      break;
 
806
 
 
807
    case 96000:
 
808
      tmp |= 0x20000;
 
809
      reg |= 0x0202000a;
 
810
      break;
 
811
 
 
812
    case 192000:
 
813
      tmp |= 0x30000;
 
814
      reg |= 0x0303000f;
 
815
      break;
 
816
 
 
817
    default:
 
818
      tmp |= 0;                 /* default is 48000 */
 
819
      reg |= 0;
 
820
      break;
 
821
    }
 
822
#endif
 
823
  write_reg (devc, SA, 0, tmp << (portc->play_port * 2));
 
824
  write_reg (devc, SRCTL, 0, reg);
 
825
 
 
826
  /* Single buffering mode */
 
827
  write_reg (devc, PFBA, portc->play_port, dmap->dmabuf_phys);
 
828
  write_reg (devc, PFBS, portc->play_port, (dmap->bytes_in_use) << 16);
 
829
 
 
830
  if (audigyls_spdif_enable)
 
831
    {
 
832
      if (portc->bits == AFMT_AC3)
 
833
        {
 
834
          audigyls_ac97_write (devc, 0x1c, 0x8000);
 
835
          write_reg (devc, SCS3, 0, 0x02108006);        /* Non Audio */
 
836
#if 0
 
837
          write_reg (devc, SCS0, 0, 0x02108006);        /* Non Audio */
 
838
          write_reg (devc, SCS1, 0, 0x02108006);        /* Non Audio */
 
839
          write_reg (devc, SCS2, 0, 0x02108006);        /* Non Audio */
 
840
#endif
 
841
        }
 
842
      else
 
843
        {
 
844
          write_reg (devc, SCS3, 0, 0x02108004);        /* Audio */
 
845
#if 0
 
846
          write_reg (devc, SCS0, 0, 0x02108004);        /* Audio */
 
847
          write_reg (devc, SCS1, 0, 0x02108004);        /* Audio */
 
848
          write_reg (devc, SCS2, 0, 0x02108004);        /* Audio */
 
849
#endif
 
850
        }
 
851
    }
 
852
  portc->audio_enabled |= PCM_ENABLE_OUTPUT;
 
853
  portc->trigger_bits &= ~PCM_ENABLE_OUTPUT;
 
854
 
 
855
#ifdef USE_ITIMER
 
856
  adjust_itimer (devc, portc, dmap);
 
857
#endif
 
858
 
 
859
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
860
  return 0;
 
861
}
 
862
 
 
863
static int
 
864
audigyls_get_buffer_pointer (int dev, dmap_t * dmap, int direction)
 
865
{
 
866
  unsigned int p = 0;
 
867
  audigyls_portc *portc = audio_engines[dev]->portc;
 
868
 
 
869
#if 1
 
870
  audigyls_devc *devc = audio_engines[dev]->devc;
 
871
 
 
872
  if (direction == PCM_ENABLE_OUTPUT)
 
873
    {
 
874
      p = read_reg (devc, CPFA, portc->play_port);
 
875
    }
 
876
 
 
877
  if (direction == PCM_ENABLE_INPUT)
 
878
    {
 
879
      p = read_reg (devc, CRFA, portc->rec_port);
 
880
    }
 
881
 
 
882
  /*
 
883
   * Round to the nearest fragment boundary.
 
884
   */
 
885
  p = (p + dmap->fragment_size / 2);
 
886
  p = (p / dmap->fragment_size) * dmap->fragment_size;
 
887
#else
 
888
  if (direction == PCM_ENABLE_OUTPUT)
 
889
    {
 
890
      return portc->play_ptr;
 
891
    }
 
892
 
 
893
  if (direction == PCM_ENABLE_INPUT)
 
894
    {
 
895
      return portc->rec_ptr;
 
896
    }
 
897
#endif
 
898
 
 
899
  return p % dmap->bytes_in_use;
 
900
}
 
901
 
 
902
static audiodrv_t audigyls_audio_driver = {
 
903
  audigyls_open,
 
904
  audigyls_close,
 
905
  audigyls_output_block,
 
906
  audigyls_start_input,
 
907
  audigyls_ioctl,
 
908
  audigyls_prepare_for_input,
 
909
  audigyls_prepare_for_output,
 
910
  audigyls_reset,
 
911
  NULL,
 
912
  NULL,
 
913
  NULL,
 
914
  NULL,
 
915
  audigyls_trigger,
 
916
  audigyls_set_rate,
 
917
  audigyls_set_format,
 
918
  audigyls_set_channels,
 
919
  NULL,
 
920
  NULL,
 
921
  NULL,
 
922
  NULL,
 
923
  NULL,                         /* audigyls_alloc_buffer, */
 
924
  NULL,                         /* audigyls_free_buffer */
 
925
  NULL,
 
926
  NULL,
 
927
  audigyls_get_buffer_pointer
 
928
};
 
929
 
 
930
 
 
931
static __inline__ int
 
932
audigylsuart_status (audigyls_devc * devc)
 
933
{
 
934
  return read_reg (devc, MUCMDA, 0);
 
935
}
 
936
 
 
937
#define input_avail(devc) (!(audigylsuart_status(devc)&INPUT_AVAIL))
 
938
#define output_ready(devc)      (!(audigylsuart_status(devc)&OUTPUT_READY))
 
939
static void
 
940
audigylsuart_cmd (audigyls_devc * devc, unsigned char cmd)
 
941
{
 
942
  write_reg (devc, MUCMDA, 0, cmd);
 
943
}
 
944
 
 
945
static __inline__ int
 
946
audigylsuart_read (audigyls_devc * devc)
 
947
{
 
948
  return read_reg (devc, MUDATA, 0);
 
949
}
 
950
 
 
951
static __inline__ void
 
952
audigylsuart_write (audigyls_devc * devc, unsigned char byte)
 
953
{
 
954
  write_reg (devc, MUDATA, 0, byte);
 
955
}
 
956
 
 
957
#define OUTPUT_READY    0x40
 
958
#define INPUT_AVAIL     0x80
 
959
#define MPU_ACK         0xFE
 
960
#define MPU_RESET       0xFF
 
961
#define UART_MODE_ON    0x3F
 
962
 
 
963
static int reset_audigylsuart (audigyls_devc * devc);
 
964
static void enter_uart_mode (audigyls_devc * devc);
 
965
 
 
966
static void
 
967
audigylsuart_input_loop (audigyls_devc * devc)
 
968
{
 
969
  while (input_avail (devc))
 
970
    {
 
971
      unsigned char c = audigylsuart_read (devc);
 
972
 
 
973
      if (c == MPU_ACK)
 
974
        devc->input_byte = c;
 
975
      else if (devc->midi_opened & OPEN_READ && devc->midi_input_intr)
 
976
        devc->midi_input_intr (devc->midi_dev, c);
 
977
    }
 
978
}
 
979
 
 
980
static void
 
981
audigylsuartintr (audigyls_devc * devc)
 
982
{
 
983
  audigylsuart_input_loop (devc);
 
984
}
 
985
 
 
986
/*ARGSUSED*/
 
987
static int
 
988
audigylsuart_open (int dev, int mode, oss_midi_inputbyte_t inputbyte,
 
989
                   oss_midi_inputbuf_t inputbuf,
 
990
                   oss_midi_outputintr_t outputintr)
 
991
{
 
992
  audigyls_devc *devc = (audigyls_devc *) midi_devs[dev]->devc;
 
993
 
 
994
  if (devc->midi_opened)
 
995
    {
 
996
      return OSS_EBUSY;
 
997
    }
 
998
 
 
999
  while (input_avail (devc))
 
1000
    audigylsuart_read (devc);
 
1001
 
 
1002
  devc->midi_input_intr = inputbyte;
 
1003
  devc->midi_opened = mode;
 
1004
  enter_uart_mode (devc);
 
1005
  devc->midi_disabled = 0;
 
1006
 
 
1007
  return 0;
 
1008
}
 
1009
 
 
1010
/*ARGSUSED*/
 
1011
static void
 
1012
audigylsuart_close (int dev, int mode)
 
1013
{
 
1014
  audigyls_devc *devc = (audigyls_devc *) midi_devs[dev]->devc;
 
1015
  reset_audigylsuart (devc);
 
1016
  oss_udelay (10);
 
1017
  enter_uart_mode (devc);
 
1018
  reset_audigylsuart (devc);
 
1019
  devc->midi_opened = 0;
 
1020
}
 
1021
 
 
1022
 
 
1023
static int
 
1024
audigylsuart_out (int dev, unsigned char midi_byte)
 
1025
{
 
1026
  int timeout;
 
1027
  audigyls_devc *devc = (audigyls_devc *) midi_devs[dev]->devc;
 
1028
  oss_native_word flags;
 
1029
 
 
1030
  /*
 
1031
   * Test for input since pending input seems to block the output.
 
1032
   */
 
1033
 
 
1034
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
1035
 
 
1036
  if (input_avail (devc))
 
1037
    audigylsuart_input_loop (devc);
 
1038
 
 
1039
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
1040
 
 
1041
  /*
 
1042
   * Sometimes it takes about 130000 loops before the output becomes ready
 
1043
   * (After reset). Normally it takes just about 10 loops.
 
1044
   */
 
1045
 
 
1046
  for (timeout = 130000; timeout > 0 && !output_ready (devc); timeout--);
 
1047
 
 
1048
  if (!output_ready (devc))
 
1049
    {
 
1050
      cmn_err (CE_WARN, "UART timeout - Device not responding\n");
 
1051
      devc->midi_disabled = 1;
 
1052
      reset_audigylsuart (devc);
 
1053
      enter_uart_mode (devc);
 
1054
      return 1;
 
1055
    }
 
1056
 
 
1057
  audigylsuart_write (devc, midi_byte);
 
1058
  return 1;
 
1059
}
 
1060
 
 
1061
/*ARGSUSED*/
 
1062
static int
 
1063
audigylsuart_ioctl (int dev, unsigned cmd, ioctl_arg arg)
 
1064
{
 
1065
  return OSS_EINVAL;
 
1066
}
 
1067
 
 
1068
static midi_driver_t audigyls_midi_driver = {
 
1069
  audigylsuart_open,
 
1070
  audigylsuart_close,
 
1071
  audigylsuart_ioctl,
 
1072
  audigylsuart_out,
 
1073
};
 
1074
 
 
1075
static void
 
1076
enter_uart_mode (audigyls_devc * devc)
 
1077
{
 
1078
  int ok, timeout;
 
1079
  oss_native_word flags;
 
1080
 
 
1081
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
1082
  for (timeout = 30000; timeout > 0 && !output_ready (devc); timeout--);
 
1083
 
 
1084
  devc->input_byte = 0;
 
1085
  audigylsuart_cmd (devc, UART_MODE_ON);
 
1086
 
 
1087
  ok = 0;
 
1088
  for (timeout = 50000; timeout > 0 && !ok; timeout--)
 
1089
    if (devc->input_byte == MPU_ACK)
 
1090
      ok = 1;
 
1091
    else if (input_avail (devc))
 
1092
      if (audigylsuart_read (devc) == MPU_ACK)
 
1093
        ok = 1;
 
1094
 
 
1095
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
1096
}
 
1097
 
 
1098
 
 
1099
void
 
1100
attach_audigylsuart (audigyls_devc * devc)
 
1101
{
 
1102
  enter_uart_mode (devc);
 
1103
  devc->midi_dev = oss_install_mididev (OSS_MIDI_DRIVER_VERSION, "AUDIGYLS", "AudigyLS UART", &audigyls_midi_driver, sizeof (midi_driver_t),
 
1104
                                        0, devc, devc->osdev);
 
1105
  devc->midi_opened = 0;
 
1106
}
 
1107
 
 
1108
static int
 
1109
reset_audigylsuart (audigyls_devc * devc)
 
1110
{
 
1111
  int ok, timeout, n;
 
1112
 
 
1113
  /*
 
1114
   * Send the RESET command. Try again if no success at the first time.
 
1115
   */
 
1116
 
 
1117
  ok = 0;
 
1118
 
 
1119
  for (n = 0; n < 2 && !ok; n++)
 
1120
    {
 
1121
      for (timeout = 30000; timeout > 0 && !output_ready (devc); timeout--);
 
1122
 
 
1123
      devc->input_byte = 0;
 
1124
      audigylsuart_cmd (devc, MPU_RESET);
 
1125
 
 
1126
      /*
 
1127
       * Wait at least 25 msec. This method is not accurate so let's make the
 
1128
       * loop bit longer. Cannot sleep since this is called during boot.
 
1129
       */
 
1130
 
 
1131
      for (timeout = 50000; timeout > 0 && !ok; timeout--)
 
1132
        if (devc->input_byte == MPU_ACK)        /* Interrupt */
 
1133
          ok = 1;
 
1134
        else if (input_avail (devc))
 
1135
          if (audigylsuart_read (devc) == MPU_ACK)
 
1136
            ok = 1;
 
1137
 
 
1138
    }
 
1139
 
 
1140
 
 
1141
 
 
1142
  if (ok)
 
1143
    audigylsuart_input_loop (devc);     /*
 
1144
                                         * Flush input before enabling interrupts
 
1145
                                         */
 
1146
 
 
1147
  return ok;
 
1148
}
 
1149
 
 
1150
 
 
1151
int
 
1152
probe_audigylsuart (audigyls_devc * devc)
 
1153
{
 
1154
  int ok = 0;
 
1155
  oss_native_word flags;
 
1156
 
 
1157
  DDB (cmn_err (CE_CONT, "Entered probe_audigylsuart\n"));
 
1158
 
 
1159
  devc->midi_input_intr = NULL;
 
1160
  devc->midi_opened = 0;
 
1161
  devc->input_byte = 0;
 
1162
 
 
1163
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
1164
  ok = reset_audigylsuart (devc);
 
1165
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
1166
 
 
1167
  if (ok)
 
1168
    {
 
1169
      DDB (cmn_err (CE_CONT, "Reset UART401 OK\n"));
 
1170
    }
 
1171
  else
 
1172
    {
 
1173
      DDB (cmn_err
 
1174
           (CE_CONT, "Reset UART401 failed (no hardware present?).\n"));
 
1175
      DDB (cmn_err
 
1176
           (CE_CONT, "mpu401 status %02x\n", audigylsuart_status (devc)));
 
1177
    }
 
1178
 
 
1179
  DDB (cmn_err (CE_CONT, "audigylsuart detected OK\n"));
 
1180
  return ok;
 
1181
}
 
1182
 
 
1183
void
 
1184
unload_audigylsuart (audigyls_devc * devc)
 
1185
{
 
1186
  reset_audigylsuart (devc);
 
1187
}
 
1188
 
 
1189
 
 
1190
static void
 
1191
attach_mpu (audigyls_devc * devc)
 
1192
{
 
1193
  devc->mpu_attached = 1;
 
1194
  attach_audigylsuart (devc);
 
1195
}
 
1196
 
 
1197
/* only for SBLive 7.1 */
 
1198
int
 
1199
audigyls_i2c_write (audigyls_devc * devc, int reg, int data)
 
1200
{
 
1201
  int i, timeout, tmp;
 
1202
 
 
1203
 
 
1204
  tmp = (reg << 9 | data) << 16;        /* set the upper 16 bits */
 
1205
  /* first write the command to the data reg */
 
1206
  write_reg (devc, I2C_1, 0, tmp);
 
1207
  for (i = 0; i < 20; i++)
 
1208
    {
 
1209
      tmp = read_reg (devc, I2C_A, 0) & ~0x6fe;
 
1210
      /* see audigyls.pdf for bits */
 
1211
      tmp |= 0x400 | 0x100 | 0x34;
 
1212
      write_reg (devc, I2C_A, 0, tmp);
 
1213
      /* now wait till controller sets valid bit (0x100) to 0 */
 
1214
      timeout = 0;
 
1215
       /*LINTED*/ while (1)
 
1216
        {
 
1217
          tmp = read_reg (devc, I2C_A, 0);
 
1218
          if ((tmp & 0x100) == 0)
 
1219
            break;
 
1220
 
 
1221
          if (timeout > 100)
 
1222
            break;
 
1223
 
 
1224
          timeout++;
 
1225
        }
 
1226
 
 
1227
      /* transaction aborted */
 
1228
      if (tmp & 0x200)
 
1229
        return 0;
 
1230
    }
 
1231
  return 1;
 
1232
}
 
1233
 
 
1234
int
 
1235
audigyls_spi_write (audigyls_devc * devc, int data)
 
1236
{
 
1237
  unsigned int orig;
 
1238
  unsigned int tmp;
 
1239
  int i, valid;
 
1240
 
 
1241
  tmp = read_reg (devc, SPI, 0);
 
1242
  orig = (tmp & ~0x3ffff) | 0x30000;
 
1243
  write_reg (devc, SPI, 0, orig | data);
 
1244
  valid = 0;
 
1245
  /* Wait for status bit to return to 0 */
 
1246
  for (i = 0; i < 1000; i++)
 
1247
    {
 
1248
      oss_udelay (100);
 
1249
      tmp = read_reg (devc, SPI, 0);
 
1250
      if (!(tmp & 0x10000))
 
1251
        {
 
1252
          valid = 1;
 
1253
          break;
 
1254
        }
 
1255
    }
 
1256
  if (!valid)                   /* Timed out */
 
1257
    return 0;
 
1258
 
 
1259
  return 1;
 
1260
}
 
1261
 
 
1262
static unsigned int
 
1263
mix_scale (int left, int right, int bits)
 
1264
{
 
1265
  left = mix_cvt[left];
 
1266
  right = mix_cvt[right];
 
1267
 
 
1268
  return ((left * ((1 << bits) - 1) / 100) << 8) | (right *
 
1269
                                                    ((1 << bits) - 1) / 100);
 
1270
}
 
1271
 
 
1272
static int
 
1273
audigyls_set_volume (audigyls_devc * devc, int codecid, int value)
 
1274
{
 
1275
  audigyls_portc *portc = NULL;
 
1276
  int left, right, i2s_vol;
 
1277
 
 
1278
  portc = &devc->portc[codecid];
 
1279
 
 
1280
  left = value & 0xff;
 
1281
  right = (value >> 8) & 0xff;
 
1282
  if (left > 100)
 
1283
    left = 100;
 
1284
  if (right > 100)
 
1285
    right = 100;
 
1286
  devc->playvol[codecid] = left | (right << 8);
 
1287
 
 
1288
  i2s_vol = 65535 - mix_scale (left, right, 8);
 
1289
  write_reg (devc, MIXVOL_I2S, portc->play_port, (i2s_vol << 16));
 
1290
  return devc->playvol[codecid];
 
1291
}
 
1292
 
 
1293
int
 
1294
audigyls_mix_control (int dev, int ctrl, unsigned int cmd, int value)
 
1295
{
 
1296
  audigyls_devc *devc = mixer_devs[dev]->hw_devc;
 
1297
  int val;
 
1298
 
 
1299
  if (cmd == SNDCTL_MIX_READ)
 
1300
    {
 
1301
      value = 0;
 
1302
      switch (ctrl)
 
1303
        {
 
1304
        case 1:         /* spread */
 
1305
          value = devc->spread;
 
1306
          break;
 
1307
 
 
1308
        case 2:         /* record what you hear */
 
1309
          value = devc->loopback;
 
1310
          break;
 
1311
 
 
1312
        case 3:
 
1313
          {
 
1314
            value = devc->recvol;
 
1315
          }
 
1316
          break;
 
1317
 
 
1318
        case 4: 
 
1319
          value = devc->input_source;
 
1320
          break;
 
1321
        case 5: 
 
1322
          value = devc->captmon; 
 
1323
          break; 
 
1324
        case 7: 
 
1325
          value = devc->fbvol; 
 
1326
          break; 
 
1327
        }
 
1328
    }
 
1329
  if (cmd == SNDCTL_MIX_WRITE)
 
1330
    {
 
1331
      switch (ctrl)
 
1332
        {
 
1333
        case 1:         /* recording source */
 
1334
          devc->spread = value;
 
1335
          if (value)
 
1336
            write_reg (devc, HMIXMAP_I2S, 0, 0x10101010);
 
1337
          else
 
1338
            write_reg (devc, HMIXMAP_I2S, 0, 0x76543210);
 
1339
          break;
 
1340
 
 
1341
        case 2:         /* record what you hear */
 
1342
          devc->loopback = value;
 
1343
          break;
 
1344
 
 
1345
        case 3:
 
1346
          {
 
1347
            val = (255 - value) & 0xff;
 
1348
            write_reg (devc, P17RECVOLL, 0,
 
1349
                       val << 24 | val << 16 | val << 8 | val);
 
1350
            write_reg (devc, P17RECVOLH, 0,
 
1351
                       val << 24 | val << 16 | val << 8 | val);
 
1352
      /* write_reg (devc, SRCTL, 1, 
 
1353
            0xff << 24 | 0xff << 16 | val << 8 | val); */ 
 
1354
            devc->recvol = value & 0xff;
 
1355
          }
 
1356
          break;
 
1357
 
 
1358
        case 4:
 
1359
          { 
 
1360
          switch (value) 
 
1361
            {
 
1362
          case 0:   /* for mic input remove GPIO */ 
 
1363
            {
 
1364
              OUTL (devc->osdev, INL (devc->osdev, devc->base + 0x18) | 0x400,
 
1365
                    devc->base + 0x18);
 
1366
              audigyls_i2c_write (devc, 0x15, 0x2);     /* Mic */
 
1367
            }
 
1368
            break; 
 
1369
          case 1: 
 
1370
            {
 
1371
              OUTL (devc->osdev,
 
1372
                    INL (devc->osdev, devc->base + 0x18) & ~0x400,
 
1373
                    devc->base + 0x18);
 
1374
              audigyls_i2c_write (devc, 0x15, 0x4);     /* Line */
 
1375
            }
 
1376
            break; 
 
1377
          case 2: 
 
1378
            { 
 
1379
              OUTL (devc->osdev, 
 
1380
              INL (devc->osdev, devc->base + 0x18) & ~0x400, 
 
1381
              devc->base + 0x18); 
 
1382
              audigyls_i2c_write (devc, 0x15, 0x8);   /* Aux */ 
 
1383
            } 
 
1384
          break; 
 
1385
            } 
 
1386
          devc->input_source = value;
 
1387
        } 
 
1388
        break; 
 
1389
        case 5: 
 
1390
          { 
 
1391
            devc->captmon = value; 
 
1392
            /* Send analog capture to front speakers */ 
 
1393
            if (value) 
 
1394
              write_reg (devc, SMIXMAP_I2S, 0, 0x76767676); 
 
1395
            else 
 
1396
             write_reg (devc, SMIXMAP_I2S, 0, 0x10101010); 
 
1397
          } 
 
1398
        break; 
 
1399
        case 7: 
 
1400
          { 
 
1401
            /*Set recording monitor volume */ 
 
1402
            val = (255 - value) & 0xff; 
 
1403
            write_reg (devc, SRCTL, 1, val << 8 | val); 
 
1404
            devc->fbvol = value & 0xff; 
 
1405
          } 
 
1406
        break;
 
1407
        }
 
1408
    }
 
1409
  return value;
 
1410
}
 
1411
 
 
1412
static int
 
1413
audigyls_mix_init (int dev)
 
1414
{
 
1415
  int group, err;
 
1416
  audigyls_devc *devc = mixer_devs[dev]->hw_devc;
 
1417
 
 
1418
  if ((group = mixer_ext_create_group (dev, 0, "EXT")) < 0)
 
1419
    return group;
 
1420
 
 
1421
  if ((err = mixer_ext_create_control (dev, group, 1, audigyls_mix_control,
 
1422
                                       MIXT_ONOFF, "Spread", 1,
 
1423
                                       MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
1424
    return err;
 
1425
 
 
1426
  if ((err = mixer_ext_create_control (dev, group, 2, audigyls_mix_control,
 
1427
                                       MIXT_ONOFF, "LOOPBACK", 1,
 
1428
                                       MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
1429
    return err;
 
1430
 
 
1431
 
 
1432
  if ((err = mixer_ext_create_control (dev, group, 3, audigyls_mix_control,
 
1433
                                       MIXT_MONOSLIDER, "RECORDVOL", 255,
 
1434
                                       MIXF_READABLE | MIXF_WRITEABLE |
 
1435
                                       MIXF_RECVOL)) < 0)
 
1436
    return err;
 
1437
 
 
1438
  if (!devc->has_ac97)
 
1439
    {
 
1440
      if ((err =
 
1441
           mixer_ext_create_control (dev, group, 4, audigyls_mix_control,
 
1442
                                     MIXT_ENUM, "RECORDSRC", 3, 
 
1443
                                     MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
1444
        return err;
 
1445
      mixer_ext_set_strings (dev, err, "MIC LINE AUX", 0); 
 
1446
    }
 
1447
  if ((err = mixer_ext_create_control (dev, group, 7, audigyls_mix_control, 
 
1448
                                       MIXT_MONOSLIDER, "monitorvol", 255,
 
1449
                                       MIXF_READABLE | MIXF_WRITEABLE |
 
1450
                                       MIXF_RECVOL)) < 0)
 
1451
    return err;
 
1452
  if ((err = mixer_ext_create_control (dev, group, 5, audigyls_mix_control, 
 
1453
                                       MIXT_ONOFF, "RecMon", 1, 
 
1454
                                       MIXF_READABLE | MIXF_WRITEABLE)) < 0) 
 
1455
    return err; 
 
1456
  return 0;
 
1457
}
 
1458
 
 
1459
static const int bindings[MAX_PORTC] = {
 
1460
  DSP_BIND_FRONT,
 
1461
  DSP_BIND_CENTER_LFE,
 
1462
  DSP_BIND_SURR
 
1463
};
 
1464
 
 
1465
static int
 
1466
install_audio_devices (audigyls_devc * devc)
 
1467
{
 
1468
  int i;
 
1469
  int frontdev = -1;
 
1470
  int adev, flags;
 
1471
  int fmts = AFMT_S16_LE | AFMT_AC3;
 
1472
  static char *names[] = {
 
1473
    "AudigyLS front",
 
1474
    "AudigyLS center/lfe",
 
1475
    "AudigyLS surround"
 
1476
  };
 
1477
 
 
1478
#if 0
 
1479
  if (audigyls_spdif_enable == 1)
 
1480
    n = 2;
 
1481
#endif
 
1482
 
 
1483
  for (i = 0; i < MAX_PORTC; i++)
 
1484
    {
 
1485
      audigyls_portc *portc = &devc->portc[i];
 
1486
 
 
1487
      flags =
 
1488
        ADEV_AUTOMODE | ADEV_16BITONLY | ADEV_STEREOONLY | ADEV_FIXEDRATE;
 
1489
 
 
1490
      switch (i)
 
1491
        {
 
1492
        case 0:
 
1493
          portc->play_port = 0;
 
1494
          portc->rec_port = 2;
 
1495
          flags |= ADEV_DUPLEX;
 
1496
          break;
 
1497
        case 1:
 
1498
          portc->play_port = 1;
 
1499
          portc->rec_port = 2;
 
1500
          flags |= ADEV_NOINPUT;
 
1501
          break;
 
1502
        case 2:
 
1503
          portc->play_port = 3;
 
1504
          portc->rec_port = 2;
 
1505
          flags |= ADEV_NOINPUT;
 
1506
          break;
 
1507
        }
 
1508
 
 
1509
      if ((adev = oss_install_audiodev (OSS_AUDIO_DRIVER_VERSION,
 
1510
                                        devc->osdev,
 
1511
                                        devc->osdev,
 
1512
                                        names[i],
 
1513
                                        &audigyls_audio_driver,
 
1514
                                        sizeof (audiodrv_t),
 
1515
                                        flags, fmts, devc, -1)) < 0)
 
1516
        {
 
1517
          return 0;
 
1518
        }
 
1519
 
 
1520
      if (i == 0)
 
1521
        frontdev = adev;
 
1522
 
 
1523
      audio_engines[adev]->portc = portc;
 
1524
      audio_engines[adev]->max_fragments = 2;
 
1525
      audio_engines[adev]->dmabuf_alloc_flags |= DMABUF_SIZE_16BITS;
 
1526
      audio_engines[adev]->rate_source = frontdev;
 
1527
      audio_engines[adev]->mixer_dev = devc->mixer_dev;
 
1528
      audio_engines[adev]->binding = bindings[i];
 
1529
      if (audio_engines[adev]->flags & ADEV_FIXEDRATE)
 
1530
        {
 
1531
          audio_engines[adev]->fixed_rate = DEFAULT_RATE;
 
1532
          audio_engines[adev]->min_rate = DEFAULT_RATE;
 
1533
          audio_engines[adev]->max_rate = DEFAULT_RATE;
 
1534
        }
 
1535
      else
 
1536
        {
 
1537
          audio_engines[adev]->min_rate = 44100;
 
1538
          audio_engines[adev]->max_rate = 192000;
 
1539
        }
 
1540
      portc->audio_dev = adev;
 
1541
      portc->open_mode = 0;
 
1542
      devc->playvol[i] = 0x3030;
 
1543
      devc->recvol = 128;
 
1544
      portc->bits = AFMT_S16_LE;
 
1545
    }
 
1546
 
 
1547
#ifdef USE_REMUX
 
1548
  if (frontdev >= 0)
 
1549
    {
 
1550
      if (audigyls_spdif_enable && devc->has_ac97)
 
1551
        remux_install ("AudigyLS 4.0 output", devc->osdev, frontdev,
 
1552
                       frontdev + 2, -1, -1);
 
1553
      else
 
1554
        remux_install ("AudigyLS 5.1 output", devc->osdev, frontdev,
 
1555
                       frontdev + 2, frontdev + 1, -1);
 
1556
    }
 
1557
#endif
 
1558
 
 
1559
#ifdef CONFIG_OSS_VMIX
 
1560
          if (frontdev >= 0)
 
1561
             vmix_attach_audiodev(devc->osdev, frontdev, -1, 0);
 
1562
#endif
 
1563
  return 1;
 
1564
}
 
1565
 
 
1566
static void
 
1567
select_out3_mode (audigyls_devc * devc, int mode)
 
1568
{
 
1569
  /*
 
1570
   * Set the out3/spdif combo jack format.
 
1571
   * mode0=analog rear/center, 1=spdif
 
1572
   */
 
1573
 
 
1574
  if (mode == 0)
 
1575
    {
 
1576
      write_reg (devc, SPC, 0, 0x00000f00);
 
1577
    }
 
1578
  else
 
1579
    {
 
1580
      write_reg (devc, SPC, 0, 0x0000000f);
 
1581
    }
 
1582
}
 
1583
 
 
1584
/*ARGSUSED*/
 
1585
static int
 
1586
audigyls_mixer_ioctl (int dev, int audiodev, unsigned int cmd, ioctl_arg arg)
 
1587
{
 
1588
  audigyls_devc *devc = mixer_devs[dev]->devc;
 
1589
 
 
1590
  if (((cmd >> 8) & 0xff) == 'M')
 
1591
    {
 
1592
      int val;
 
1593
 
 
1594
      if (IOC_IS_OUTPUT (cmd))
 
1595
        switch (cmd & 0xff)
 
1596
          {
 
1597
          case SOUND_MIXER_RECSRC:
 
1598
            return *arg = 0;
 
1599
            break;
 
1600
 
 
1601
          case SOUND_MIXER_PCM:
 
1602
            val = *arg;
 
1603
            return *arg = audigyls_set_volume (devc, 0, val);
 
1604
 
 
1605
          case SOUND_MIXER_CENTERVOL:
 
1606
            val = *arg;
 
1607
            return *arg = audigyls_set_volume (devc, 1, val);
 
1608
 
 
1609
          case SOUND_MIXER_REARVOL:
 
1610
            val = *arg;
 
1611
            return *arg = audigyls_set_volume (devc, 2, val);
 
1612
          }
 
1613
      else
 
1614
        switch (cmd & 0xff)     /* Return Parameter */
 
1615
          {
 
1616
          case SOUND_MIXER_RECSRC:
 
1617
          case SOUND_MIXER_RECMASK:
 
1618
            return *arg = 0;
 
1619
            break;
 
1620
 
 
1621
          case SOUND_MIXER_DEVMASK:
 
1622
            return *arg =
 
1623
              SOUND_MASK_PCM | SOUND_MASK_REARVOL | SOUND_MASK_CENTERVOL;
 
1624
            break;
 
1625
 
 
1626
          case SOUND_MIXER_STEREODEVS:
 
1627
            return *arg =
 
1628
              SOUND_MASK_PCM | SOUND_MASK_REARVOL | SOUND_MASK_CENTERVOL;
 
1629
            break;
 
1630
 
 
1631
          case SOUND_MIXER_CAPS:
 
1632
            return *arg = SOUND_CAP_EXCL_INPUT;
 
1633
            break;
 
1634
 
 
1635
          case SOUND_MIXER_PCM:
 
1636
            return *arg = devc->playvol[0];
 
1637
            break;
 
1638
 
 
1639
          case SOUND_MIXER_CENTERVOL:
 
1640
            return *arg = devc->playvol[2];
 
1641
            break;
 
1642
 
 
1643
          case SOUND_MIXER_REARVOL:
 
1644
            return *arg = devc->playvol[3];
 
1645
            break;
 
1646
          }
 
1647
    }
 
1648
  else
 
1649
    return *arg = 0;
 
1650
 
 
1651
  return OSS_EINVAL;
 
1652
}
 
1653
 
 
1654
static mixer_driver_t audigyls_mixer_driver = {
 
1655
  audigyls_mixer_ioctl
 
1656
};
 
1657
 
 
1658
int
 
1659
oss_audigyls_attach (oss_device_t * osdev)
 
1660
{
 
1661
  int tmp, err, i, tries;
 
1662
  unsigned char pci_irq_line, pci_revision;
 
1663
  unsigned short pci_command, vendor, device;
 
1664
  unsigned int pci_ioaddr;
 
1665
  unsigned int subvendor;
 
1666
  audigyls_devc *devc;
 
1667
 
 
1668
  static unsigned int spi_dac[] = {
 
1669
    0x00ff, 0x02ff, 0x0400, 0x530, 0x0622, 0x08ff, 0x0aff, 0x0cff,
 
1670
    0x0eff, 0x10ff, 0x1200, 0x1400, 0x1800, 0x1aff, 0x1cff,
 
1671
    0x1e00,
 
1672
  };
 
1673
 
 
1674
  DDB (cmn_err (CE_WARN, "Entered AUDIGYLS probe routine\n"));
 
1675
 
 
1676
  pci_read_config_word (osdev, PCI_VENDOR_ID, &vendor);
 
1677
  pci_read_config_word (osdev, PCI_DEVICE_ID, &device);
 
1678
 
 
1679
  if (vendor != PCI_VENDOR_ID_CREATIVE ||
 
1680
      device != PCI_DEVICE_ID_CREATIVE_AUDIGYLS)
 
1681
    return 0;
 
1682
 
 
1683
  pci_read_config_dword (osdev, 0x2c, &subvendor);
 
1684
  pci_read_config_byte (osdev, PCI_REVISION_ID, &pci_revision);
 
1685
  pci_read_config_word (osdev, PCI_COMMAND, &pci_command);
 
1686
  pci_read_config_irq (osdev, PCI_INTERRUPT_LINE, &pci_irq_line);
 
1687
  pci_read_config_dword (osdev, PCI_BASE_ADDRESS_0, &pci_ioaddr);
 
1688
 
 
1689
 
 
1690
  if (pci_ioaddr == 0)
 
1691
    {
 
1692
      cmn_err (CE_WARN, "I/O address not assigned by BIOS.\n");
 
1693
      return 0;
 
1694
    }
 
1695
 
 
1696
  if (pci_irq_line == 0)
 
1697
    {
 
1698
      cmn_err (CE_WARN, "IRQ not assigned by BIOS.\n");
 
1699
      return 0;
 
1700
    }
 
1701
 
 
1702
  if ((devc = PMALLOC (osdev, sizeof (*devc))) == NULL)
 
1703
    {
 
1704
      cmn_err (CE_WARN, "Out of memory\n");
 
1705
      return 0;
 
1706
    }
 
1707
 
 
1708
  devc->osdev = osdev;
 
1709
  osdev->devc = devc;
 
1710
  devc->card_name = "AudigyLS";
 
1711
  devc->subvendor = subvendor;
 
1712
 
 
1713
  pci_command |= PCI_COMMAND_MASTER | PCI_COMMAND_IO;
 
1714
  pci_write_config_word (osdev, PCI_COMMAND, pci_command);
 
1715
 
 
1716
  devc->base = MAP_PCI_IOADDR (devc->osdev, 0, pci_ioaddr);
 
1717
  devc->base &= ~0x3;
 
1718
 
 
1719
  MUTEX_INIT (osdev, devc->mutex, MH_DRV);
 
1720
  MUTEX_INIT (osdev, devc->low_mutex, MH_DRV + 1);
 
1721
 
 
1722
  oss_register_device (osdev, devc->card_name);
 
1723
 
 
1724
  if ((err =
 
1725
       oss_register_interrupts (devc->osdev, 0, audigylsintr, NULL)) < 0)
 
1726
    {
 
1727
      cmn_err (CE_WARN, "Can't register interrupt handler, err=%d\n", err);
 
1728
      return 0;
 
1729
    }
 
1730
 
 
1731
 
 
1732
/*
 
1733
 * Init mixer
 
1734
 */
 
1735
  if (subvendor == 0x10021102)  /* original audigyls */
 
1736
    {
 
1737
      devc->mixer_dev = ac97_install (&devc->ac97devc, devc->card_name,
 
1738
                                      audigyls_ac97_read, audigyls_ac97_write,
 
1739
                                      devc, devc->osdev);
 
1740
      devc->has_ac97 = 1;
 
1741
      audigyls_ac97_write (devc, 0x1c, 0x8000);
 
1742
    }
 
1743
  else
 
1744
    {
 
1745
      devc->mixer_dev = oss_install_mixer (OSS_MIXER_DRIVER_VERSION,
 
1746
                                           devc->osdev,
 
1747
                                           devc->osdev,
 
1748
                                           "AudigyLS Mixer",
 
1749
                                           &audigyls_mixer_driver,
 
1750
                                           sizeof (mixer_driver_t), devc);
 
1751
      devc->has_ac97 = 0;       /* no ac97 */
 
1752
      mixer_devs[devc->mixer_dev]->hw_devc = devc;
 
1753
      mixer_devs[devc->mixer_dev]->priority = 1;        /* Possible default mixer candidate */
 
1754
    }
 
1755
 
 
1756
  mixer_ext_set_init_fn (devc->mixer_dev, audigyls_mix_init, 10);
 
1757
 
 
1758
#if 0
 
1759
  write_reg (devc, SCS0, 0, 0x02108504);
 
1760
  write_reg (devc, SCS1, 0, 0x02108504);
 
1761
  write_reg (devc, SCS2, 0, 0x02108504);
 
1762
#endif
 
1763
  write_reg (devc, SCS3, 0, 0x02108504);
 
1764
 
 
1765
  write_reg (devc, AUDCTL, 0, 0x0f0f003f);      /* enable all outputs */
 
1766
 
 
1767
  select_out3_mode (devc, audigyls_spdif_enable);
 
1768
 
 
1769
/**********************************************************************
 
1770
 * In P17, there's 8 GPIO pins.
 
1771
 * GPIO register: 0x00XXYYZZ
 
1772
 * XX: Configure GPIO to be either GPI (0) or GPO (1).
 
1773
 * YY: GPO values, applicable if the pin is configure to be GPO.
 
1774
 * ZZ: GPI values, applicable if the pin is configure to be GPI.
 
1775
 * 
 
1776
 * in SB570, pin 0-4 and 6 is used as GPO and pin 5 and 7 is used as GPI.
 
1777
 * 
 
1778
 * GPO0:
 
1779
 * 1 ==> Analog output
 
1780
 * 0 ==> Digital output
 
1781
 * GPO1:
 
1782
 * 1 ==> Enable output on card
 
1783
 * 0 ==> Diable output on card
 
1784
 * GPO2:
 
1785
 * 1 ==> Enable Mic Bias and Mic Path
 
1786
 * 0 ==> Disable Mic Bias and Mic Path
 
1787
 * GPO3:
 
1788
 * 1 ==> Disable SPDIF-IO output
 
1789
 * 0 ==> Enable SPDIF-IO output
 
1790
 * GPO4 and GPO6:
 
1791
 * DAC sampling rate selection:
 
1792
 * Not applicable to SB570 since DAC is controlled through SPI
 
1793
 * GPI5:
 
1794
 * 1 ==> Front Panel is not connected
 
1795
 * 0 ==> Front Panel is connected
 
1796
 * GPI7:
 
1797
 * 1 ==> Front Panel Headphone is not connected
 
1798
 * 0 ==> Front Panel Headphone is connected
 
1799
 ***********************************************************/
 
1800
 
 
1801
  OUTL (devc->osdev, 0, devc->base + 0x18);     /* GPIO */
 
1802
  if (devc->has_ac97)
 
1803
    OUTL (devc->osdev, 0x005f03a3, devc->base + 0x18);
 
1804
  else
 
1805
    {
 
1806
      /* for SBLive 7.1 */
 
1807
      OUTL (devc->osdev, 0x005f4301, devc->base + 0x18);
 
1808
      audigyls_i2c_write (devc, 0x15, 0x4);
 
1809
      tries = 0;
 
1810
    again:
 
1811
      for (i = 0; i < sizeof (spi_dac); i++)
 
1812
        {
 
1813
          if (!audigyls_spi_write (devc, spi_dac[i]) && tries < 100)
 
1814
            {
 
1815
              tries++;
 
1816
              goto again;
 
1817
            }
 
1818
        }
 
1819
    }
 
1820
 
 
1821
  OUTL (devc->osdev, INTR_PCI | INTR_RXA | INTR_AI, devc->base + IE);
 
1822
  OUTL (devc->osdev, 0x00000009, devc->base + 0x14);    /* Enable audio */
 
1823
 
 
1824
  tmp = read_reg (devc, SRCTL, 0);
 
1825
  if (devc->has_ac97)
 
1826
    tmp |= 0xf0c81000;          /* record src0/src1 from ac97 */
 
1827
  else
 
1828
    tmp |= 0x50c81000;          /* record src0/src1 from I2SIN */
 
1829
  write_reg (devc, SRCTL, 0, tmp);
 
1830
  write_reg (devc, HMIXMAP_I2S, 0, 0x76543210); /* default out route */
 
1831
  install_audio_devices (devc);
 
1832
 
 
1833
  if (devc->has_ac97)           /* only attach midi for AudigyLS */
 
1834
    attach_mpu (devc);
 
1835
 
 
1836
  return 1;
 
1837
}
 
1838
 
 
1839
int
 
1840
oss_audigyls_detach (oss_device_t * osdev)
 
1841
{
 
1842
  unsigned int status;
 
1843
  audigyls_devc *devc = (audigyls_devc *) osdev->devc;
 
1844
 
 
1845
  if (oss_disable_device (osdev) < 0)
 
1846
    return 0;
 
1847
 
 
1848
 
 
1849
  write_reg (devc, SA, 0, 0);
 
1850
  OUTL (devc->osdev, 0x00000000, devc->base + IE);      /* Interrupt disable */
 
1851
  write_reg (devc, AINT_ENABLE, 0, 0);  /* Disable audio interrupts */
 
1852
  status = INL (devc->osdev, devc->base + 0x08);
 
1853
  OUTL (devc->osdev, status, devc->base + 0x08);        /* Acknowledge */
 
1854
  oss_udelay (1000);
 
1855
  if (devc->mpu_attached)
 
1856
    unload_audigylsuart (devc);
 
1857
 
 
1858
  oss_unregister_interrupts (devc->osdev);
 
1859
 
 
1860
  MUTEX_CLEANUP (devc->mutex);
 
1861
  MUTEX_CLEANUP (devc->low_mutex);
 
1862
  UNMAP_PCI_IOADDR (devc->osdev, 0);
 
1863
 
 
1864
  oss_unregister_device (osdev);
 
1865
  return 1;
 
1866
}