← Back to branch summary

~ubuntu-branches/ubuntu/precise/alsa-driver/precise

« back to all changes in this revision

Viewing changes to alsa-kernel/pci/oxygen/xonar_pcm179x.c

  • Committer: Bazaar Package Importer
  • Author(s): Luke Yelavich
  • Date: 2011-02-21 18:06:40 UTC
  • mfrom: (1.1.15 upstream)
  • Revision ID: james.westby@ubuntu.com-20110221180640-a8p2yxtvgf7xbxub
Tags: 1.0.24+dfsg-0ubuntu1
* New upstream release
* Refreshed patches:
  - distinguish_kernel_makefile_and_source_dirs.patch
  - debian_dfsg_configure.patch
* debian/control: Update Vcs-bzr field to point to new branch location

Show diffs side-by-side

added added

removed removed

Lines of Context:
alsa-kernel/pci/oxygen/xonar_pcm179x.c
22
22
 *
23
23
 * CMI8788:
24
24
 *
25
 
 * SPI 0 -> 1st PCM1796 (front)
26
 
 * SPI 1 -> 2nd PCM1796 (surround)
27
 
 * SPI 2 -> 3rd PCM1796 (center/LFE)
28
 
 * SPI 4 -> 4th PCM1796 (back)
 
25
 *   SPI 0 -> 1st PCM1796 (front)
 
26
 *   SPI 1 -> 2nd PCM1796 (surround)
 
27
 *   SPI 2 -> 3rd PCM1796 (center/LFE)
 
28
 *   SPI 4 -> 4th PCM1796 (back)
29
29
 *
30
 
 * GPIO 2 -> M0 of CS5381
31
 
 * GPIO 3 -> M1 of CS5381
32
 
 * GPIO 5 <- external power present (D2X only)
33
 
 * GPIO 7 -> ALT
34
 
 * GPIO 8 -> enable output to speakers
 
30
 *   GPIO 2 -> M0 of CS5381
 
31
 *   GPIO 3 -> M1 of CS5381
 
32
 *   GPIO 5 <- external power present (D2X only)
 
33
 *   GPIO 7 -> ALT
 
34
 *   GPIO 8 -> enable output to speakers
35
35
 *
36
36
 * CM9780:
37
37
 *
38
 
 * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
 
38
 *   LINE_OUT -> input of ADC
 
39
 *
 
40
 *   AUX_IN   <- aux
 
41
 *   VIDEO_IN <- CD
 
42
 *   FMIC_IN  <- mic
 
43
 *
 
44
 *   GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
39
45
 */
40
46
 
41
47
/*
44
50
 *
45
51
 * CMI8788:
46
52
 *
47
 
 * I²C <-> PCM1796 (front)
48
 
 *
49
 
 * GPI 0 <- external power present
50
 
 *
51
 
 * GPIO 0 -> enable output to speakers
52
 
 * GPIO 2 -> M0 of CS5381
53
 
 * GPIO 3 -> M1 of CS5381
54
 
 * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
55
 
 *
56
 
 * TXD -> HDMI controller
57
 
 * RXD <- HDMI controller
58
 
 *
59
 
 * PCM1796 front: AD1,0 <- 0,0
 
53
 *   I²C <-> PCM1796 (addr 1001100) (front)
 
54
 *
 
55
 *   GPI 0 <- external power present
 
56
 *
 
57
 *   GPIO 0 -> enable HDMI (0) or speaker (1) output
 
58
 *   GPIO 2 -> M0 of CS5381
 
59
 *   GPIO 3 -> M1 of CS5381
 
60
 *   GPIO 4 <- daughterboard detection
 
61
 *   GPIO 5 <- daughterboard detection
 
62
 *   GPIO 6 -> ?
 
63
 *   GPIO 7 -> ?
 
64
 *   GPIO 8 -> route input jack to line-in (0) or mic-in (1)
 
65
 *
 
66
 *   UART <-> HDMI controller
60
67
 *
61
68
 * CM9780:
62
69
 *
63
 
 * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
 
70
 *   LINE_OUT -> input of ADC
 
71
 *
 
72
 *   AUX_IN <- aux
 
73
 *   CD_IN  <- CD
 
74
 *   MIC_IN <- mic
 
75
 *
 
76
 *   GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
64
77
 *
65
78
 * no daughterboard
66
79
 * ----------------
67
80
 *
68
 
 * GPIO 4 <- 1
 
81
 *   GPIO 4 <- 1
69
82
 *
70
83
 * H6 daughterboard
71
84
 * ----------------
72
85
 *
73
 
 * GPIO 4 <- 0
74
 
 * GPIO 5 <- 0
75
 
 *
76
 
 * I²C <-> PCM1796 (surround)
77
 
 *     <-> PCM1796 (center/LFE)
78
 
 *     <-> PCM1796 (back)
79
 
 *
80
 
 * PCM1796 surround:   AD1,0 <- 0,1
81
 
 * PCM1796 center/LFE: AD1,0 <- 1,0
82
 
 * PCM1796 back:       AD1,0 <- 1,1
 
86
 *   GPIO 4 <- 0
 
87
 *   GPIO 5 <- 0
 
88
 *
 
89
 *   I²C <-> PCM1796 (addr 1001101) (surround)
 
90
 *       <-> PCM1796 (addr 1001110) (center/LFE)
 
91
 *       <-> PCM1796 (addr 1001111) (back)
83
92
 *
84
93
 * unknown daughterboard
85
94
 * ---------------------
86
95
 *
87
 
 * GPIO 4 <- 0
88
 
 * GPIO 5 <- 1
89
 
 *
90
 
 * I²C <-> CS4362A (surround, center/LFE, back)
91
 
 *
92
 
 * CS4362A: AD0 <- 0
 
96
 *   GPIO 4 <- 0
 
97
 *   GPIO 5 <- 1
 
98
 *
 
99
 *   I²C <-> CS4362A (addr 0011000) (surround, center/LFE, back)
93
100
 */
