← Back to branch summary

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

« back to all changes in this revision

Viewing changes to kernel/drv/oss_digi96/oss_digi96.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_digi96/oss_digi96.c
 
1
/*
 
2
 * Purpose: Driver for RME Digi96 family
 
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_digi96_cfg.h"
 
17
#include "oss_pci.h"
 
18
 
 
19
#define RME_VENDOR_ID2          0x10ee
 
20
#define RME_DIGI96              0x3fc0
 
21
#define RME_DIGI96_8            0x3fc1
 
22
#define RME_DIGI96_PRO          0x3fc2
 
23
#define RME_DIGI96_PAD          0x3fc3
 
24
 
 
25
#define MAX_AUDIO_CHANNEL       2
 
26
 
 
27
/*
 
28
 * Control register pCTRL1
 
29
 */
 
30
#define CTRL1_STARTPLAY         0x00000001
 
31
#define CTRL1_STARTREC          0x00000002
 
32
#define CTRL1_GAIN              0x0000000c
 
33
#define CTRL1_MODE24_PLAY       0x00000010
 
34
#define CTRL1_MODE24_REC        0x00000020
 
35
#define CTRL1_PLAYBM            0x00000040
 
36
#define CTRL1_RECBM             0x00000080
 
37
#define CTRL1_ADAT              0x00000100
 
38
#define CTRL1_FREQ              0x00000600
 
39
#define CTRL1_FREQ32            0x00000200
 
40
#define CTRL1_FREQ44            0x00000400
 
41
#define CTRL1_FREQ48            0x00000600
 
42
#define CTRL1_DS                0x00000800
 
43
#define CTRL1_PRO               0x00001000
 
44
#define CTRL1_EMP               0x00002000
 
45
#define CTRL1_SEL               0x00004000
 
46
#define CTRL1_MASTER            0x00008000
 
47
#define CTRL1_PD                0x00010000
 
48
#define CTRL1_INPUTSEL          0x00060000
 
49
#define CTRL1_INPUTSHIFT                17
 
50
#define CTRL1_THRU              0x07f80000
 
51
#define CTRL1_AC3               0x08000000
 
52
#define CTRL1_MONITOR           0x30000000
 
53
#define CTRL1_ISEL              0x40000000
 
54
#define CTRL1_IDIS              0x80000000
 
55
 
 
56
/*
 
57
 * Control register pCTRL2
 
58
 */
 
59
#define CTRL2_WSEL              0x00000001
 
60
#define CTRL2_ANALOG            0x00000002      /* PAD only */
 
61
#define CTRL2_FREQAD            0x0000001c      /* PAD */
 
62
#define CTRL2_PD2               0x00000020
 
63
#
 
64
/* Next ones are only for new Digi96/8Pro (blue board) and PAD */
 
65
#define CTRL2_DAC_EN            0x00000040
 
66
#define CTRL2_CLATCH            0x00000080
 
67
#define CTRL2_CCLK              0x00000100
 
68
#define CTRL2_CDATA             0x00000200
 
69
/*
 
70
 * For reads from the pPLAYPOS and pRECPOS registers
 
71
 */
 
72
 
 
73
#define POS_PLAYIRQ             0x80000000
 
74
#define POS_AUTOSYNC            0x40000000
 
75
#define POS_FBITS               0x38000000
 
76
#define POS_FSHIFT                      27
 
77
#define POS_ERF                 0x04000000
 
78
#define POS_CONSTANT11          0x03000000
 
79
#define POS_LOCK                0x00800000
 
80
#define POS_DEVID               0x00600000
 
81
#define POS_CONSTANT000         0x008c0000
 
82
#define POS_TOUT                0x00020000
 
83
#define POS_RECIRQ              0x00010000
 
84
#define POS_ADDR                0x000fffff
 
85
 
 
86
typedef struct digi96_portc
 
87
{
 
88
  int open_mode;
 
89
  int audio_dev;
 
90
  int channels, bits;
 
91
  int speed, speedsel;
 
92
  int trigger_bits;
 
93
}
 
94
digi96_portc;
 
95
 
 
96
typedef struct digi96_devc
 
97
{
 
98
  oss_device_t *osdev;
 
99
  oss_mutex_t mutex;
 
100
 
 
101
  char *chip_name;
 
102
  int have_adat;
 
103
  int have_analog;
 
104
  int mode;
 
105
#define MD_SPDIF        0
 
106
#define MD_AES          1
 
107
#define MD_ADAT         2
 
108
 
 
109
  oss_native_word physaddr;
 
110
  char *linaddr;
 
111
  unsigned int *pPLAYBUF;
 
112
  unsigned int *pRECBUF;
 
113
  unsigned int *pCTRL1, ctrl1_bits;
 
114
  unsigned int *pCTRL2, ctrl2_bits;
 
115
  unsigned int *pPLAYACK;
 
116
  unsigned int *pRECACK;
 
117
  unsigned int *pPLAYPOS;
 
118
  unsigned int *pRECPOS;
 
119
  unsigned int *pRESETPLAY;
 
120
  unsigned int *pRESETREC;
 
121
 
 
122
  int irq;
 
123
 
 
124
  digi96_portc portc[MAX_AUDIO_CHANNEL];
 
125
  int open_mode;
 
126
#define TY_READ 0
 
127
#define TY_WRITE 1
 
128
#define TY_BOTH 2
 
129
  int mixer_dev;
 
130
 
 
131
  int master;
 
132
  int external_locked;
 
133
  int input_source;
 
134
  int doublespeed;
 
135
  int adatrate;
 
136
}
 
