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
41union tas_biquad_t {
42	struct {
43		int b0,b1,b2,a1,a2;
44	} coeff;
45	int buf[5];
46};
47
48struct tas_biquad_ctrl_t {
49	u_int channel:4;
50	u_int filter:4;
51
52	union tas_biquad_t data;
53};
54
55struct tas_biquad_ctrl_list_t {
56	int flags;
57	int filter_count;
58	struct tas_biquad_ctrl_t biquads[0];
59};
60
61struct tas_ratio_t {
62	unsigned short val;    /* 8.8                        */
63	unsigned short expand; /* 0 = compress, !0 = expand. */
64};
65
66struct 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
76struct tas_drce_ctrl_t {
77	uint flags;
78
79	struct tas_drce_t data;
80};
81
82struct tas_gain_t
83{
84  unsigned int *master;
85  unsigned int *treble;
86  unsigned int *bass;
87  unsigned int *mixer;
88};
89
90typedef char tas_shadow_t[0x45];
91
92struct tas_data_t
93{
94	struct i2c_client *client;
95	tas_shadow_t *shadow;
96	uint mixer[SOUND_MIXER_NRDEVICES];
97};
98
99typedef int (*tas_hook_init_t)(struct i2c_client *);
100typedef int (*tas_hook_post_init_t)(struct tas_data_t *);
101typedef void (*tas_hook_uninit_t)(struct tas_data_t *);
102
103typedef int (*tas_hook_get_mixer_level_t)(struct tas_data_t *,int,uint *);
104typedef int (*tas_hook_set_mixer_level_t)(struct tas_data_t *,int,uint);
105
106typedef int (*tas_hook_enter_sleep_t)(struct tas_data_t *);
107typedef int (*tas_hook_leave_sleep_t)(struct tas_data_t *);
108
109typedef int (*tas_hook_supported_mixers_t)(struct tas_data_t *);
110typedef int (*tas_hook_mixer_is_stereo_t)(struct tas_data_t *,int);
111typedef int (*tas_hook_stereo_mixers_t)(struct tas_data_t *);
112
113typedef int (*tas_hook_output_device_change_t)(struct tas_data_t *,int,int,int);
114typedef int (*tas_hook_device_ioctl_t)(struct tas_data_t *,u_int,u_long);
115
116struct 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
146enum tas_write_mode_t {
147	WRITE_HW     = 0x01,
148	WRITE_SHADOW = 0x02,
149	WRITE_NORMAL = 0x03,
150	FORCE_WRITE  = 0x04
151};
152
153static inline uint
154tas_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 */
163static inline int
164tas_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
193static inline int
194tas_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
213static inline int
214tas_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
234static inline int
235tas_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
249static inline int
250tas_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
261extern int tas_register_driver(struct tas_driver_hooks_t *hooks);
262
263extern int tas_get_mixer_level(int mixer,uint *level);
264extern int tas_set_mixer_level(int mixer,uint level);
265extern int tas_enter_sleep(void);
266extern int tas_leave_sleep(void);
267extern int tas_supported_mixers(void);
268extern int tas_mixer_is_stereo(int mixer);
269extern int tas_stereo_mixers(void);
270extern int tas_output_device_change(int,int,int);
271extern int tas_device_ioctl(u_int, u_long);
272
273extern void tas_cleanup(void);
274extern int tas_init(int driver_id,const char *driver_name);
275extern 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 */
285