94
101
 
95
102
/*
98
105
 *
99
106
 * CMI8788:
100
107
 *
101
 
 * I²C <-> PCM1792A
102
 
 *     <-> CS2000 (ST only)
103
 
 *
104
 
 * ADC1 MCLK -> REF_CLK of CS2000 (ST only)
105
 
 *
106
 
 * GPI 0 <- external power present (STX only)
107
 
 *
108
 
 * GPIO 0 -> enable output to speakers
109
 
 * GPIO 1 -> route HP to front panel (0) or rear jack (1)
110
 
 * GPIO 2 -> M0 of CS5381
111
 
 * GPIO 3 -> M1 of CS5381
112
 
 * GPIO 7 -> route output to speaker jacks (0) or HP (1)
113
 
 * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
 
108
 *   I²C <-> PCM1792A (addr 1001100)
 
109
 *       <-> CS2000 (addr 1001110) (ST only)
 
110
 *
 
111
 *   ADC1 MCLK -> REF_CLK of CS2000 (ST only)
 
112
 *
 
113
 *   GPI 0 <- external power present (STX only)
 
114
 *
 
115
 *   GPIO 0 -> enable output to speakers
 
116
 *   GPIO 1 -> route HP to front panel (0) or rear jack (1)
 
117
 *   GPIO 2 -> M0 of CS5381
 
118
 *   GPIO 3 -> M1 of CS5381
 
119
 *   GPIO 4 <- daughterboard detection
 
120
 *   GPIO 5 <- daughterboard detection
 
121
 *   GPIO 6 -> ?
 
122
 *   GPIO 7 -> route output to speaker jacks (0) or HP (1)
 
123
 *   GPIO 8 -> route input jack to line-in (0) or mic-in (1)
114
124
 *
115
125
 * PCM1792A:
116
126
 *
117
 
 * AD1,0 <- 0,0
118
 
 * SCK <- CLK_OUT of CS2000 (ST only)
119
 
 *
120
 
 * CS2000:
121
 
 *
122
 
 * AD0 <- 0
 
127
 *   SCK <- CLK_OUT of CS2000 (ST only)
123
128
 *
124
129
 * CM9780:
125
130
 *
126
 
 * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
 
131
 *   LINE_OUT -> input of ADC
 
132
 *
 
133
 *   AUX_IN <- aux
 
134
 *   MIC_IN <- mic
 
135
 *
 
136
 *   GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
127
137
 *
128
138
 * H6 daughterboard
129
139
 * ----------------
132
142
 * GPIO 5 <- 0
133
143
 */
134
144
 
 
145
/*
 
146
 * Xonar Xense
 
147
 * -----------
 
148
 *
 
149
 * CMI8788:
 
150
 *
 
151
 *   I²C <-> PCM1796 (addr 1001100) (front)
 
152
 *       <-> CS4362A (addr 0011000) (surround, center/LFE, back)
 
153
 *       <-> CS2000 (addr 1001110)
 
154
 *
 
155
 *   ADC1 MCLK -> REF_CLK of CS2000
 
156
 *
 
157
 *   GPI 0 <- external power present
 
158
 *
 
159
 *   GPIO 0 -> enable output
 
160
 *   GPIO 1 -> route HP to front panel (0) or rear jack (1)
 
161
 *   GPIO 2 -> M0 of CS5381
 
162
 *   GPIO 3 -> M1 of CS5381
 
163
 *   GPIO 4 -> enable output
 
164
 *   GPIO 5 -> enable output
 
165
 *   GPIO 6 -> ?
 
166
 *   GPIO 7 -> route output to HP (0) or speaker (1)
 
167
 *   GPIO 8 -> route input jack to mic-in (0) or line-in (1)
 
168
 *
 
169
 * CM9780:
 
170
 *
 
171
 *   LINE_OUT -> input of ADC
 
172
 *
 
173
 *   AUX_IN   <- aux
 
174
 *   VIDEO_IN <- ?
 
175
 *   FMIC_IN  <- mic
 
176
 *
 
177
 *   GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
 
178
 *   GPO 1 -> route mic-in from input jack (0) or front panel header (1)
 
179
 */
 
180
 