137
digi96_devc;
 
138
 
 
139
static int fbit_tab[8] = {
 
140
  0, 0, 0, 96000, 88200, 48000, 44100, 32000
 
141
};
 
142
 
 
143
 
 
144
static void
 
145
write_ctrl1 (digi96_devc * devc, unsigned int ctrl)
 
146
{
 
147
  devc->ctrl1_bits = ctrl;
 
148
 
 
149
  PCI_WRITEL (devc->osdev, devc->pCTRL1, ctrl);
 
150
}
 
151
 
 
152
static void
 
153
write_ctrl2 (digi96_devc * devc, unsigned int ctrl)
 
154
{
 
155
  devc->ctrl2_bits = ctrl;
 
156
 
 
157
  PCI_WRITEL (devc->osdev, devc->pCTRL2, ctrl);
 
158
}
 
159
 
 
160
static int
 
161
digi96intr (oss_device_t * osdev)
 
162
{
 
163
  int i, serviced = 0;
 
164
  unsigned int playstat, recstat;
 
165
  digi96_devc *devc = (digi96_devc *) osdev->devc;
 
166
  digi96_portc *portc;
 
167
 
 
168
  playstat = PCI_READL (devc->osdev, devc->pPLAYPOS);
 
169
  recstat = PCI_READL (devc->osdev, devc->pRECPOS);
 
170
 
 
171
  for (i = 0; i < 2; i++)
 
172
    {
 
173
      portc = &devc->portc[i];
 
174
 
 
175
      if (playstat & POS_PLAYIRQ)
 
176
        {
 
177
          serviced = 1;
 
178
          PCI_WRITEL (devc->osdev, devc->pPLAYACK, 0);
 
179
          oss_audio_outputintr (portc->audio_dev, 0);
 
180
        }
 
181
 
 
182
      if (recstat & POS_RECIRQ)
 
183
        {
 
184
          serviced = 1;
 
185
          PCI_WRITEL (devc->osdev, devc->pRECACK, 0);
 
186
          oss_audio_inputintr (portc->audio_dev, 0);
 
187
        }
 
188
    }
 
189
  return serviced;
 
190
}
 
191
 
 
192
 
 
193
/***********************************
 
194
 * Audio routines 
 
195
 ***********************************/
 
196
 
 
197
static int
 
198
digi96_set_rate (int dev, int arg)
 
199
{
 
200
  digi96_devc *devc = audio_engines[dev]->devc;
 
201
  digi96_portc *portc = audio_engines[dev]->portc;
 
202
 
 
203
  static int speed_table[6] = { 32000, 44100, 48000, 64000, 88200, 96000 };
 
204
  int i, best = 2, dif, bestdif = 0x7fffffff;
 
205
 
 
206
  if (arg)
 
207
    {
 
208
      if (devc->external_locked || (portc->open_mode & OPEN_READ))
 
209
        arg = portc->speed;     /* Speed locked to input */
 
210
 
 
211
      for (i = 0; i < 6; i++)
 
212
        {
 
213
          if (arg == speed_table[i])    /* Exact match */
 
214
            {
 
215
              portc->speed = arg;
 
216
              portc->speedsel = i;
 
217
              return portc->speed;
 
218
            }
 
219
 
 
220
          dif = arg - speed_table[i];
 
221
          if (dif < 0)
 
222
            dif *= -1;
 
223
          if (dif <= bestdif)
 
224
            {
 
225
              best = i;
 
226
              bestdif = dif;
 
227
            }
 
228
 
 
229
        }
 
230
 
 
231
      portc->speed = speed_table[best];
 
232
      portc->speedsel = best;
 
233
    }
 
234
 
 
235
  return portc->speed;
 
236
}
 
237
 
 
238
static short
 
239
digi96_set_channels (int dev, short arg)
 
240
{
 
241
  digi96_portc *portc = audio_engines[dev]->portc;
 
242
  digi96_devc *devc = audio_engines[dev]->devc;
 
243
 
 
244
  if (arg == 0)
 
245
    return portc->channels;
 
246
 
 
247
  if (devc->mode == MD_ADAT)
 
248
    arg = 8;
 
249
  else
 
250
    arg = 2;
 
251
  return portc->channels = arg;
 
252
}
 
253
 
 
254
static unsigned int
 
255
digi96_set_format (int dev, unsigned int arg)
 
256
{
 
257
  digi96_portc *portc = audio_engines[dev]->portc;
 
258
 
 
259
  if (arg != AFMT_S16_LE && arg != AFMT_AC3 && arg != AFMT_S32_LE)
 
260
    return portc->bits;
 
261
 
 
262
  return portc->bits = arg;
 
263
}
 
264
 
 
265
/*ARGSUSED*/
 
266
static int
 
267
digi96_ioctl (int dev, unsigned int cmd, ioctl_arg arg)
 
268
{
 
269
  return OSS_EINVAL;
 
270
}
 
271
 
 
272
static void digi96_trigger (int dev, int state);
 
273
 
 
274
static void
 
275
digi96_reset (int dev)
 
276
{
 
277
  digi96_trigger (dev, 0);
 
278
}
 
279
 
 
280
static void
 
281
digi96_reset_input (int dev)
 
282
{
 
283
  digi96_portc *portc = audio_engines[dev]->portc;
 
284
  digi96_trigger (dev, portc->trigger_bits & ~PCM_ENABLE_INPUT);
 
285
}
 
