← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to sound/pci/oxygen/oxygen.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
sound/pci/oxygen/oxygen.h
 
1
#ifndef OXYGEN_H_INCLUDED
 
2
#define OXYGEN_H_INCLUDED
 
3
 
 
4
#include <linux/mutex.h>
 
5
#include <linux/spinlock.h>
 
6
#include <linux/wait.h>
 
7
#include <linux/workqueue.h>
 
8
#include "oxygen_regs.h"
 
9
 
 
10
/* 1 << PCM_x == OXYGEN_CHANNEL_x */
 
11
#define PCM_A           0
 
12
#define PCM_B           1
 
13
#define PCM_C           2
 
14
#define PCM_SPDIF       3
 
15
#define PCM_MULTICH     4
 
16
#define PCM_AC97        5
 
17
#define PCM_COUNT       6
 
18
 
 
19
#define OXYGEN_MCLKS(f_single, f_double, f_quad) ((MCLK_##f_single << 0) | \
 
20
                                                  (MCLK_##f_double << 2) | \
 
21
                                                  (MCLK_##f_quad   << 4))
 
22
 
 
23
#define OXYGEN_IO_SIZE  0x100
 
24
 
 
25
#define OXYGEN_EEPROM_ID        0x434d  /* "CM" */
 
26
 
 
27
/* model-specific configuration of outputs/inputs */
 
28
#define PLAYBACK_0_TO_I2S       0x0001
 
29
     /* PLAYBACK_0_TO_AC97_0            not implemented */
 
30
#define PLAYBACK_1_TO_SPDIF     0x0004
 
31
#define PLAYBACK_2_TO_AC97_1    0x0008
 
32
#define CAPTURE_0_FROM_I2S_1    0x0010
 
33
#define CAPTURE_0_FROM_I2S_2    0x0020
 
34
     /* CAPTURE_0_FROM_AC97_0           not implemented */
 
35
#define CAPTURE_1_FROM_SPDIF    0x0080
 
36
#define CAPTURE_2_FROM_I2S_2    0x0100
 
37
#define CAPTURE_2_FROM_AC97_1   0x0200
 
38
     /* CAPTURE_3_FROM_I2S_3            not implemented */
 
39
#define MIDI_OUTPUT             0x0800
 
40
#define MIDI_INPUT              0x1000
 
41
#define AC97_CD_INPUT           0x2000
 
42
#define AC97_FMIC_SWITCH        0x4000
 
43
 
 
44
enum {
 
45
        CONTROL_SPDIF_PCM,
 
46
        CONTROL_SPDIF_INPUT_BITS,
 
47
        CONTROL_MIC_CAPTURE_SWITCH,
 
48
        CONTROL_LINE_CAPTURE_SWITCH,
 
49
        CONTROL_CD_CAPTURE_SWITCH,
 
50
        CONTROL_AUX_CAPTURE_SWITCH,
 
51
        CONTROL_COUNT
 
52
};
 
53
 
 
54
#define OXYGEN_PCI_SUBID(sv, sd) \
 
55
        .vendor = PCI_VENDOR_ID_CMEDIA, \
 
56
        .device = 0x8788, \
 
57
        .subvendor = sv, \
 
58
        .subdevice = sd
 
59
 
 
60
#define BROKEN_EEPROM_DRIVER_DATA ((unsigned long)-1)
 
61
#define OXYGEN_PCI_SUBID_BROKEN_EEPROM \
 
62
        OXYGEN_PCI_SUBID(PCI_VENDOR_ID_CMEDIA, 0x8788), \
 
63
        .driver_data = BROKEN_EEPROM_DRIVER_DATA
 
64
 
 
65
struct pci_dev;
 
66
struct pci_device_id;
 
67
struct snd_card;
 
68
struct snd_pcm_substream;
 
69
struct snd_pcm_hardware;
 
70
struct snd_pcm_hw_params;
 
71
struct snd_kcontrol_new;
 
72
struct snd_rawmidi;
 
73
struct snd_info_buffer;
 
74
struct oxygen;
 
75
 
 
76
struct oxygen_model {
 
77
        const char *shortname;
 
78
        const char *longname;
 
79
        const char *chip;
 
80
        void (*init)(struct oxygen *chip);
 
81
        int (*control_filter)(struct snd_kcontrol_new *template);
 
82
        int (*mixer_init)(struct oxygen *chip);
 
83
        void (*cleanup)(struct oxygen *chip);
 
84
        void (*suspend)(struct oxygen *chip);
 
85
        void (*resume)(struct oxygen *chip);
 
86
        void (*pcm_hardware_filter)(unsigned int channel,
 
87
                                    struct snd_pcm_hardware *hardware);
 
88
        void (*set_dac_params)(struct oxygen *chip,
 
89
                               struct snd_pcm_hw_params *params);
 
90
        void (*set_adc_params)(struct oxygen *chip,
 
91
                               struct snd_pcm_hw_params *params);
 
92
        void (*update_dac_volume)(struct oxygen *chip);
 
93
        void (*update_dac_mute)(struct oxygen *chip);
 
94
        void (*update_center_lfe_mix)(struct oxygen *chip, bool mixed);
 
95
        unsigned int (*adjust_dac_routing)(struct oxygen *chip,
 
96
                                           unsigned int play_routing);
 
97
        void (*gpio_changed)(struct oxygen *chip);
 
98
        void (*uart_input)(struct oxygen *chip);
 
99
        void (*ac97_switch)(struct oxygen *chip,
 
100
                            unsigned int reg, unsigned int mute);
 
101
        void (*dump_registers)(struct oxygen *chip,
 
102
                               struct snd_info_buffer *buffer);
 
103
        const unsigned int *dac_tlv;
 
104
        size_t model_data_size;
 
105
        unsigned int device_config;
 
106
        u8 dac_channels_pcm;
 
107
        u8 dac_channels_mixer;
 
108
        u8 dac_volume_min;
 
109
        u8 dac_volume_max;
 
110
        u8 misc_flags;
 
111
        u8 function_flags;
 
112
        u8 dac_mclks;
 
113
        u8 adc_mclks;
 
114
        u16 dac_i2s_format;
 
115
        u16 adc_i2s_format;
 
116
};
 
117
 
 
118
struct oxygen {
 
119
        unsigned long addr;
 
120
        spinlock_t reg_lock;
 
121
        struct mutex mutex;
 
122
        struct snd_card *card;
 
123
        struct pci_dev *pci;
 
124
        struct snd_rawmidi *midi;
 
125
        int irq;
 
126
        void *model_data;
 
127
        unsigned int interrupt_mask;
 
128
        u8 dac_volume[8];
 
129
        u8 dac_mute;
 
130
        u8 pcm_active;
 
131
        u8 pcm_running;
 
132
        u8 dac_routing;
 
133
        u8 spdif_playback_enable;
 
134
        u8 has_ac97_0;
 
135
        u8 has_ac97_1;
 
136
        u32 spdif_bits;
 
137
        u32 spdif_pcm_bits;
 
138
        struct snd_pcm_substream *streams[PCM_COUNT];
 
139
        struct snd_kcontrol *controls[CONTROL_COUNT];
 
140
        struct work_struct spdif_input_bits_work;
 
141
        struct work_struct gpio_work;
 
142
        wait_queue_head_t ac97_waitqueue;
 
143
        union {
 
144
                u8 _8[OXYGEN_IO_SIZE];
 
145
                __le16 _16[OXYGEN_IO_SIZE / 2];
 
146
                __le32 _32[OXYGEN_IO_SIZE / 4];
 
147
        } saved_registers;
 
148
        u16 saved_ac97_registers[2][0x40];
 
149
        unsigned int uart_input_count;
 
150
        u8 uart_input[32];
 
151
        struct oxygen_model model;
 
152
};
 
153
 
 
154
/* oxygen_lib.c */
 
155
 
 
156
int oxygen_pci_probe(struct pci_dev *pci, int index, char *id,
 
157
                     struct module *owner,
 
158
                     const struct pci_device_id *ids,
 
159
                     int (*get_model)(struct oxygen *chip,
 
160
                                      const struct pci_device_id *id
 
161
                                     )
 
162
                    );
 
163
void oxygen_pci_remove(struct pci_dev *pci);
 
164
#ifdef CONFIG_PM
 
165
int oxygen_pci_suspend(struct pci_dev *pci, pm_message_t state);
 
166
int oxygen_pci_resume(struct pci_dev *pci);
 
167
#endif
 
168
void oxygen_pci_shutdown(struct pci_dev *pci);
 
169
 
 
170
/* oxygen_mixer.c */
 
171
 
 
172
int oxygen_mixer_init(struct oxygen *chip);
 
173
void oxygen_update_dac_routing(struct oxygen *chip);
 
174
void oxygen_update_spdif_source(struct oxygen *chip);
 
175
 
 
176
/* oxygen_pcm.c */
 
177
 
 
178
int oxygen_pcm_init(struct oxygen *chip);
 
179
 
 
180
/* oxygen_io.c */
 
181
 
 
182
u8 oxygen_read8(struct oxygen *chip, unsigned int reg);
 
183
u16 oxygen_read16(struct oxygen *chip, unsigned int reg);
 
184
u32 oxygen_read32(struct oxygen *chip, unsigned int reg);
 
185
void oxygen_write8(struct oxygen *chip, unsigned int reg, u8 value);
 
186
void oxygen_write16(struct oxygen *chip, unsigned int reg, u16 value);
 
187
void oxygen_write32(struct oxygen *chip, unsigned int reg, u32 value);
 
188
void oxygen_write8_masked(struct oxygen *chip, unsigned int reg,
 
189
                          u8 value, u8 mask);
 
190
void oxygen_write16_masked(struct oxygen *chip, unsigned int reg,
 
191
                           u16 value, u16 mask);
 
192
void oxygen_write32_masked(struct oxygen *chip, unsigned int reg,
 
193
                           u32 value, u32 mask);
 
194
 
 
195
u16 oxygen_read_ac97(struct oxygen *chip, unsigned int codec,
 
196
                     unsigned int index);
 
197
void oxygen_write_ac97(struct oxygen *chip, unsigned int codec,
 
198
                       unsigned int index, u16 data);
 
199
void oxygen_write_ac97_masked(struct oxygen *chip, unsigned int codec,
 
200
                              unsigned int index, u16 data, u16 mask);
 
201
 
 
202
void oxygen_write_spi(struct oxygen *chip, u8 control, unsigned int data);
 
203
void oxygen_write_i2c(struct oxygen *chip, u8 device, u8 map, u8 data);
 
204
 
 
205
void oxygen_reset_uart(struct oxygen *chip);
 
206
void oxygen_write_uart(struct oxygen *chip, u8 data);
 
207
 
 
208
u16 oxygen_read_eeprom(struct oxygen *chip, unsigned int index);
 
209
void oxygen_write_eeprom(struct oxygen *chip, unsigned int index, u16 value);
 
210
 
 
211
static inline void oxygen_set_bits8(struct oxygen *chip,
 
212
                                    unsigned int reg, u8 value)
 
213
{
 
214
        oxygen_write8_masked(chip, reg, value, value);
 
215
}
 
216
 
 
217
static inline void oxygen_set_bits16(struct oxygen *chip,
 
218
                                     unsigned int reg, u16 value)
 
219
{
 
220
        oxygen_write16_masked(chip, reg, value, value);
 
221
}
 
222
 
 
223
static inline void oxygen_set_bits32(struct oxygen *chip,
 
224
                                     unsigned int reg, u32 value)
 
225
{
 
226
        oxygen_write32_masked(chip, reg, value, value);
 
227
}
 
228
 
 
229
static inline void oxygen_clear_bits8(struct oxygen *chip,
 
230
                                      unsigned int reg, u8 value)
 
231
{
 
232
        oxygen_write8_masked(chip, reg, 0, value);
 
233
}
 
234
 
 
235
static inline void oxygen_clear_bits16(struct oxygen *chip,
 
236
                                       unsigned int reg, u16 value)
 
237
{
 
238
        oxygen_write16_masked(chip, reg, 0, value);
 
239
}
 
240
 
 
241
static inline void oxygen_clear_bits32(struct oxygen *chip,
 
242
                                       unsigned int reg, u32 value)
 
243
{
 
244
        oxygen_write32_masked(chip, reg, 0, value);
 
245
}
 
246
 
 
247
static inline void oxygen_ac97_set_bits(struct oxygen *chip, unsigned int codec,
 
248
                                        unsigned int index, u16 value)
 
249
{
 
250
        oxygen_write_ac97_masked(chip, codec, index, value, value);
 
251
}
 
252
 
 
253
static inline void oxygen_ac97_clear_bits(struct oxygen *chip,
 
254
                                          unsigned int codec,
 
255
                                          unsigned int index, u16 value)
 
256
{
 
257
        oxygen_write_ac97_masked(chip, codec, index, 0, value);
 
258
}
 
259
 
 
260
#endif