135
181
#include <linux/pci.h>
136
182
#include <linux/delay.h>
137
183
#include <linux/mutex.h>
138
184
#include <sound/ac97_codec.h>
139
185
#include <sound/control.h>
140
186
#include <sound/core.h>
 
187
#include <sound/info.h>
141
188
#include <sound/pcm.h>
142
189
#include <sound/pcm_params.h>
143
190
#include <sound/tlv.h>
155
202
#define GPIO_INPUT_ROUTE        0x0100
156
203
 
157
204
#define GPIO_HDAV_OUTPUT_ENABLE 0x0001
 
205
#define GPIO_HDAV_MAGIC         0x00c0
158
206
 
159
207
#define GPIO_DB_MASK            0x0030
160
208
#define GPIO_DB_H6              0x0000
161
209
 
162
210
#define GPIO_ST_OUTPUT_ENABLE   0x0001
163
211
#define GPIO_ST_HP_REAR         0x0002
 
212
#define GPIO_ST_MAGIC           0x0040
164
213
#define GPIO_ST_HP              0x0080
165
214
 
166
215
#define I2C_DEVICE_PCM1796(i)   (0x98 + ((i) << 1))     /* 10011, ii, /W=0 */
174
223
        unsigned int dacs;
175
224
        u8 pcm1796_regs[4][5];
176
225
        unsigned int current_rate;
177
 
        bool os_128;
 
226
        bool h6;
178
227
        bool hp_active;
179
228
        s8 hp_gain_offset;
180
229
        bool has_cs2000;
181
 
        u8 cs2000_fun_cfg_1;
 
230
        u8 cs2000_regs[0x1f];
 
231
        bool broken_i2c;
182
232
};
183
233
 
184
234
struct xonar_hdav {
237
287
        struct xonar_pcm179x *data = chip->model_data;
238
288
 
239
289
        oxygen_write_i2c(chip, I2C_DEVICE_CS2000, reg, value);
240
 
        if (reg == CS2000_FUN_CFG_1)
241
 
                data->cs2000_fun_cfg_1 = value;
 
290
        data->cs2000_regs[reg] = value;
242
291
}
243
292
 
244
293
static void cs2000_write_cached(struct oxygen *chip, u8 reg, u8 value)
245
294
{
246
295
        struct xonar_pcm179x *data = chip->model_data;
247
296
 
248
 
        if (reg != CS2000_FUN_CFG_1 ||
249
 
            value != data->cs2000_fun_cfg_1)
 
297
        if (value != data->cs2000_regs[reg])
250
298
                cs2000_write(chip, reg, value);
251
299
}
252
300
 
256
304
        unsigned int i;
257
305
        s8 gain_offset;
258
306
 
 
307
        msleep(1);
259
308
        gain_offset = data->hp_active ? data->hp_gain_offset : 0;
260
309
        for (i = 0; i < data->dacs; ++i) {
261
310
                /* set ATLD before ATL/ATR */
270
319
                pcm1796_write(chip, i, 20,
271
320
                              data->pcm1796_regs[0][20 - PCM1796_REG_BASE]);
272
321
                pcm1796_write(chip, i, 21, 0);
 
322
                gain_offset = 0;
273
323
        }
274
324
}
275
325
 
278
328
        struct xonar_pcm179x *data = chip->model_data;
279
329
 
280
330
        data->pcm1796_regs[0][18 - PCM1796_REG_BASE] = PCM1796_MUTE |
281
 
                PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
 
331
                PCM1796_DMF_DISABLED | PCM1796_FMT_24_I2S | PCM1796_ATLD;
282
332
        data->pcm1796_regs[0][19 - PCM1796_REG_BASE] =
283
333
                PCM1796_FLT_SHARP | PCM1796_ATS_1;
284
 
        data->pcm1796_regs[0][20 - PCM1796_REG_BASE] = PCM1796_OS_64;
 
334
        data->pcm1796_regs[0][20 - PCM1796_REG_BASE] =
 
335
                data->h6 ? PCM1796_OS_64 : PCM1796_OS_128;
285
336
        pcm1796_registers_init(chip);
286
337
        data->current_rate = 48000;
287
338
}
327
378
        oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
328
379
                       OXYGEN_2WIRE_LENGTH_8 |
329
380
                       OXYGEN_2WIRE_INTERRUPT_MASK |
330
 
                       OXYGEN_2WIRE_SPEED_FAST);
 
381
                       OXYGEN_2WIRE_SPEED_STANDARD);
331
382
 
332
383
        data->pcm179x.generic.anti_pop_delay = 100;
333
384
        data->pcm179x.generic.output_enable_bit = GPIO_HDAV_OUTPUT_ENABLE;
334
385
        data->pcm179x.generic.ext_power_reg = OXYGEN_GPI_DATA;
335
386
        data->pcm179x.generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
336
387
        data->pcm179x.generic.ext_power_bit = GPI_EXT_POWER;
337
 
        data->pcm179x.dacs = chip->model.private_data ? 4 : 1;
 
388
        data->pcm179x.dacs = chip->model.dac_channels_mixer / 2;
 