286
 
 
287
static void
 
288
digi96_reset_output (int dev)
 
289
{
 
290
  digi96_portc *portc = audio_engines[dev]->portc;
 
291
  digi96_trigger (dev, portc->trigger_bits & ~PCM_ENABLE_OUTPUT);
 
292
}
 
293
 
 
294
static int
 
295
verify_input (digi96_devc * devc, digi96_portc * portc)
 
296
{
 
297
  int i, status, savedstatus;
 
298
  int tmp;
 
299
  oss_native_word flags;
 
300
 
 
301
  tmp = devc->ctrl1_bits & ~CTRL1_INPUTSEL;
 
302
  tmp |= (devc->input_source & 0x3) << CTRL1_INPUTSHIFT;
 
303
  write_ctrl1 (devc, tmp);
 
304
 
 
305
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
306
 
 
307
  i = 0;
 
308
  status = PCI_READL (devc->osdev, devc->pRECPOS);
 
309
 
 
310
  if (status & POS_LOCK)        /* ADAT input */
 
311
    {
 
312
      devc->mode = MD_ADAT;
 
313
      portc->channels = 8;
 
314
 
 
315
      switch (devc->adatrate)
 
316
        {
 
317
        case 0:         /* Autodetect */
 
318
          if (status & POS_AUTOSYNC)
 
319
            portc->speed = 48000;
 
320
          else
 
321
            portc->speed = 44100;
 
322
          DDB (cmn_err
 
323
               (CE_WARN, "ADAT input detected, sr=%d Hz\n", portc->speed));
 
324
          break;
 
325
 
 
326
        case 1:
 
327
          portc->speed = 44100;
 
328
          break;
 
329
 
 
330
        case 2:
 
331
          portc->speed = 48000;
 
332
          break;
 
333
        }
 
334
      MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
335
      return 1;
 
336
    }
 
337
 
 
338
  while (i++ < 100 && status & POS_ERF)
 
339
    {
 
340
      oss_udelay (10);
 
341
      status = PCI_READL (devc->osdev, devc->pRECPOS);
 
342
    }
 
343
 
 
344
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
345
  savedstatus = status;
 
346
 
 
347
  status &= POS_ERF;
 
348
 
 
349
  if (status)
 
350
    cmn_err (CE_WARN, "Cannot sync with the input signal\n");
 
351
  else
 
352
    {
 
353
      int fbits = (savedstatus & POS_FBITS) >> POS_FSHIFT;
 
354
      portc->speed = fbit_tab[fbits];
 
355
      DDB (cmn_err
 
356
           (CE_WARN, "digi96: Measured input sampling rate is %d\n",
 
357
            portc->speed));
 
358
    }
 
359
  return devc->external_locked = !status;
 
360
}
 
361
 
 
362
/*ARGSUSED*/
 
363
static int
 
364
digi96_open (int dev, int mode, int open_flags)
 
365
{
 
366
  unsigned int tmp;
 
367
  digi96_portc *portc = audio_engines[dev]->portc;
 
368
  digi96_devc *devc = audio_engines[dev]->devc;
 
369
  oss_native_word flags;
 
370
 
 
371
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
372
  if (portc->open_mode != 0 || (devc->open_mode & mode))        /* Busy? */
 
373
    {
 
374
      MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
375
      return OSS_EBUSY;
 
376
    }
 
377
 
 
378
  portc->open_mode = mode;
 
379
  devc->open_mode |= mode;
 
380
  portc->audio_dev = dev;
 
381
  portc->trigger_bits = 0;
 
382
 
 
383
  tmp = devc->ctrl1_bits;
 
384
  devc->external_locked = 0;
 
385
  if (devc->master)
 
386
    tmp |= CTRL1_MASTER;
 
387
  else
 
388
    {
 
389
      tmp &= ~CTRL1_MASTER;
 
390
      devc->external_locked = 1;
 
391
    }
 
392
  write_ctrl1 (devc, tmp);
 
393
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
394
 
 
395
  if (devc->external_locked || (portc->open_mode & OPEN_READ))
 
396
    verify_input (devc, portc);
 
397
 
 
398
  if (devc->mode == MD_ADAT)
 
399
    {
 
400
      audio_engines[dev]->min_block = 8 * 1024;
 
401
      audio_engines[dev]->max_block = 8 * 1024;
 
402
      audio_engines[dev]->caps &= ~DSP_CH_MASK;
 
403
      audio_engines[dev]->caps |= DSP_CH_MULTI;
 
404
      audio_engines[dev]->min_channels = 8;
 
405
      audio_engines[dev]->max_channels = 8;
 
406
      write_ctrl1 (devc, devc->ctrl1_bits & ~CTRL1_ISEL);
 
407
    }
 
408
  else
 
409
    {
 
410
      audio_engines[dev]->min_block = 2 * 1024;
 
411
      audio_engines[dev]->max_block = 2 * 1024;
 
412
      audio_engines[dev]->caps &= ~DSP_CH_MASK;
 
413
      audio_engines[dev]->caps |= DSP_CH_STEREO;
 
414
      audio_engines[dev]->min_channels = 2;
 
415
      audio_engines[dev]->max_channels = 2;
 
416
      write_ctrl1 (devc, devc->ctrl1_bits | CTRL1_ISEL);
 
417
    }
 
418
 
 
419
  return 0;
 
420
}
 
421
 
 
422
static void
 
423
digi96_close (int dev, int mode)
 
