[PATCH] powerpc: Fix sound driver use of i2c
[linux-2.6.git] / sound / oss / dmasound / tas_common.h
1 #ifndef _TAS_COMMON_H_
2 #define _TAS_COMMON_H_
3
4 #include <linux/i2c.h>
5 #include <linux/soundcard.h>
6 #include <asm/string.h>
7
8 #define I2C_DRIVERID_TAS_BASE   (0xFEBA)
9
10 #define SET_4_20(shadow, offset, val)                        \
11         do {                                                 \
12                 (shadow)[(offset)+0] = ((val) >> 16) & 0xff; \
13                 (shadow)[(offset)+1] = ((val) >> 8)  & 0xff; \
14                 (shadow)[(offset)+2] = ((val) >> 0)  & 0xff; \
15         } while (0)
16
17 #define GET_4_20(shadow, offset)                             \
18         (((u_int)((shadow)[(offset)+0]) << 16) |             \
19          ((u_int)((shadow)[(offset)+1]) <<  8) |             \
20          ((u_int)((shadow)[(offset)+2]) <<  0))
21
22
23 #define TAS_BIQUAD_FAST_LOAD 0x01
24
25 #define TAS_DRCE_ENABLE           0x01
26 #define TAS_DRCE_ABOVE_RATIO      0x02
27 #define TAS_DRCE_BELOW_RATIO      0x04
28 #define TAS_DRCE_THRESHOLD        0x08
29 #define TAS_DRCE_ENERGY           0x10
30 #define TAS_DRCE_ATTACK           0x20
31 #define TAS_DRCE_DECAY            0x40
32
33 #define TAS_DRCE_ALL              0x7f
34
35
36 #define TAS_OUTPUT_HEADPHONES     0x00
37 #define TAS_OUTPUT_INTERNAL_SPKR  0x01
38 #define TAS_OUTPUT_EXTERNAL_SPKR  0x02
39
40
41 union tas_biquad_t {
42         struct {
43                 int b0,b1,b2,a1,a2;
44         } coeff;
45         int buf[5];
46 };
47
48 struct tas_biquad_ctrl_t {
49         u_int channel:4;
50         u_int filter:4;
51
52         union tas_biquad_t data;
53 };
54
55 struct tas_biquad_ctrl_list_t {
56         int flags;
57         int filter_count;
58         struct tas_biquad_ctrl_t biquads[0];
59 };
60
61 struct tas_ratio_t {
62         unsigned short val;    /* 8.8                        */
63         unsigned short expand; /* 0 = compress, !0 = expand. */
64 };
65
66 struct tas_drce_t {
67         unsigned short enable;
68         struct tas_ratio_t above;
69         struct tas_ratio_t below;
70         short threshold;       /* dB,       8.8 signed    */
71         unsigned short energy; /* seconds,  4.12 unsigned */
72         unsigned short attack; /* seconds,  4.12 unsigned */
73         unsigned short decay;  /* seconds,  4.12 unsigned */
74 };
75
76 struct tas_drce_ctrl_t {
77         uint flags;
78
79         struct tas_drce_t data;
80 };
81
82 struct tas_gain_t
83 {
84   unsigned int *master;
85   unsigned int *treble;
86   unsigned int *bass;
87   unsigned int *mixer;
88 };
89
90 typedef char tas_shadow_t[0x45];
91
92 struct tas_data_t
93 {
94         struct i2c_client *client;
95         tas_shadow_t *shadow;
96         uint mixer[SOUND_MIXER_NRDEVICES];
97 };
98
99 typedef int (*tas_hook_init_t)(struct i2c_client *);
100 typedef int (*tas_hook_post_init_t)(struct tas_data_t *);
101 typedef void (*tas_hook_uninit_t)(struct tas_data_t *);
102
103 typedef int (*tas_hook_get_mixer_level_t)(struct tas_data_t *,int,uint *);
104 typedef int (*tas_hook_set_mixer_level_t)(struct tas_data_t *,int,uint);
105
106 typedef int (*tas_hook_enter_sleep_t)(struct tas_data_t *);
107 typedef int (*tas_hook_leave_sleep_t)(struct tas_data_t *);
108
109 typedef int (*tas_hook_supported_mixers_t)(struct tas_data_t *);
110 typedef int (*tas_hook_mixer_is_stereo_t)(struct tas_data_t *,int);
111 typedef int (*tas_hook_stereo_mixers_t)(struct tas_data_t *);
112
113 typedef int (*tas_hook_output_device_change_t)(struct tas_data_t *,int,int,int);
114 typedef int (*tas_hook_device_ioctl_t)(struct tas_data_t *,u_int,u_long);
115
116 struct tas_driver_hooks_t {
117         /*
118          * All hardware initialisation must be performed in
119          * post_init(), as tas_dmasound_init() does a hardware reset.
120          *
121          * init() is called before tas_dmasound_init() so that
122          * ouput_device_change() is always called after i2c driver
123          * initialisation. The implication is that
124          * output_device_change() must cope with the fact that it
125          * may be called before post_init().
126          */
127
128         tas_hook_init_t                   init;
129         tas_hook_post_init_t              post_init;
130         tas_hook_uninit_t                 uninit;
131
132         tas_hook_get_mixer_level_t        get_mixer_level;
133         tas_hook_set_mixer_level_t        set_mixer_level;
134
135         tas_hook_enter_sleep_t            enter_sleep;
136         tas_hook_leave_sleep_t            leave_sleep;
137
138         tas_hook_supported_mixers_t       supported_mixers;
139         tas_hook_mixer_is_stereo_t        mixer_is_stereo;
140         tas_hook_stereo_mixers_t          stereo_mixers;
141
142         tas_hook_output_device_change_t   output_device_change;
143         tas_hook_device_ioctl_t           device_ioctl;
144 };
145
146 enum tas_write_mode_t {
147         WRITE_HW     = 0x01,
148         WRITE_SHADOW = 0x02,
149         WRITE_NORMAL = 0x03,
150         FORCE_WRITE  = 0x04
151 };
152
153 static inline uint
154 tas_mono_to_stereo(uint mono)
155 {
156         mono &=0xff;
157         return mono | (mono<<8);
158 }
159
160 /*
161  * Todo: make these functions a bit more efficient !
162  */
163 static inline int
164 tas_write_register(     struct tas_data_t *self,
165                         uint reg_num,
166                         uint reg_width,
167                         char *data,
168                         uint write_mode)
169 {
170         int rc;
171
172         if (reg_width==0 || data==NULL || self==NULL)
173                 return -EINVAL;
174         if (!(write_mode & FORCE_WRITE) &&
175             !memcmp(data,self->shadow[reg_num],reg_width))
176                 return 0;
177
178         if (write_mode & WRITE_SHADOW)
179                 memcpy(self->shadow[reg_num],data,reg_width);
180         if (write_mode & WRITE_HW) {
181                 rc=i2c_smbus_write_i2c_block_data(self->client,
182                                                   reg_num,
183                                                   reg_width,
184                                                   data);
185                 if (rc < 0) {
186                         printk("tas: I2C block write failed \n");  
187                         return rc; 
188                 }
189         }
190         return 0;
191 }
192
193 static inline int
194 tas_sync_register(      struct tas_data_t *self,
195                         uint reg_num,
196                         uint reg_width)
197 {
198         int rc;
199
200         if (reg_width==0 || self==NULL)
201                 return -EINVAL;
202         rc=i2c_smbus_write_i2c_block_data(self->client,
203                                           reg_num,
204                                           reg_width,
205                                           self->shadow[reg_num]);
206         if (rc < 0) {
207                 printk("tas: I2C block write failed \n");
208                 return rc;
209         }
210         return 0;
211 }
212
213 static inline int
214 tas_write_byte_register(        struct tas_data_t *self,
215                                 uint reg_num,
216                                 char data,
217                                 uint write_mode)
218 {
219         if (self==NULL)
220                 return -1;
221         if (!(write_mode & FORCE_WRITE) && data != self->shadow[reg_num][0])
222                 return 0;
223         if (write_mode & WRITE_SHADOW)
224                 self->shadow[reg_num][0]=data;
225         if (write_mode & WRITE_HW) {
226                 if (i2c_smbus_write_byte_data(self->client, reg_num, data) < 0) {
227                         printk("tas: I2C byte write failed \n");  
228                         return -1; 
229                 }
230         }
231         return 0;
232 }
233
234 static inline int
235 tas_sync_byte_register( struct tas_data_t *self,
236                         uint reg_num,
237                         uint reg_width)
238 {
239         if (reg_width==0 || self==NULL)
240                 return -1;
241         if (i2c_smbus_write_byte_data(
242             self->client, reg_num, self->shadow[reg_num][0]) < 0) {
243                 printk("tas: I2C byte write failed \n");
244                 return -1;
245         }
246         return 0;
247 }
248
249 static inline int
250 tas_read_register(      struct tas_data_t *self,
251                         uint reg_num,
252                         uint reg_width,
253                         char *data)
254 {
255         if (reg_width==0 || data==NULL || self==NULL)
256                 return -1;
257         memcpy(data,self->shadow[reg_num],reg_width);
258         return 0;
259 }
260
261 extern int tas_register_driver(struct tas_driver_hooks_t *hooks);
262
263 extern int tas_get_mixer_level(int mixer,uint *level);
264 extern int tas_set_mixer_level(int mixer,uint level);
265 extern int tas_enter_sleep(void);
266 extern int tas_leave_sleep(void);
267 extern int tas_supported_mixers(void);
268 extern int tas_mixer_is_stereo(int mixer);
269 extern int tas_stereo_mixers(void);
270 extern int tas_output_device_change(int,int,int);
271 extern int tas_device_ioctl(u_int, u_long);
272
273 extern void tas_cleanup(void);
274 extern int tas_init(int driver_id,const char *driver_name);
275 extern int tas_post_init(void);
276
277 #endif /* _TAS_COMMON_H_ */
278 /*
279  * Local Variables:
280  * tab-width: 8
281  * indent-tabs-mode: t
282  * c-basic-offset: 8
283  * End:
284  */