389
        data->pcm179x.h6 = chip->model.dac_channels_mixer > 2;
338
390
 
339
391
        pcm1796_init(chip);
340
392
 
341
 
        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_INPUT_ROUTE);
 
393
        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
 
394
                          GPIO_HDAV_MAGIC | GPIO_INPUT_ROUTE);
342
395
        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_INPUT_ROUTE);
343
396
 
344
397
        xonar_init_cs53x1(chip);
355
408
        oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
356
409
                       OXYGEN_2WIRE_LENGTH_8 |
357
410
                       OXYGEN_2WIRE_INTERRUPT_MASK |
358
 
                       OXYGEN_2WIRE_SPEED_FAST);
 
411
                       OXYGEN_2WIRE_SPEED_STANDARD);
359
412
}
360
413
 
361
414
static void xonar_st_init_common(struct oxygen *chip)
362
415
{
363
416
        struct xonar_pcm179x *data = chip->model_data;
364
417
 
365
 
        data->generic.anti_pop_delay = 100;
366
418
        data->generic.output_enable_bit = GPIO_ST_OUTPUT_ENABLE;
367
 
        data->dacs = chip->model.private_data ? 4 : 1;
 
419
        data->dacs = chip->model.dac_channels_mixer / 2;
368
420
        data->hp_gain_offset = 2*-18;
369
421
 
370
422
        pcm1796_init(chip);
371
423
 
372
424
        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
373
 
                          GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
 
425
                          GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR |
 
426
                          GPIO_ST_MAGIC | GPIO_ST_HP);
374
427
        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
375
428
                            GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
376
429
 
399
452
        cs2000_write(chip, CS2000_RATIO_0 + 1, 0x10);
400
453
        cs2000_write(chip, CS2000_RATIO_0 + 2, 0x00);
401
454
        cs2000_write(chip, CS2000_RATIO_0 + 3, 0x00);
402
 
        cs2000_write(chip, CS2000_FUN_CFG_1, data->cs2000_fun_cfg_1);
 
455
        cs2000_write(chip, CS2000_FUN_CFG_1,
 
456
                     data->cs2000_regs[CS2000_FUN_CFG_1]);
403
457
        cs2000_write(chip, CS2000_FUN_CFG_2, 0);
404
458
        cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_EN_DEV_CFG_2);
 
459
        msleep(3); /* PLL lock delay */
405
460
}
406
461
 
407
462
static void xonar_st_init(struct oxygen *chip)
408
463
{
409
464
        struct xonar_pcm179x *data = chip->model_data;
410
465
 
 
466
        data->generic.anti_pop_delay = 100;
 
467
        data->h6 = chip->model.dac_channels_mixer > 2;
411
468
        data->has_cs2000 = 1;
412
 
        data->cs2000_fun_cfg_1 = CS2000_REF_CLK_DIV_1;
 
469
        data->cs2000_regs[CS2000_FUN_CFG_1] = CS2000_REF_CLK_DIV_1;
 
470
        data->broken_i2c = true;
413
471
 
414
472
        oxygen_write16(chip, OXYGEN_I2S_A_FORMAT,
415
 
                       OXYGEN_RATE_48000 | OXYGEN_I2S_FORMAT_I2S |
416
 
                       OXYGEN_I2S_MCLK_128 | OXYGEN_I2S_BITS_16 |
417
 
                       OXYGEN_I2S_MASTER | OXYGEN_I2S_BCLK_64);
 
473
                       OXYGEN_RATE_48000 |
 
474
                       OXYGEN_I2S_FORMAT_I2S |
 
475
                       OXYGEN_I2S_MCLK(data->h6 ? MCLK_256 : MCLK_512) |
 
476
                       OXYGEN_I2S_BITS_16 |
 
477
                       OXYGEN_I2S_MASTER |
 
478
                       OXYGEN_I2S_BCLK_64);
418
479
 
419
480
        xonar_st_init_i2c(chip);
420
481
        cs2000_registers_init(chip);
428
489
        struct xonar_pcm179x *data = chip->model_data;
429
490
 
430
491
        xonar_st_init_i2c(chip);
 
492
        data->generic.anti_pop_delay = 800;
431
493
        data->generic.ext_power_reg = OXYGEN_GPI_DATA;
432
494
        data->generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
433
495
        data->generic.ext_power_bit = GPI_EXT_POWER;
494
556
        xonar_stx_resume(chip);
495
557
}
496
558
 
497
 
static unsigned int mclk_from_rate(struct oxygen *chip, unsigned int rate)
498
 
{
499
 
        struct xonar_pcm179x *data = chip->model_data;
500
 
 
501
 
        if (rate <= 32000)
502
 
                return OXYGEN_I2S_MCLK_512;
503
 
        else if (rate <= 48000 && data->os_128)
504
 
                return OXYGEN_I2S_MCLK_512;
505
 
        else if (rate <= 96000)
506
 
                return OXYGEN_I2S_MCLK_256;
507
 
        else
508
 
                return OXYGEN_I2S_MCLK_128;
509
 
}
510
 
 
511
 