424
{
 
425
  digi96_devc *devc = audio_engines[dev]->devc;
 
426
  digi96_portc *portc = audio_engines[dev]->portc;
 
427
  oss_native_word flags;
 
428
 
 
429
  digi96_reset (dev);
 
430
  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
 
431
  portc->open_mode = 0;
 
432
  devc->open_mode &= ~mode;
 
433
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
 
434
}
 
435
 
 
436
/*ARGSUSED*/
 
437
static void
 
438
digi96_output_block (int dev, oss_native_word ptr, int count, int fragsize,
 
439
                     int intrflag)
 
440
{
 
441
}
 
442
 
 
443
/*ARGSUSED*/
 
444
static void
 
445
digi96_start_input (int dev, oss_native_word ptr, int count, int fragsize,
 
446
                    int intrflag)
 
447
{
 
448
}
 
449
 
 
450
static void
 
451
digi96_trigger (int dev, int state)
 
452
{
 
453
  digi96_devc *devc = audio_engines[dev]->devc;
 
454
  digi96_portc *portc = audio_engines[dev]->portc;
 
455
  unsigned int tmp = devc->ctrl1_bits;
 
456
 
 
457
  state &= portc->open_mode;
 
458
 
 
459
  if (portc->open_mode & OPEN_WRITE)
 
460
    {
 
461
      if (state & PCM_ENABLE_OUTPUT)
 
462
        tmp |= CTRL1_STARTPLAY;
 
463
      else
 
464
        tmp &= ~CTRL1_STARTPLAY;
 
465
    }
 
466
 
 
467
  if (portc->open_mode & OPEN_READ)
 
468
    {
 
469
      if (state & PCM_ENABLE_INPUT)
 
470
        tmp |= CTRL1_STARTREC;
 
471
      else
 
472
        tmp &= ~CTRL1_STARTREC;
 
473
    }
 
474
 
 
475
  portc->trigger_bits = state;
 
476
  write_ctrl1 (devc, tmp);
 
477
}
 
478
 
 
479
/*ARGSUSED*/
 
480
static int
 
481
digi96_prepare_for_output (int dev, int bsize, int bcount)
 
482
{
 
483
  digi96_devc *devc = audio_engines[dev]->devc;
 
484
  digi96_portc *portc = audio_engines[dev]->portc;
 
485
 
 
486
  int cmd = devc->ctrl1_bits;
 
487
  int doublespeed;
 
488
 
 
489
  PCI_WRITEL (devc->osdev, devc->pRESETPLAY, 0);
 
490
  if (devc->master)
 
491
    cmd |= CTRL1_MASTER;
 
492
  else
 
493
    cmd &= ~CTRL1_MASTER;
 
494
  if (portc->channels == 8)
 
495
    cmd |= CTRL1_ADAT;
 
496
  else
 
497
    cmd &= ~CTRL1_ADAT;
 
498
  write_ctrl1 (devc, cmd);
 
499
 
 
500
  if (!devc->master)
 
501
    {
 
502
      if (!verify_input (devc, portc))
 
503
        return OSS_EIO;
 
504
    }
 
505
 
 
506
  cmd = devc->ctrl1_bits;
 
507
  doublespeed = (portc->speedsel > 3);
 
508
 
 
509
  cmd &= ~(CTRL1_DS | CTRL1_FREQ);
 
510
  if (doublespeed)
 
511
    cmd |= CTRL1_DS;
 
512
 
 
513
  cmd |= ((portc->speedsel % 3) + 1) << 9;
 
514
  write_ctrl1 (devc, cmd);
 
515
 
 
516
  if (doublespeed != devc->doublespeed)
 
517
    {
 
518
      devc->doublespeed = doublespeed;
 
519
      write_ctrl1 (devc, cmd | CTRL1_PD);       /* Reset the DAC */
 
520
    }
 
521
 
 
522
  if (portc->bits == AFMT_AC3)
 
523
    write_ctrl1 (devc, devc->ctrl1_bits | CTRL1_AC3 | CTRL1_PD);
 
524
  else
 
525
    {
 
526
      if (portc->bits == AFMT_S32_LE)
 
527
        {
 
528
          write_ctrl1 (devc, devc->ctrl1_bits | CTRL1_MODE24_PLAY);
 
529
        }
 
530
      else
 
531
        write_ctrl1 (devc, devc->ctrl1_bits & ~(CTRL1_MODE24_PLAY));
 
532
 
 
533
      write_ctrl1 (devc, devc->ctrl1_bits & ~(CTRL1_AC3 | CTRL1_PD));   /* Unmute DAC */
 
534
    }
 
535
  return 0;
 
536
}
 
537
 
 
538
/*ARGSUSED*/
 
539
static int
 
540
digi96_prepare_for_input (int dev, int bsize, int bcount)
 
541
{
 
542
  digi96_devc *devc = audio_engines[dev]->devc;
 
543
  digi96_portc *portc = audio_engines[dev]->portc;
 
544
 
 
545
  int cmd = devc->ctrl1_bits;
 
546
 
 
547
  if (portc->channels == 8)
 
548
    cmd |= CTRL1_ADAT;
 
549
  else
 
550
    cmd &= ~CTRL1_ADAT;
 
551
 
 
552
  if (portc->bits == AFMT_S32_LE)
 
553
    cmd |= CTRL1_MODE24_REC;
 
554
  else
 
555
    cmd &= ~CTRL1_MODE24_REC;
 
556
  write_ctrl1 (devc, cmd);
 
557
 
 
558
  if (!verify_input (devc, portc))
 
559
    return OSS_EIO;
 
560
  PCI_WRITEL (devc->osdev, devc->pRESETREC, 0);
 
561
 
 
562
  return 0;
 
563
}
 
