Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  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 enum {
 20         CONTROL_SPDIF_PCM,
 21         CONTROL_SPDIF_INPUT_BITS,
 22         CONTROL_MIC_CAPTURE_SWITCH,
 23         CONTROL_LINE_CAPTURE_SWITCH,
 24         CONTROL_CD_CAPTURE_SWITCH,
 25         CONTROL_AUX_CAPTURE_SWITCH,
 26         CONTROL_COUNT
 27 };
 28 
 29 #define OXYGEN_PCI_SUBID(sv, sd) \
 30         .vendor = PCI_VENDOR_ID_CMEDIA, \
 31         .device = 0x8788, \
 32         .subvendor = sv, \
 33         .subdevice = sd
 34 
 35 struct pci_dev;
 36 struct snd_card;
 37 struct snd_pcm_substream;
 38 struct snd_pcm_hardware;
 39 struct snd_pcm_hw_params;
 40 struct snd_kcontrol_new;
 41 struct snd_rawmidi;
 42 struct oxygen_model;
 43 
 44 struct oxygen {
 45         unsigned long addr;
 46         spinlock_t reg_lock;
 47         struct mutex mutex;
 48         struct snd_card *card;
 49         struct pci_dev *pci;
 50         struct snd_rawmidi *midi;
 51         int irq;
 52         const struct oxygen_model *model;
 53         void *model_data;
 54         unsigned int interrupt_mask;
 55         u8 dac_volume[8];
 56         u8 dac_mute;
 57         u8 pcm_active;
 58         u8 pcm_running;
 59         u8 dac_routing;
 60         u8 spdif_playback_enable;
 61         u8 revision;
 62         u8 has_ac97_0;
 63         u8 has_ac97_1;
 64         u32 spdif_bits;
 65         u32 spdif_pcm_bits;
 66         struct snd_pcm_substream *streams[PCM_COUNT];
 67         struct snd_kcontrol *controls[CONTROL_COUNT];
 68         struct work_struct spdif_input_bits_work;
 69         struct work_struct gpio_work;
 70         wait_queue_head_t ac97_waitqueue;
 71 };
 72 
 73 struct oxygen_model {
 74         const char *shortname;
 75         const char *longname;
 76         const char *chip;
 77         struct module *owner;
 78         void (*init)(struct oxygen *chip);
 79         int (*control_filter)(struct snd_kcontrol_new *template);
 80         int (*mixer_init)(struct oxygen *chip);
 81         void (*cleanup)(struct oxygen *chip);
 82         void (*pcm_hardware_filter)(unsigned int channel,
 83                                     struct snd_pcm_hardware *hardware);
 84         void (*set_dac_params)(struct oxygen *chip,
 85                                struct snd_pcm_hw_params *params);
 86         void (*set_adc_params)(struct oxygen *chip,
 87                                struct snd_pcm_hw_params *params);
 88         void (*update_dac_volume)(struct oxygen *chip);
 89         void (*update_dac_mute)(struct oxygen *chip);
 90         void (*ac97_switch_hook)(struct oxygen *chip, unsigned int codec,
 91                                  unsigned int reg, int mute);
 92         void (*gpio_changed)(struct oxygen *chip);
 93         size_t model_data_size;
 94         u8 dac_channels;
 95         u8 used_channels;
 96         u8 function_flags;
 97         u16 dac_i2s_format;
 98         u16 adc_i2s_format;
 99 };
100 
101 /* oxygen_lib.c */
102 
103 int oxygen_pci_probe(struct pci_dev *pci, int index, char *id, int midi,
104                      const struct oxygen_model *model);
105 void oxygen_pci_remove(struct pci_dev *pci);
106 
107 /* oxygen_mixer.c */
108 
109 int oxygen_mixer_init(struct oxygen *chip);
110 void oxygen_update_dac_routing(struct oxygen *chip);
111 void oxygen_update_spdif_source(struct oxygen *chip);
112 
113 /* oxygen_pcm.c */
114 
115 int oxygen_pcm_init(struct oxygen *chip);
116 
117 /* oxygen_io.c */
118 
119 u8 oxygen_read8(struct oxygen *chip, unsigned int reg);
120 u16 oxygen_read16(struct oxygen *chip, unsigned int reg);
121 u32 oxygen_read32(struct oxygen *chip, unsigned int reg);
122 void oxygen_write8(struct oxygen *chip, unsigned int reg, u8 value);
123 void oxygen_write16(struct oxygen *chip, unsigned int reg, u16 value);
124 void oxygen_write32(struct oxygen *chip, unsigned int reg, u32 value);
125 void oxygen_write8_masked(struct oxygen *chip, unsigned int reg,
126                           u8 value, u8 mask);
127 void oxygen_write16_masked(struct oxygen *chip, unsigned int reg,
128                            u16 value, u16 mask);
129 void oxygen_write32_masked(struct oxygen *chip, unsigned int reg,
130                            u32 value, u32 mask);
131 
132 u16 oxygen_read_ac97(struct oxygen *chip, unsigned int codec,
133                      unsigned int index);
134 void oxygen_write_ac97(struct oxygen *chip, unsigned int codec,
135                        unsigned int index, u16 data);
136 void oxygen_write_ac97_masked(struct oxygen *chip, unsigned int codec,
137                               unsigned int index, u16 data, u16 mask);
138 
139 void oxygen_write_spi(struct oxygen *chip, u8 control, unsigned int data);
140 
141 static inline void oxygen_set_bits8(struct oxygen *chip,
142                                     unsigned int reg, u8 value)
143 {
144         oxygen_write8_masked(chip, reg, value, value);
145 }
146 
147 static inline void oxygen_set_bits16(struct oxygen *chip,
148                                      unsigned int reg, u16 value)
149 {
150         oxygen_write16_masked(chip, reg, value, value);
151 }
152 
153 static inline void oxygen_set_bits32(struct oxygen *chip,
154                                      unsigned int reg, u32 value)
155 {
156         oxygen_write32_masked(chip, reg, value, value);
157 }
158 
159 static inline void oxygen_clear_bits8(struct oxygen *chip,
160                                       unsigned int reg, u8 value)
161 {
162         oxygen_write8_masked(chip, reg, 0, value);
163 }
164 
165 static inline void oxygen_clear_bits16(struct oxygen *chip,
166                                        unsigned int reg, u16 value)
167 {
168         oxygen_write16_masked(chip, reg, 0, value);
169 }
170 
171 static inline void oxygen_clear_bits32(struct oxygen *chip,
172                                        unsigned int reg, u32 value)
173 {
174         oxygen_write32_masked(chip, reg, 0, value);
175 }
176 
177 static inline void oxygen_ac97_set_bits(struct oxygen *chip, unsigned int codec,
178                                         unsigned int index, u16 value)
179 {
180         oxygen_write_ac97_masked(chip, codec, index, value, value);
181 }
182 
183 static inline void oxygen_ac97_clear_bits(struct oxygen *chip,
184                                           unsigned int codec,
185                                           unsigned int index, u16 value)
186 {
187         oxygen_write_ac97_masked(chip, codec, index, 0, value);
188 }
189 
190 #endif
191 
  This page was automatically generated by the LXR engine.