static unsigned int get_pcm1796_i2s_mclk(struct oxygen *chip,
512
 
                                         unsigned int channel,
513
 
                                         struct snd_pcm_hw_params *params)
514
 
{
515
 
        if (channel == PCM_MULTICH)
516
 
                return mclk_from_rate(chip, params_rate(params));
517
 
        else
518
 
                return oxygen_default_i2s_mclk(chip, channel, params);
519
 
}
520
 
 
521
559
static void update_pcm1796_oversampling(struct oxygen *chip)
522
560
{
523
561
        struct xonar_pcm179x *data = chip->model_data;
524
562
        unsigned int i;
525
563
        u8 reg;
526
564
 
527
 
        if (data->current_rate <= 32000)
528
 
                reg = PCM1796_OS_128;
529
 
        else if (data->current_rate <= 48000 && data->os_128)
530
 
                reg = PCM1796_OS_128;
531
 
        else if (data->current_rate <= 96000 || data->os_128)
 
565
        if (data->current_rate <= 48000 && !data->h6)
 
566
                reg = PCM1796_OS_128;
 
567
        else
532
568
                reg = PCM1796_OS_64;
533
 
        else
534
 
                reg = PCM1796_OS_32;
535
569
        for (i = 0; i < data->dacs; ++i)
536
570
                pcm1796_write_cached(chip, i, 20, reg);
537
571
}
541
575
{
542
576
        struct xonar_pcm179x *data = chip->model_data;
543
577
 
 
578
        msleep(1);
544
579
        data->current_rate = params_rate(params);
545
580
        update_pcm1796_oversampling(chip);
546
581
}
557
592
                                     + gain_offset);
558
593
                pcm1796_write_cached(chip, i, 17, chip->dac_volume[i * 2 + 1]
559
594
                                     + gain_offset);
 
595
                gain_offset = 0;
560
596
        }
561
597
}
562
598
 
566
602
        unsigned int i;
567
603
        u8 value;
568
604
 
569
 
        value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
 
605
        value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_I2S | PCM1796_ATLD;
570
606
        if (chip->dac_mute)
571
607
                value |= PCM1796_MUTE;
572
608
        for (i = 0; i < data->dacs; ++i)
579
615
        u8 rate_mclk, reg;
580
616
 
581
617
        switch (rate) {
582
 
                /* XXX Why is the I2S A MCLK half the actual I2S MCLK? */
583
618
        case 32000:
584
 
                rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256;
 
619
        case 64000:
 
620
                rate_mclk = OXYGEN_RATE_32000;
585
621
                break;
586
622
        case 44100:
587
 
                if (data->os_128)
588
 
                        rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
589
 
                else
590
 
                        rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_128;
591
 
                break;
592
 
        default: /* 48000 */
593
 
                if (data->os_128)
594
 
                        rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
595
 
                else
596
 
                        rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_128;
597
 
                break;
598
 
        case 64000:
599
 
                rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256;
600
 
                break;
601
623
        case 88200:
602
 
                rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
 
624
        case 176400:
 
625
                rate_mclk = OXYGEN_RATE_44100;
603
626
                break;
 
627
        default:
 
628
        case 48000:
604
629
        case 96000:
605
 
                rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
606
 
                break;
607
 
        case 176400:
608
 
                rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
609
 
                break;
610
630
        case 192000:
611
 
                rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
 
631
                rate_mclk = OXYGEN_RATE_48000;
612
632
                break;
613
633
        }
 
634
 
 
635
        if (rate <= 96000 && (rate > 48000 || data->h6)) {
 
636
                rate_mclk |= OXYGEN_I2S_MCLK(MCLK_256);
 
637
                reg = CS2000_REF_CLK_DIV_1;
 
638
        } else {
 
639
                rate_mclk |= OXYGEN_I2S_MCLK(MCLK_512);
 
640
                reg = CS2000_REF_CLK_DIV_2;
 
641
        }
 
642
 
614
643
        oxygen_write16_masked(chip, OXYGEN_I2S_A_FORMAT, rate_mclk,
615
644
                              OXYGEN_I2S_RATE_MASK | OXYGEN_I2S_MCLK_MASK);
616
 
        if ((rate_mclk & OXYGEN_I2S_MCLK_MASK) <= OXYGEN_I2S_MCLK_128)
617
 
                reg = CS2000_REF_CLK_DIV_1;
618
 
        else
619
 
                reg = CS2000_REF_CLK_DIV_2;
620
645
        cs2000_write_cached(chip, CS2000_FUN_CFG_1, reg);
 
646
        msleep(3); /* PLL lock delay */
621
647
}
622
648
 
623
649
static void set_st_params(struct oxygen *chip,
652
678
                "Sharp Roll-off", "Slow Roll-off"
653
679
        };
654
680
 
655
 
        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
656
 
        info->count = 1;
657
 
        info->value.enumerated.items = 2;
658
 
        if (info->value.enumerated.item >= 2)
659
 
                info->value.enumerated.item = 1;
660
 
        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
661
 
        return 0;
 
681
        return snd_ctl_enum_info(info, 1, 2, names);