564
 
 
565
static int
 
566
digi96_alloc_buffer (int dev, dmap_t * dmap, int direction)
 
567
{
 
568
  digi96_devc *devc = audio_engines[dev]->devc;
 
569
 
 
570
  if (direction == OPEN_WRITE)
 
571
    {
 
572
      dmap->dmabuf = (void *) devc->pPLAYBUF;
 
573
      dmap->dmabuf_phys = (oss_native_word) devc->pPLAYBUF;
 
574
    }
 
575
  else
 
576
    {
 
577
      dmap->dmabuf = (void *) devc->pRECBUF;
 
578
      dmap->dmabuf_phys = (oss_native_word) devc->pRECBUF;
 
579
    }
 
580
  dmap->buffsize = 64 * 1024;
 
581
 
 
582
  return 0;
 
583
}
 
584
 
 
585
/*ARGSUSED*/
 
586
static int
 
587
digi96_free_buffer (int dev, dmap_t * dmap, int direction)
 
588
{
 
589
  dmap->dmabuf = NULL;
 
590
  dmap->dmabuf_phys = 0;
 
591
  return 0;
 
592
}
 
593
 
 
594
/*ARGSUSED*/
 
595
static void
 
596
digi96_setup_fragments (int dev, dmap_p dmap, int direction)
 
597
{
 
598
  /* Make sure the whole sample RAM is covered by the buffer */
 
599
  dmap->nfrags = dmap->buffsize / dmap->fragment_size;
 
600
}
 
601
 
 
602
static audiodrv_t digi96_driver = {
 
603
  digi96_open,
 
604
  digi96_close,
 
605
  digi96_output_block,
 
606
  digi96_start_input,
 
607
  digi96_ioctl,
 
608
  digi96_prepare_for_input,
 
609
  digi96_prepare_for_output,
 
610
  digi96_reset,
 
611
  NULL,
 
612
  NULL,
 
613
  digi96_reset_input,
 
614
  digi96_reset_output,
 
615
  digi96_trigger,
 
616
  digi96_set_rate,
 
617
  digi96_set_format,
 
618
  digi96_set_channels,
 
619
  NULL,
 
620
  NULL,
 
621
  NULL,
 
622
  NULL,
 
623
  digi96_alloc_buffer,
 
624
  digi96_free_buffer,
 
625
  NULL,
 
626
  NULL,
 
627
  NULL,                         /* digi96_get_buffer_pointer */
 
628
  NULL,
 
629
  NULL,
 
630
  NULL,
 
631
  NULL,
 
632
  NULL,
 
633
  NULL,
 
634
  digi96_setup_fragments
 
635
};
 
636
 
 
637
/*ARGSUSED*/
 
638
static int
 
639
digi96_mixer_ioctl (int dev, int audiodev, unsigned int cmd, ioctl_arg arg)
 
640
{
 
641
  if (cmd == SOUND_MIXER_PRIVATE1)      /* Bogus testing */
 
642
    {
 
643
      int val;
 
644
 
 
645
      val = *arg;
 
646
      return *arg = val;
 
647
    }
 
648
  if (cmd == SOUND_MIXER_READ_DEVMASK ||
 
649
      cmd == SOUND_MIXER_READ_RECMASK || cmd == SOUND_MIXER_READ_RECSRC)
 
650
    return *arg = 0;
 
651
 
 
652
  if (cmd == SOUND_MIXER_READ_VOLUME || cmd == SOUND_MIXER_READ_PCM)
 
653
    return *arg = 100 | (100 << 8);
 
654
  if (cmd == SOUND_MIXER_WRITE_VOLUME || cmd == SOUND_MIXER_WRITE_PCM)
 
655
    return *arg = 100 | (100 << 8);
 
656
  return OSS_EINVAL;
 
657
}
 
658
 
 
659
static mixer_driver_t digi96_mixer_driver = {
 
660
  digi96_mixer_ioctl
 
661
};
 
662
 
 
663
static int
 
664
digi96_set_control (int dev, int ctrl, unsigned int cmd, int value)
 
665
{
 
666
  digi96_devc *devc = mixer_devs[dev]->devc;
 
667
  unsigned int tmp;
 
668
 
 
669
  if (ctrl < 0)
 
670
    return OSS_EINVAL;
 
671
 
 
672
  if (cmd == SNDCTL_MIX_READ)
 
673
    {
 
674
      switch (ctrl)
 
675
        {
 
676
        case 1:
 
677
          return !!devc->master;
 
678
          break;
 
679
 
 
680
        case 2:
 
681
          return devc->input_source;
 
682
          break;
 
683
 
 
684
        case 3:
 
685
          return !!(devc->ctrl1_bits & CTRL1_SEL);
 
686
          break;
 
687
 
 
688
        case 4:
 
689
          return devc->mode;
 
690
          break;
 
691
 
 
692
        case 5:
 
693
          return !!(devc->ctrl2_bits & CTRL2_WSEL);
 
694
          break;
 
695
 
 
696
        case 6:
 
697
          return !!(devc->ctrl1_bits & CTRL1_EMP);
 
698
          break;
 
699
 
 
700
        case 7:
 
701
          return !!(devc->ctrl1_bits & CTRL1_AC3);
 
702
          break;
 
703
 
 
704
        case 8:
 
705
          return devc->adatrate;
 
706
          break;
 
707
        }
 
708
 
 
709
      return OSS_EINVAL;
 
710
    }
 
711
 
 
712
  if (cmd == SNDCTL_MIX_WRITE)
 
713
    {
 
714
      switch (ctrl)
 
715
        {
 
716
        case 1:
 
717
          devc->master = !!value;
 
718
          return !!value;
 
719
          break;
 
720
 
 
721
        case 2:
 
722
          if (value < 0 || value > 3)
 
723
            return OSS_EINVAL;
 
724
 
 
725
          devc->input_source = value;
 
726
          return value;
 
727
          break;
 
728
 
 
729
        case 3:
 
730
          tmp = devc->ctrl1_bits;
 
731
          if (value)
 
732
            tmp |= CTRL1_SEL;
 
733
          else
 
734
            {
 
735
              tmp &= ~(CTRL1_SEL | CTRL1_MASTER);
 
736
              devc->master = 0;
 
737
            }
 
738
          write_ctrl1 (devc, tmp);
 
739
          return value;
 
740
          break;
 
741
 
 
742
        case 4:
 
743
          if (value > 2 || (!devc->have_adat && value > 1))
 
744
            return OSS_EINVAL;
 
745
 
 
746
          devc->mode = value;
 
747
          return value;
 
748
          break;
 
749
 
 
750
        case 5:
 
751
          if (value)
 
752
            {
 
753
              write_ctrl2 (devc, devc->ctrl2_bits | CTRL2_WSEL);
 
754
              return 1;
 
755
            }
 
756
 
 
757
          write_ctrl2 (devc, devc->ctrl2_bits & ~CTRL2_WSEL);
 
758
          return 0;
 
759
          break;
 
760
 
 
761
        case 6:
 
762
          if (value)
 
763
            {
 
764
              write_ctrl1 (devc, devc->ctrl1_bits | CTRL1_EMP);
 
765
              return 1;
 
766
            }
 
767
 
 
768
          write_ctrl1 (devc, devc->ctrl1_bits & ~CTRL1_EMP);
 
769
          return 0;
 
770
          break;
 
771
 
 
772
        case 7:
 
773
          if (value)
 
774
            {
 
775
              write_ctrl1 (devc, devc->ctrl1_bits | CTRL1_AC3);
 
776
              return 1;
 
777
            }
 
778
 
 
779
          write_ctrl1 (devc, devc->ctrl1_bits & ~CTRL1_AC3);
 
780
          return 0;
 
781
          break;
 
782
 
 
783
        case 8:
 
784
          if (value > 2)
 
785
            value = 2;
 
786
          if (value < 0)
 
787
            value = 0;
 
788
 
 
789
          return devc->adatrate = value;
 
790
          break;
 
791
 
 
792
        }
 
793
 
 
794
      return OSS_EINVAL;
 
795
    }
 
796
 
 
797
  return OSS_EINVAL;
 
798
}
 
799
 
 
800
static int
 
801
digi96_mix_init (int dev)
 