662
682
}
663
683
 
664
684
static int rolloff_get(struct snd_kcontrol *ctl,
706
726
        .put = rolloff_put,
707
727
};
708
728
 
709
 
static int os_128_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
710
 
{
711
 
        static const char *const names[2] = { "64x", "128x" };
712
 
 
713
 
        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
714
 
        info->count = 1;
715
 
        info->value.enumerated.items = 2;
716
 
        if (info->value.enumerated.item >= 2)
717
 
                info->value.enumerated.item = 1;
718
 
        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
719
 
        return 0;
720
 
}
721
 
 
722
 
static int os_128_get(struct snd_kcontrol *ctl,
723
 
                      struct snd_ctl_elem_value *value)
724
 
{
725
 
        struct oxygen *chip = ctl->private_data;
726
 
        struct xonar_pcm179x *data = chip->model_data;
727
 
 
728
 
        value->value.enumerated.item[0] = data->os_128;
729
 
        return 0;
730
 
}
731
 
 
732
 
static int os_128_put(struct snd_kcontrol *ctl,
733
 
                      struct snd_ctl_elem_value *value)
734
 
{
735
 
        struct oxygen *chip = ctl->private_data;
736
 
        struct xonar_pcm179x *data = chip->model_data;
737
 
        int changed;
738
 
 
739
 
        mutex_lock(&chip->mutex);
740
 
        changed = value->value.enumerated.item[0] != data->os_128;
741
 
        if (changed) {
742
 
                data->os_128 = value->value.enumerated.item[0];
743
 
                if (data->has_cs2000)
744
 
                        update_cs2000_rate(chip, data->current_rate);
745
 
                oxygen_write16_masked(chip, OXYGEN_I2S_MULTICH_FORMAT,
746
 
                                      mclk_from_rate(chip, data->current_rate),
747
 
                                      OXYGEN_I2S_MCLK_MASK);
748
 
                update_pcm1796_oversampling(chip);
749
 
        }
750
 
        mutex_unlock(&chip->mutex);
751
 
        return changed;
752
 
}
753
 
 
754
 
static const struct snd_kcontrol_new os_128_control = {
 
729
static const struct snd_kcontrol_new hdav_hdmi_control = {
755
730
        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
756
 
        .name = "DAC Oversampling Playback Enum",
757
 
        .info = os_128_info,
758
 
        .get = os_128_get,
759
 
        .put = os_128_put,
 
731
        .name = "HDMI Playback Switch",
 
732
        .info = snd_ctl_boolean_mono_info,
 
733
        .get = xonar_gpio_bit_switch_get,
 
734
        .put = xonar_gpio_bit_switch_put,
 
735
        .private_value = GPIO_HDAV_OUTPUT_ENABLE | XONAR_GPIO_BIT_INVERT,
760
736
};
761
737
 
762
738
static int st_output_switch_info(struct snd_kcontrol *ctl,
766
742
                "Speakers", "Headphones", "FP Headphones"
767
743
        };
768
744
 
769
 
        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
770
 
        info->count = 1;
771
 
        info->value.enumerated.items = 3;
772
 
        if (info->value.enumerated.item >= 3)
773
 
                info->value.enumerated.item = 2;
774
 
        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
775
 
        return 0;
 
745
        return snd_ctl_enum_info(info, 1, 3, names);
776
746
}
777
747
 
778
748
static int st_output_switch_get(struct snd_kcontrol *ctl,
827
797
                "< 64 ohms", "64-300 ohms", "300-600 ohms"
828
798
        };
829
799
 
830
 
        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
831
 
        info->count = 1;
832
 
        info->value.enumerated.items = 3;
833
 
        if (info->value.enumerated.item > 2)
834
 
                info->value.enumerated.item = 2;
835
 
        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
836
 
        return 0;
 
800
        return snd_ctl_enum_info(info, 1, 3, names);
837
801
}
838
802
 
839
803
static int st_hp_volume_offset_get(struct snd_kcontrol *ctl,
915
879
        return 0;
916
880
}
917
881
 
918
 
static int xonar_st_control_filter(struct snd_kcontrol_new *template)
 
882
static int xonar_st_h6_control_filter(struct snd_kcontrol_new *template)
919
883
{
920
 
        if (!strncmp(template->name, "CD Capture ", 11))
921
 
                return 1; /* no CD input */
 
884
        if (!strncmp(template->name, "Master Playback ", 16))
 
885
                /* no volume/mute, as I²C to the third DAC does not work */
 
886
                return 1;
922
887
        return 0;
923
888
}
924
889
 
925
890
static int add_pcm1796_controls(struct oxygen *chip)
926
891
{
 
892
        struct xonar_pcm179x *data = chip->model_data;
927
893
        int err;
928
894
 
929
 
        err = snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip));
930
 
        if (err < 0)
931
 
                return err;
932
 
        err = snd_ctl_add(chip->card, snd_ctl_new1(&os_128_control, chip));
933
 
        if (err < 0)
934
 
                return err;
 