802
{
 
803
  /* digi96_devc *devc = mixer_devs[dev]->devc; */
 
804
  int group, err;
 
805
 
 
806
  if ((group = mixer_ext_create_group (dev, 0, "DIGI96")) < 0)
 
807
    return group;
 
808
 
 
809
  if ((err = mixer_ext_create_control (dev, group,
 
810
                                       4, digi96_set_control,
 
811
                                       MIXT_ENUM,
 
812
                                       "DIGI96_MODE", 3,
 
813
                                       MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
814
    return err;
 
815
 
 
816
  if ((err = mixer_ext_create_control (dev, group,
 
817
                                       1, digi96_set_control,
 
818
                                       MIXT_ENUM,
 
819
                                       "DIGI96_SYNC", 2,
 
820
                                       MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
821
    return err;
 
822
 
 
823
  if ((err = mixer_ext_create_control (dev, group,
 
824
                                       2, digi96_set_control,
 
825
                                       MIXT_ENUM,
 
826
                                       "DIGI96_INPUT", 4,
 
827
                                       MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
828
    return err;
 
829
 
 
830
  if ((err = mixer_ext_create_control (dev, group,
 
831
                                       3, digi96_set_control,
 
832
                                       MIXT_ENUM,
 
833
                                       "DIGI96_SEL", 2,
 
834
                                       MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
835
    return err;
 
836
 
 
837
  if ((err = mixer_ext_create_control (dev, group,
 
838
                                       5, digi96_set_control,
 
839
                                       MIXT_ONOFF,
 
840
                                       "DIGI96_WORLDCLK", 1,
 
841
                                       MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
842
    return err;
 
843
 
 
844
  if ((err = mixer_ext_create_control (dev, group,
 
845
                                       6, digi96_set_control,
 
846
                                       MIXT_ONOFF,
 
847
                                       "DIGI96_EMPH", 1,
 
848
                                       MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
849
    return err;
 
850
 
 
851
#if 0
 
852
  if ((err = mixer_ext_create_control (dev, group,
 
853
                                       7, digi96_set_control,
 
854
                                       MIXT_ENUM,
 
855
                                       "DIGI96_DATA", 2,
 
856
                                       MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
857
    return err;
 
858
#endif
 
859
 
 
860
  if ((err = mixer_ext_create_control (dev, group,
 
861
                                       8, digi96_set_control,
 
862
                                       MIXT_ENUM,
 
863
                                       "DIGI96_ADATRATE", 3,
 
864
                                       MIXF_READABLE | MIXF_WRITEABLE)) < 0)
 
865
    return err;
 
866
  mixer_ext_set_strings (dev, err, "AUTO 44100 48000", 0);
 
867
 
 
868
  return 0;
 
869
}
 
870
 
 
871
static int
 
872
attach_channel (digi96_devc * devc, int chnum, char *name,
 
873
                audiodrv_t * drv, int type)
 
874
{
 
875
  int adev;
 
876
  digi96_portc *portc;
 
877
  int opts = ADEV_DUPLEX | ADEV_COLD | ADEV_AUTOMODE | ADEV_NOVIRTUAL;
 
878
 
 
879
  if (chnum < 0 || chnum >= MAX_AUDIO_CHANNEL)
 
880
    return 0;
 
881
 
 
882
  if (type == TY_BOTH)
 
883
    opts = ADEV_SHADOW;
 
884
 
 
885
  portc = &devc->portc[chnum];
 
886
 
 
887
  devc->master = 1;
 
888
  devc->input_source = 0;
 
889
  devc->doublespeed = 0;
 
890
  devc->external_locked = 0;
 
891
 
 
892
  if ((adev = oss_install_audiodev (OSS_AUDIO_DRIVER_VERSION,
 
893
                                    devc->osdev,
 
894
                                    devc->osdev,
 
895
                                    name,
 
896
                                    drv,
 
897
                                    sizeof (audiodrv_t),
 
898
                                    opts,
 
899
                                    AFMT_AC3 | AFMT_S16_LE | AFMT_S32_LE,
 
900
                                    devc, -1)) < 0)
 
901
    {
 
902
      return 0;
 
903
    }
 
904
 
 
905
  audio_engines[adev]->mixer_dev = devc->mixer_dev;
 
906
  audio_engines[adev]->portc = portc;
 
907
  audio_engines[adev]->caps |= DSP_CH_STEREO;
 
908
  audio_engines[adev]->min_block = 2 * 1024;
 
909
  audio_engines[adev]->max_block = 2 * 1024;
 
910
  audio_engines[adev]->min_rate = 32000;
 
911
  audio_engines[adev]->max_rate = 96000;
 
912
  portc->open_mode = 0;
 
913
  devc->open_mode = 0;
 
914
  portc->audio_dev = adev;
 
915
 
 
916
  portc->speed = 48000;
 
917
  portc->speedsel = 3;
 
918
  portc->bits = AFMT_S16_LE;
 
919
  portc->channels = 2;
 
920
  return 1;
 
921
}
 
922
 
 
923
int
 
924
init_digi96 (digi96_devc * devc)
 
925
{
 
926
  int my_mixer;
 
927
  int ret;
 
928
 
 
929
  if ((my_mixer = oss_install_mixer (OSS_MIXER_DRIVER_VERSION,
 
930
                                     devc->osdev,
 
931
                                     devc->osdev,
 
932
                                     "RME Digi96 Control panel",
 
933
                                     &digi96_mixer_driver,
 
934
                                     sizeof (mixer_driver_t), devc)) < 0)
 
935
    {
 
936
 
 
937
      devc->mixer_dev = -1;
 
938
      return 0;
 
939
    }
 
940
  else
 
941
 
 
942
    {
 
943
      mixer_devs[my_mixer]->priority = -1;      /* Don't use as the default mixer */
 
944
      devc->mixer_dev = my_mixer;
 
945
      mixer_ext_set_init_fn (my_mixer, digi96_mix_init, 20);
 
946
    }
 
947
 
 
948
  ret = attach_channel (devc, 0, devc->chip_name, &digi96_driver, 0);
 
949
  if (ret > 0)
 
950
    {
 
951
      ret =
 
952
        attach_channel (devc, 1, devc->chip_name, &digi96_driver, TY_BOTH);
 
953
    }
 
954
 
 
955
/*
 
956
 * Set some defaults
 
957
 */
 
958
  write_ctrl2 (devc, 0);
 
959
  write_ctrl1 (devc, CTRL1_ISEL | CTRL1_FREQ48 | CTRL1_PD);     /* Reset DAC */
 
960
  write_ctrl1 (devc, CTRL1_ISEL | CTRL1_FREQ48 | CTRL1_MASTER | CTRL1_SEL);
 
961
  write_ctrl2 (devc, CTRL2_DAC_EN);     /* Soft unmute the DAC (blue PRO boards) */
 
962
  return ret;
 
963
}
 
964
 
 
965
 
 
966
int
 
967
oss_digi96_attach (oss_device_t * osdev)
 
968
{
 
969
  digi96_devc *devc;
 
970
  unsigned char pci_irq_line, pci_revision /*, pci_latency */ ;
 
971
  unsigned short pci_command, vendor, device;
 
972
  unsigned int pci_ioaddr;
 
973
  int err;
 
974
 
 
975
  DDB (cmn_err (CE_WARN, "Entered Digi96 detect routine\n"));
 
976
 
 
977
  pci_read_config_word (osdev, PCI_VENDOR_ID, &vendor);
 
978
  pci_read_config_word (osdev, PCI_DEVICE_ID, &device);
 
979
  if (vendor != RME_VENDOR_ID2 ||
 
980
      (device != RME_DIGI96_PRO &&
 
981
       device != RME_DIGI96_PAD &&
 
982
       device != RME_DIGI96 && device != RME_DIGI96_8))
 
983
 
 
984
    return 0;
 
985
 
 
986
  pci_read_config_word (osdev, PCI_COMMAND, &pci_command);
 
987
  pci_read_config_byte (osdev, PCI_REVISION_ID, &pci_revision);
 
988
  pci_read_config_irq (osdev, PCI_INTERRUPT_LINE, &pci_irq_line);
 
989
  pci_read_config_dword (osdev, PCI_MEM_BASE_ADDRESS_0, &pci_ioaddr);
 
990
 
 
991
  pci_command |= PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY;
 
992
  pci_write_config_word (osdev, PCI_COMMAND, pci_command);
 
993
 
 
994
  if (pci_ioaddr == 0)
 
995
    {
 
996
      cmn_err (CE_WARN, "BAR0 not initialized by BIOS\n");
 
997
      return 0;
 
998
    }
 
999
 
 
1000
  if ((devc = PMALLOC (osdev, sizeof (*devc))) == NULL)
 
1001
    {
 
1002
      cmn_err (CE_WARN, "Out of memory\n");
 
1003
      return 0;
 
1004
    }
 
1005
 
 
1006
  devc->osdev = osdev;
 
1007
  osdev->devc = devc;
 
1008
  devc->physaddr = pci_ioaddr;
 
1009
 
 
1010
  devc->have_adat = 0;
 
1011
  devc->have_analog = 0;
 
1012
  devc->mode = MD_SPDIF;
 
1013
 
 
1014
  switch (device)
 
1015
    {
 
1016
    case RME_DIGI96:
 
1017
      devc->chip_name = "RME Digi96";
 
1018
      break;
 
1019
 
 
1020
    case RME_DIGI96_8:
 
1021
      devc->chip_name = "RME Digi96/8";
 
1022
      devc->have_adat = 1;
 
1023
      break;
 
1024
 
 
1025
    case RME_DIGI96_PRO:
 
1026
      devc->have_adat = 1;
 
1027
      if (pci_revision < 2)
 
1028
        {
 
1029
          devc->chip_name = "RME Digi96/8 PRO (green)";
 
1030
        }
 
1031
      else
 
1032
        {
 
1033
          devc->chip_name = "RME Digi96/8 PRO (blue)";
 
1034
        }
 
1035
      break;
 
1036
 
 
1037
    case RME_DIGI96_PAD:
 
1038
      devc->have_adat = 1;
 
1039
      devc->have_analog = 1;
 
1040
      devc->chip_name = "RME Digi96/8 PAD";
 
1041
      break;
 
1042
    }
 
1043
 
 
1044
  MUTEX_INIT (devc->osdev, devc->mutex, MH_DRV);
 
1045
 
 
1046
  oss_register_device (osdev, devc->chip_name);
 
1047
 
 
1048
  devc->linaddr =
 
1049
    (char *) MAP_PCI_MEM (devc->osdev, 0, devc->physaddr, 0x60000);
 
1050
  if (devc->linaddr == NULL)
 
1051
    {
 
1052
      cmn_err (CE_WARN, "Can't map PCI registers (0x%08lx)\n",
 
1053
               devc->physaddr);
 
1054
      return 0;
 
1055
    }
 
1056
 
 
1057
  if ((err = oss_register_interrupts (devc->osdev, 0, digi96intr, NULL)) < 0)
 
1058
    {
 
1059
      cmn_err (CE_WARN, "Can't register interrupt handler, err=%d\n", err);
 
1060
      return 0;
 
1061
    }
 
1062
 
 
1063
  devc->pPLAYBUF = (unsigned int *) devc->linaddr;
 
1064
  devc->pRECBUF = (unsigned int *) (devc->linaddr + 0x10000);
 
1065
  devc->pCTRL1 = (unsigned int *) (devc->linaddr + 0x20000);
 
1066
  devc->pCTRL2 = (unsigned int *) (devc->linaddr + 0x20004);
 
1067
  devc->pPLAYACK = (unsigned int *) (devc->linaddr + 0x20008);
 
1068
  devc->pRECACK = (unsigned int *) (devc->linaddr + 0x2000c);
 
1069
  devc->pPLAYPOS = (unsigned int *) (devc->linaddr + 0x20000);
 
1070
  devc->pRECPOS = (unsigned int *) (devc->linaddr + 0x30000);
 
1071
  devc->pRESETPLAY = (unsigned int *) (devc->linaddr + 0x4fffc);
 
1072
  devc->pRESETREC = (unsigned int *) (devc->linaddr + 0x5fffc);
 
1073
 
 
1074
  return init_digi96 (devc);    /* Detected */
 
1075
}
 
1076
 
 
1077
int
 
1078
oss_digi96_detach (oss_device_t * osdev)
 
1079
{
 
1080
  digi96_devc *devc = (digi96_devc *) osdev->devc;
 
1081
 
 
1082
  if (oss_disable_device (osdev) < 0)
 
1083
    return 0;
 
1084
 
 
1085
  write_ctrl2 (devc, 0);        /* Soft mute */
 
1086
 
 
1087
  oss_unregister_interrupts (devc->osdev);
 
1088
 
 
1089
  MUTEX_CLEANUP (devc->mutex);
 
1090
 
 
1091
  UNMAP_PCI_MEM (devc->osdev, 0, devc->physaddr, devc->linaddr, 0x60000);
 
1092
 
 
1093
  oss_unregister_device (devc->osdev);
 
1094
 
 
1095
  return 1;
 
1096
 
 
1097
}