895
        if (!data->broken_i2c) {
 
896
                err = snd_ctl_add(chip->card,
 
897
                                  snd_ctl_new1(&rolloff_control, chip));
 
898
                if (err < 0)
 
899
                        return err;
 
900
        }
935
901
        return 0;
936
902
}
937
903
 
950
916
 
951
917
static int xonar_hdav_mixer_init(struct oxygen *chip)
952
918
{
953
 
        return add_pcm1796_controls(chip);
 
919
        int err;
 
920
 
 
921
        err = snd_ctl_add(chip->card, snd_ctl_new1(&hdav_hdmi_control, chip));
 
922
        if (err < 0)
 
923
                return err;
 
924
        err = add_pcm1796_controls(chip);
 
925
        if (err < 0)
 
926
                return err;
 
927
        return 0;
954
928
}
955
929
 
956
930
static int xonar_st_mixer_init(struct oxygen *chip)
970
944
        return 0;
971
945
}
972
946
 
 
947
static void dump_pcm1796_registers(struct oxygen *chip,
 
948
                                   struct snd_info_buffer *buffer)
 
949
{
 
950
        struct xonar_pcm179x *data = chip->model_data;
 
951
        unsigned int dac, i;
 
952
 
 
953
        for (dac = 0; dac < data->dacs; ++dac) {
 
954
                snd_iprintf(buffer, "\nPCM1796 %u:", dac + 1);
 
955
                for (i = 0; i < 5; ++i)
 
956
                        snd_iprintf(buffer, " %02x",
 
957
                                    data->pcm1796_regs[dac][i]);
 
958
        }
 
959
        snd_iprintf(buffer, "\n");
 
960
}
 
961
 
 
962
static void dump_cs2000_registers(struct oxygen *chip,
 
963
                                  struct snd_info_buffer *buffer)
 
964
{
 
965
        struct xonar_pcm179x *data = chip->model_data;
 
966
        unsigned int i;
 
967
 
 
968
        if (data->has_cs2000) {
 
969
                snd_iprintf(buffer, "\nCS2000:\n00:   ");
 
970
                for (i = 1; i < 0x10; ++i)
 
971
                        snd_iprintf(buffer, " %02x", data->cs2000_regs[i]);
 
972
                snd_iprintf(buffer, "\n10:");
 
973
                for (i = 0x10; i < 0x1f; ++i)
 
974
                        snd_iprintf(buffer, " %02x", data->cs2000_regs[i]);
 
975
                snd_iprintf(buffer, "\n");
 
976
        }
 
977
}
 
978
 
 
979
static void dump_st_registers(struct oxygen *chip,
 
980
                              struct snd_info_buffer *buffer)
 
981
{
 
982
        dump_pcm1796_registers(chip, buffer);
 
983
        dump_cs2000_registers(chip, buffer);
 
984
}
 
985
 
973
986
static const struct oxygen_model model_xonar_d2 = {
974
987
        .longname = "Asus Virtuoso 200",
975
988
        .chip = "AV200",
979
992
        .cleanup = xonar_d2_cleanup,
980
993
        .suspend = xonar_d2_suspend,
981
994
        .resume = xonar_d2_resume,
982
 
        .get_i2s_mclk = get_pcm1796_i2s_mclk,
983
995
        .set_dac_params = set_pcm1796_params,
984
996
        .set_adc_params = xonar_set_cs53x1_params,
985
997
        .update_dac_volume = update_pcm1796_volume,
986
998
        .update_dac_mute = update_pcm1796_mute,
 
999
        .dump_registers = dump_pcm1796_registers,
987
1000
        .dac_tlv = pcm1796_db_scale,
988
1001
        .model_data_size = sizeof(struct xonar_pcm179x),
989
1002
        .device_config = PLAYBACK_0_TO_I2S |
991
1004
                         CAPTURE_0_FROM_I2S_2 |
992
1005
                         CAPTURE_1_FROM_SPDIF |
993
1006
                         MIDI_OUTPUT |
994
 
                         MIDI_INPUT,
995
 
        .dac_channels = 8,
 
1007
                         MIDI_INPUT |
 
1008
                         AC97_CD_INPUT,
 
1009
        .dac_channels_pcm = 8,
 
1010
        .dac_channels_mixer = 8,
996
1011
        .dac_volume_min = 255 - 2*60,
997
1012
        .dac_volume_max = 255,
998
1013
        .misc_flags = OXYGEN_MISC_MIDI,
999
1014
        .function_flags = OXYGEN_FUNCTION_SPI |
1000
1015
                          OXYGEN_FUNCTION_ENABLE_SPI_4_5,
1001
 
        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
 
1016
        .dac_mclks = OXYGEN_MCLKS(512, 128, 128),
 
1017
        .adc_mclks = OXYGEN_MCLKS(256, 128, 128),
 
1018
        .dac_i2s_format = OXYGEN_I2S_FORMAT_I2S,
1002
1019
        .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1003
1020
};
1004
1021
 
1011
1028
        .suspend = xonar_hdav_suspend,
1012
1029
        .resume = xonar_hdav_resume,
1013
1030
        .pcm_hardware_filter = xonar_hdmi_pcm_hardware_filter,
1014
 
        .get_i2s_mclk = get_pcm1796_i2s_mclk,
1015
1031
        .set_dac_params = set_hdav_params,
1016
1032
        .set_adc_params = xonar_set_cs53x1_params,
1017
1033
        .update_dac_volume = update_pcm1796_volume,
1018
1034
        .update_dac_mute = update_pcm1796_mute,
1019
1035
        .uart_input = xonar_hdmi_uart_input,
1020
1036
        .ac97_switch = xonar_line_mic_ac97_switch,
 
1037
        .dump_registers = dump_pcm1796_registers,
1021
1038
        .dac_tlv = pcm1796_db_scale,
1022
1039
        .model_data_size = sizeof(struct xonar_hdav),
1023
1040
        .device_config = PLAYBACK_0_TO_I2S |
1024
1041
                         PLAYBACK_1_TO_SPDIF |
1025
1042
                         CAPTURE_0_FROM_I2S_2 |
1026
1043
                         CAPTURE_1_FROM_SPDIF,
1027
 
        .dac_channels = 8,
 
1044
        .dac_channels_pcm = 8,
 
1045
        .dac_channels_mixer = 2,
1028
1046
        .dac_volume_min = 255 - 2*60,
1029
1047
        .dac_volume_max = 255,
1030
1048
        .misc_flags = OXYGEN_MISC_MIDI,
1031
1049
        .function_flags = OXYGEN_FUNCTION_2WIRE,
1032
 
        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
 
1050
        .dac_mclks = OXYGEN_MCLKS(512, 128, 128),
 
1051
        .adc_mclks = OXYGEN_MCLKS(256, 128, 128),
 
1052
        .dac_i2s_format = OXYGEN_I2S_FORMAT_I2S,
1033
1053
        .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1034
1054
};
1035
1055
 
1037
1057
        .longname = "Asus Virtuoso 100",
1038
1058
        .chip = "AV200",
1039
1059
        .init = xonar_st_init,
1040
 
        .control_filter = xonar_st_control_filter,
1041
1060
        .mixer_init = xonar_st_mixer_init,
1042
1061
        .cleanup = xonar_st_cleanup,
1043
1062
        .suspend = xonar_st_suspend,
1044
1063
        .resume = xonar_st_resume,
1045
 
        .get_i2s_mclk = get_pcm1796_i2s_mclk,
1046
1064
        .set_dac_params = set_st_params,
1047
1065
        .set_adc_params = xonar_set_cs53x1_params,
1048
1066
        .update_dac_volume = update_pcm1796_volume,
1049
1067
        .update_dac_mute = update_pcm1796_mute,
1050
1068
        .ac97_switch = xonar_line_mic_ac97_switch,
 
1069
        .dump_registers = dump_st_registers,
1051
1070
        .dac_tlv = pcm1796_db_scale,
1052
1071
        .model_data_size = sizeof(struct xonar_pcm179x),
1053
1072
        .device_config = PLAYBACK_0_TO_I2S |
1054
1073
                         PLAYBACK_1_TO_SPDIF |
1055
 
                         CAPTURE_0_FROM_I2S_2,
1056
 
        .dac_channels = 2,
 
1074
                         CAPTURE_0_FROM_I2S_2 |
 
1075
                         AC97_FMIC_SWITCH,
 
1076
        .dac_channels_pcm = 2,
 
1077
        .dac_channels_mixer = 2,
1057
1078
        .dac_volume_min = 255 - 2*60,
1058
1079
        .dac_volume_max = 255,
1059
1080
        .function_flags = OXYGEN_FUNCTION_2WIRE,
1060
 
        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
 
1081
        .dac_mclks = OXYGEN_MCLKS(512, 128, 128),
 
1082
        .adc_mclks = OXYGEN_MCLKS(256, 128, 128),
 
1083
        .dac_i2s_format = OXYGEN_I2S_FORMAT_I2S,
1061
1084
        .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1062
1085
};
1063
1086
 
1083
1106
                        break;
1084
1107
                case GPIO_DB_H6:
1085
1108
                        chip->model.shortname = "Xonar HDAV1.3+H6";
1086
 
                        chip->model.private_data = 1;
 
1109
                        chip->model.dac_channels_mixer = 8;
 
1110
                        chip->model.dac_mclks = OXYGEN_MCLKS(256, 128, 128);
1087
1111
                        break;
1088
1112
                }
1089
1113
                break;
1096
1120
                        break;
1097
1121
                case GPIO_DB_H6:
1098
1122
                        chip->model.shortname = "Xonar ST+H6";
1099
 
                        chip->model.dac_channels = 8;
1100
 
                        chip->model.private_data = 1;
 
1123
                        chip->model.control_filter = xonar_st_h6_control_filter;
 
1124
                        chip->model.dac_channels_pcm = 8;
 
1125
                        chip->model.dac_channels_mixer = 8;
 
1126
                        chip->model.dac_mclks = OXYGEN_MCLKS(256, 128, 128);
1101
1127
                        break;
1102
1128
                }
1103
1129
                break;