aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video/cx25840
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/video/cx25840')
-rw-r--r--drivers/media/video/cx25840/Makefile6
-rw-r--r--drivers/media/video/cx25840/cx25840-audio.c368
-rw-r--r--drivers/media/video/cx25840/cx25840-core.c1020
-rw-r--r--drivers/media/video/cx25840/cx25840-firmware.c167
-rw-r--r--drivers/media/video/cx25840/cx25840-vbi.c315
-rw-r--r--drivers/media/video/cx25840/cx25840.h85
6 files changed, 1961 insertions, 0 deletions
diff --git a/drivers/media/video/cx25840/Makefile b/drivers/media/video/cx25840/Makefile
new file mode 100644
index 000000000000..543ebacdc9d7
--- /dev/null
+++ b/drivers/media/video/cx25840/Makefile
@@ -0,0 +1,6 @@
1cx25840-objs := cx25840-core.o cx25840-audio.o cx25840-firmware.o \
2 cx25840-vbi.o
3
4obj-$(CONFIG_VIDEO_DECODER) += cx25840.o
5
6EXTRA_CFLAGS += -I$(src)/..
diff --git a/drivers/media/video/cx25840/cx25840-audio.c b/drivers/media/video/cx25840/cx25840-audio.c
new file mode 100644
index 000000000000..740908f8027d
--- /dev/null
+++ b/drivers/media/video/cx25840/cx25840-audio.c
@@ -0,0 +1,368 @@
1/* cx25840 audio functions
2 *
3 * This program is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU General Public License
5 * as published by the Free Software Foundation; either version 2
6 * of the License, or (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 */
17
18
19#include <linux/videodev2.h>
20#include <linux/i2c.h>
21#include <media/audiochip.h>
22#include <media/v4l2-common.h>
23
24#include "cx25840.h"
25
26inline static int set_audclk_freq(struct i2c_client *client,
27 enum v4l2_audio_clock_freq freq)
28{
29 struct cx25840_state *state = i2c_get_clientdata(client);
30
31 /* assert soft reset */
32 cx25840_and_or(client, 0x810, ~0x1, 0x01);
33
34 /* common for all inputs and rates */
35 /* SA_MCLK_SEL=1, SA_MCLK_DIV=0x10 */
36 cx25840_write(client, 0x127, 0x50);
37
38 switch (state->audio_input) {
39 case AUDIO_TUNER:
40 switch (freq) {
41 case V4L2_AUDCLK_32_KHZ:
42 /* VID_PLL and AUX_PLL */
43 cx25840_write4(client, 0x108, 0x0f040610);
44
45 /* AUX_PLL_FRAC */
46 cx25840_write4(client, 0x110, 0xee39bb01);
47
48 /* src3/4/6_ctl = 0x0801f77f */
49 cx25840_write4(client, 0x900, 0x7ff70108);
50 cx25840_write4(client, 0x904, 0x7ff70108);
51 cx25840_write4(client, 0x90c, 0x7ff70108);
52 break;
53
54 case V4L2_AUDCLK_441_KHZ:
55 /* VID_PLL and AUX_PLL */
56 cx25840_write4(client, 0x108, 0x0f040910);
57
58 /* AUX_PLL_FRAC */
59 cx25840_write4(client, 0x110, 0xd66bec00);
60
61 /* src3/4/6_ctl = 0x08016d59 */
62 cx25840_write4(client, 0x900, 0x596d0108);
63 cx25840_write4(client, 0x904, 0x596d0108);
64 cx25840_write4(client, 0x90c, 0x596d0108);
65 break;
66
67 case V4L2_AUDCLK_48_KHZ:
68 /* VID_PLL and AUX_PLL */
69 cx25840_write4(client, 0x108, 0x0f040a10);
70
71 /* AUX_PLL_FRAC */
72 cx25840_write4(client, 0x110, 0xe5d69800);
73
74 /* src3/4/6_ctl = 0x08014faa */
75 cx25840_write4(client, 0x900, 0xaa4f0108);
76 cx25840_write4(client, 0x904, 0xaa4f0108);
77 cx25840_write4(client, 0x90c, 0xaa4f0108);
78 break;
79 }
80 break;
81
82 case AUDIO_EXTERN_1:
83 case AUDIO_EXTERN_2:
84 case AUDIO_INTERN:
85 case AUDIO_RADIO:
86 switch (freq) {
87 case V4L2_AUDCLK_32_KHZ:
88 /* VID_PLL and AUX_PLL */
89 cx25840_write4(client, 0x108, 0x0f04081e);
90
91 /* AUX_PLL_FRAC */
92 cx25840_write4(client, 0x110, 0x69082a01);
93
94 /* src1_ctl = 0x08010000 */
95 cx25840_write4(client, 0x8f8, 0x00000108);
96
97 /* src3/4/6_ctl = 0x08020000 */
98 cx25840_write4(client, 0x900, 0x00000208);
99 cx25840_write4(client, 0x904, 0x00000208);
100 cx25840_write4(client, 0x90c, 0x00000208);
101
102 /* SA_MCLK_SEL=1, SA_MCLK_DIV=0x14 */
103 cx25840_write(client, 0x127, 0x54);
104 break;
105
106 case V4L2_AUDCLK_441_KHZ:
107 /* VID_PLL and AUX_PLL */
108 cx25840_write4(client, 0x108, 0x0f040918);
109
110 /* AUX_PLL_FRAC */
111 cx25840_write4(client, 0x110, 0xd66bec00);
112
113 /* src1_ctl = 0x08010000 */
114 cx25840_write4(client, 0x8f8, 0xcd600108);
115
116 /* src3/4/6_ctl = 0x08020000 */
117 cx25840_write4(client, 0x900, 0x85730108);
118 cx25840_write4(client, 0x904, 0x85730108);
119 cx25840_write4(client, 0x90c, 0x85730108);
120 break;
121
122 case V4L2_AUDCLK_48_KHZ:
123 /* VID_PLL and AUX_PLL */
124 cx25840_write4(client, 0x108, 0x0f040a18);
125
126 /* AUX_PLL_FRAC */
127 cx25840_write4(client, 0x110, 0xe5d69800);
128
129 /* src1_ctl = 0x08010000 */
130 cx25840_write4(client, 0x8f8, 0x00800108);
131
132 /* src3/4/6_ctl = 0x08020000 */
133 cx25840_write4(client, 0x900, 0x55550108);
134 cx25840_write4(client, 0x904, 0x55550108);
135 cx25840_write4(client, 0x90c, 0x55550108);
136 break;
137 }
138 break;
139 }
140
141 /* deassert soft reset */
142 cx25840_and_or(client, 0x810, ~0x1, 0x00);
143
144 state->audclk_freq = freq;
145
146 return 0;
147}
148
149static int set_input(struct i2c_client *client, int audio_input)
150{
151 struct cx25840_state *state = i2c_get_clientdata(client);
152
153 cx25840_dbg("set audio input (%d)\n", audio_input);
154
155 /* stop microcontroller */
156 cx25840_and_or(client, 0x803, ~0x10, 0);
157
158 /* Mute everything to prevent the PFFT! */
159 cx25840_write(client, 0x8d3, 0x1f);
160
161 switch (audio_input) {
162 case AUDIO_TUNER:
163 /* Set Path1 to Analog Demod Main Channel */
164 cx25840_write4(client, 0x8d0, 0x7038061f);
165
166 /* When the microcontroller detects the
167 * audio format, it will unmute the lines */
168 cx25840_and_or(client, 0x803, ~0x10, 0x10);
169 break;
170
171 case AUDIO_EXTERN_1:
172 case AUDIO_EXTERN_2:
173 case AUDIO_INTERN:
174 case AUDIO_RADIO:
175 /* Set Path1 to Serial Audio Input */
176 cx25840_write4(client, 0x8d0, 0x12100101);
177
178 /* The microcontroller should not be started for the
179 * non-tuner inputs: autodetection is specific for
180 * TV audio. */
181 break;
182
183 default:
184 cx25840_dbg("Invalid audio input selection %d\n", audio_input);
185 return -EINVAL;
186 }
187
188 state->audio_input = audio_input;
189
190 return set_audclk_freq(client, state->audclk_freq);
191}
192
193inline static int get_volume(struct i2c_client *client)
194{
195 /* Volume runs +18dB to -96dB in 1/2dB steps
196 * change to fit the msp3400 -114dB to +12dB range */
197
198 /* check PATH1_VOLUME */
199 int vol = 228 - cx25840_read(client, 0x8d4);
200 vol = (vol / 2) + 23;
201 return vol << 9;
202}
203
204inline static void set_volume(struct i2c_client *client, int volume)
205{
206 /* First convert the volume to msp3400 values (0-127) */
207 int vol = volume >> 9;
208 /* now scale it up to cx25840 values
209 * -114dB to -96dB maps to 0
210 * this should be 19, but in my testing that was 4dB too loud */
211 if (vol <= 23) {
212 vol = 0;
213 } else {
214 vol -= 23;
215 }
216
217 /* PATH1_VOLUME */
218 cx25840_write(client, 0x8d4, 228 - (vol * 2));
219}
220
221inline static int get_bass(struct i2c_client *client)
222{
223 /* bass is 49 steps +12dB to -12dB */
224
225 /* check PATH1_EQ_BASS_VOL */
226 int bass = cx25840_read(client, 0x8d9) & 0x3f;
227 bass = (((48 - bass) * 0xffff) + 47) / 48;
228 return bass;
229}
230
231inline static void set_bass(struct i2c_client *client, int bass)
232{
233 /* PATH1_EQ_BASS_VOL */
234 cx25840_and_or(client, 0x8d9, ~0x3f, 48 - (bass * 48 / 0xffff));
235}
236
237inline static int get_treble(struct i2c_client *client)
238{
239 /* treble is 49 steps +12dB to -12dB */
240
241 /* check PATH1_EQ_TREBLE_VOL */
242 int treble = cx25840_read(client, 0x8db) & 0x3f;
243 treble = (((48 - treble) * 0xffff) + 47) / 48;
244 return treble;
245}
246
247inline static void set_treble(struct i2c_client *client, int treble)
248{
249 /* PATH1_EQ_TREBLE_VOL */
250 cx25840_and_or(client, 0x8db, ~0x3f, 48 - (treble * 48 / 0xffff));
251}
252
253inline static int get_balance(struct i2c_client *client)
254{
255 /* balance is 7 bit, 0 to -96dB */
256
257 /* check PATH1_BAL_LEVEL */
258 int balance = cx25840_read(client, 0x8d5) & 0x7f;
259 /* check PATH1_BAL_LEFT */
260 if ((cx25840_read(client, 0x8d5) & 0x80) == 0)
261 balance = 0x80 - balance;
262 else
263 balance = 0x80 + balance;
264 return balance << 8;
265}
266
267inline static void set_balance(struct i2c_client *client, int balance)
268{
269 int bal = balance >> 8;
270 if (bal > 0x80) {
271 /* PATH1_BAL_LEFT */
272 cx25840_and_or(client, 0x8d5, 0x7f, 0x80);
273 /* PATH1_BAL_LEVEL */
274 cx25840_and_or(client, 0x8d5, ~0x7f, bal & 0x7f);
275 } else {
276 /* PATH1_BAL_LEFT */
277 cx25840_and_or(client, 0x8d5, 0x7f, 0x00);
278 /* PATH1_BAL_LEVEL */
279 cx25840_and_or(client, 0x8d5, ~0x7f, 0x80 - bal);
280 }
281}
282
283inline static int get_mute(struct i2c_client *client)
284{
285 /* check SRC1_MUTE_EN */
286 return cx25840_read(client, 0x8d3) & 0x2 ? 1 : 0;
287}
288
289inline static void set_mute(struct i2c_client *client, int mute)
290{
291 struct cx25840_state *state = i2c_get_clientdata(client);
292
293 if (state->audio_input == AUDIO_TUNER) {
294 /* Must turn off microcontroller in order to mute sound.
295 * Not sure if this is the best method, but it does work.
296 * If the microcontroller is running, then it will undo any
297 * changes to the mute register. */
298 if (mute) {
299 /* disable microcontroller */
300 cx25840_and_or(client, 0x803, ~0x10, 0x00);
301 cx25840_write(client, 0x8d3, 0x1f);
302 } else {
303 /* enable microcontroller */
304 cx25840_and_or(client, 0x803, ~0x10, 0x10);
305 }
306 } else {
307 /* SRC1_MUTE_EN */
308 cx25840_and_or(client, 0x8d3, ~0x2, mute ? 0x02 : 0x00);
309 }
310}
311
312int cx25840_audio(struct i2c_client *client, unsigned int cmd, void *arg)
313{
314 struct v4l2_control *ctrl = arg;
315
316 switch (cmd) {
317 case AUDC_SET_INPUT:
318 return set_input(client, *(int *)arg);
319 case VIDIOC_INT_AUDIO_CLOCK_FREQ:
320 return set_audclk_freq(client, *(enum v4l2_audio_clock_freq *)arg);
321 case VIDIOC_G_CTRL:
322 switch (ctrl->id) {
323 case V4L2_CID_AUDIO_VOLUME:
324 ctrl->value = get_volume(client);
325 break;
326 case V4L2_CID_AUDIO_BASS:
327 ctrl->value = get_bass(client);
328 break;
329 case V4L2_CID_AUDIO_TREBLE:
330 ctrl->value = get_treble(client);
331 break;
332 case V4L2_CID_AUDIO_BALANCE:
333 ctrl->value = get_balance(client);
334 break;
335 case V4L2_CID_AUDIO_MUTE:
336 ctrl->value = get_mute(client);
337 break;
338 default:
339 return -EINVAL;
340 }
341 break;
342 case VIDIOC_S_CTRL:
343 switch (ctrl->id) {
344 case V4L2_CID_AUDIO_VOLUME:
345 set_volume(client, ctrl->value);
346 break;
347 case V4L2_CID_AUDIO_BASS:
348 set_bass(client, ctrl->value);
349 break;
350 case V4L2_CID_AUDIO_TREBLE:
351 set_treble(client, ctrl->value);
352 break;
353 case V4L2_CID_AUDIO_BALANCE:
354 set_balance(client, ctrl->value);
355 break;
356 case V4L2_CID_AUDIO_MUTE:
357 set_mute(client, ctrl->value);
358 break;
359 default:
360 return -EINVAL;
361 }
362 break;
363 default:
364 return -EINVAL;
365 }
366
367 return 0;
368}
diff --git a/drivers/media/video/cx25840/cx25840-core.c b/drivers/media/video/cx25840/cx25840-core.c
new file mode 100644
index 000000000000..f6afeec499c5
--- /dev/null
+++ b/drivers/media/video/cx25840/cx25840-core.c
@@ -0,0 +1,1020 @@
1/* cx25840 - Conexant CX25840 audio/video decoder driver
2 *
3 * Copyright (C) 2004 Ulf Eklund
4 *
5 * Based on the saa7115 driver and on the first verison of Chris Kennedy's
6 * cx25840 driver.
7 *
8 * Changes by Tyler Trafford <tatrafford@comcast.net>
9 * - cleanup/rewrite for V4L2 API (2005)
10 *
11 * VBI support by Hans Verkuil <hverkuil@xs4all.nl>.
12 *
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License
15 * as published by the Free Software Foundation; either version 2
16 * of the License, or (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
26 */
27
28
29#include <linux/kernel.h>
30#include <linux/module.h>
31#include <linux/slab.h>
32#include <linux/videodev2.h>
33#include <linux/i2c.h>
34#include <media/audiochip.h>
35#include <media/v4l2-common.h>
36
37#include "cx25840.h"
38
39MODULE_DESCRIPTION("Conexant CX25840 audio/video decoder driver");
40MODULE_AUTHOR("Ulf Eklund, Chris Kennedy, Hans Verkuil, Tyler Trafford");
41MODULE_LICENSE("GPL");
42
43static unsigned short normal_i2c[] = { 0x88 >> 1, I2C_CLIENT_END };
44
45
46int cx25840_debug = 0;
47
48module_param(cx25840_debug, bool, 0644);
49
50MODULE_PARM_DESC(cx25840_debug, "Debugging messages [0=Off (default) 1=On]");
51
52I2C_CLIENT_INSMOD;
53
54/* ----------------------------------------------------------------------- */
55
56int cx25840_write(struct i2c_client *client, u16 addr, u8 value)
57{
58 u8 buffer[3];
59 buffer[0] = addr >> 8;
60 buffer[1] = addr & 0xff;
61 buffer[2] = value;
62 return i2c_master_send(client, buffer, 3);
63}
64
65int cx25840_write4(struct i2c_client *client, u16 addr, u32 value)
66{
67 u8 buffer[6];
68 buffer[0] = addr >> 8;
69 buffer[1] = addr & 0xff;
70 buffer[2] = value >> 24;
71 buffer[3] = (value >> 16) & 0xff;
72 buffer[4] = (value >> 8) & 0xff;
73 buffer[5] = value & 0xff;
74 return i2c_master_send(client, buffer, 6);
75}
76
77u8 cx25840_read(struct i2c_client * client, u16 addr)
78{
79 u8 buffer[2];
80 buffer[0] = addr >> 8;
81 buffer[1] = addr & 0xff;
82
83 if (i2c_master_send(client, buffer, 2) < 2)
84 return 0;
85
86 if (i2c_master_recv(client, buffer, 1) < 1)
87 return 0;
88
89 return buffer[0];
90}
91
92u32 cx25840_read4(struct i2c_client * client, u16 addr)
93{
94 u8 buffer[4];
95 buffer[0] = addr >> 8;
96 buffer[1] = addr & 0xff;
97
98 if (i2c_master_send(client, buffer, 2) < 2)
99 return 0;
100
101 if (i2c_master_recv(client, buffer, 4) < 4)
102 return 0;
103
104 return (buffer[0] << 24) | (buffer[1] << 16) |
105 (buffer[2] << 8) | buffer[3];
106}
107
108int cx25840_and_or(struct i2c_client *client, u16 addr, u8 and_mask,
109 u8 or_value)
110{
111 return cx25840_write(client, addr,
112 (cx25840_read(client, addr) & and_mask) |
113 or_value);
114}
115
116/* ----------------------------------------------------------------------- */
117
118static int set_input(struct i2c_client *, enum cx25840_input);
119static void input_change(struct i2c_client *);
120static void log_status(struct i2c_client *client);
121
122/* ----------------------------------------------------------------------- */
123
124static inline void init_dll1(struct i2c_client *client)
125{
126 /* This is the Hauppauge sequence used to
127 * initialize the Delay Lock Loop 1 (ADC DLL). */
128 cx25840_write(client, 0x159, 0x23);
129 cx25840_write(client, 0x15a, 0x87);
130 cx25840_write(client, 0x15b, 0x06);
131 cx25840_write(client, 0x159, 0xe1);
132 cx25840_write(client, 0x15a, 0x86);
133 cx25840_write(client, 0x159, 0xe0);
134 cx25840_write(client, 0x159, 0xe1);
135 cx25840_write(client, 0x15b, 0x10);
136}
137
138static inline void init_dll2(struct i2c_client *client)
139{
140 /* This is the Hauppauge sequence used to
141 * initialize the Delay Lock Loop 2 (ADC DLL). */
142 cx25840_write(client, 0x15d, 0xe3);
143 cx25840_write(client, 0x15e, 0x86);
144 cx25840_write(client, 0x15f, 0x06);
145 cx25840_write(client, 0x15d, 0xe1);
146 cx25840_write(client, 0x15d, 0xe0);
147 cx25840_write(client, 0x15d, 0xe1);
148}
149
150static void cx25840_initialize(struct i2c_client *client, int loadfw)
151{
152 struct cx25840_state *state = i2c_get_clientdata(client);
153
154 /* datasheet startup in numbered steps, refer to page 3-77 */
155 /* 2. */
156 cx25840_and_or(client, 0x803, ~0x10, 0x00);
157 /* The default of this register should be 4, but I get 0 instead.
158 * Set this register to 4 manually. */
159 cx25840_write(client, 0x000, 0x04);
160 /* 3. */
161 init_dll1(client);
162 init_dll2(client);
163 cx25840_write(client, 0x136, 0x0a);
164 /* 4. */
165 cx25840_write(client, 0x13c, 0x01);
166 cx25840_write(client, 0x13c, 0x00);
167 /* 5. */
168 if (loadfw)
169 cx25840_loadfw(client);
170 /* 6. */
171 cx25840_write(client, 0x115, 0x8c);
172 cx25840_write(client, 0x116, 0x07);
173 cx25840_write(client, 0x118, 0x02);
174 /* 7. */
175 cx25840_write(client, 0x4a5, 0x80);
176 cx25840_write(client, 0x4a5, 0x00);
177 cx25840_write(client, 0x402, 0x00);
178 /* 8. */
179 cx25840_write(client, 0x401, 0x18);
180 cx25840_write(client, 0x4a2, 0x10);
181 cx25840_write(client, 0x402, 0x04);
182 /* 10. */
183 cx25840_write(client, 0x8d3, 0x1f);
184 cx25840_write(client, 0x8e3, 0x03);
185
186 cx25840_vbi_setup(client);
187
188 /* trial and error says these are needed to get audio */
189 cx25840_write(client, 0x914, 0xa0);
190 cx25840_write(client, 0x918, 0xa0);
191 cx25840_write(client, 0x919, 0x01);
192
193 /* stereo prefered */
194 cx25840_write(client, 0x809, 0x04);
195 /* AC97 shift */
196 cx25840_write(client, 0x8cf, 0x0f);
197
198 /* (re)set video input */
199 set_input(client, state->input);
200 /* (re)set audio input */
201 cx25840_audio(client, AUDC_SET_INPUT, &state->audio_input);
202
203 /* start microcontroller */
204 cx25840_and_or(client, 0x803, ~0x10, 0x10);
205}
206
207/* ----------------------------------------------------------------------- */
208
209static void input_change(struct i2c_client *client)
210{
211 v4l2_std_id std = cx25840_get_v4lstd(client);
212
213 if (std & V4L2_STD_PAL) {
214 /* Follow tuner change procedure for PAL */
215 cx25840_write(client, 0x808, 0xff);
216 cx25840_write(client, 0x80b, 0x10);
217 } else if (std & V4L2_STD_SECAM) {
218 /* Select autodetect for SECAM */
219 cx25840_write(client, 0x808, 0xff);
220 cx25840_write(client, 0x80b, 0x10);
221 } else if (std & V4L2_STD_NTSC) {
222 /* NTSC */
223 cx25840_write(client, 0x808, 0xf6);
224 cx25840_write(client, 0x80b, 0x00);
225 }
226
227 if (cx25840_read(client, 0x803) & 0x10) {
228 /* restart audio decoder microcontroller */
229 cx25840_and_or(client, 0x803, ~0x10, 0x00);
230 cx25840_and_or(client, 0x803, ~0x10, 0x10);
231 }
232}
233
234static int set_input(struct i2c_client *client, enum cx25840_input input)
235{
236 struct cx25840_state *state = i2c_get_clientdata(client);
237
238 cx25840_dbg("decoder set input (%d)\n", input);
239
240 switch (input) {
241 case CX25840_TUNER:
242 cx25840_dbg("now setting Tuner input\n");
243
244 if (state->cardtype == CARDTYPE_PVR150) {
245 /* CH_SEL_ADC2=1 */
246 cx25840_and_or(client, 0x102, ~0x2, 0x02);
247 }
248
249 /* Video Input Control */
250 if (state->cardtype == CARDTYPE_PG600) {
251 cx25840_write(client, 0x103, 0x11);
252 } else {
253 cx25840_write(client, 0x103, 0x46);
254 }
255
256 /* INPUT_MODE=0 */
257 cx25840_and_or(client, 0x401, ~0x6, 0x00);
258 break;
259
260 case CX25840_COMPOSITE0:
261 case CX25840_COMPOSITE1:
262 cx25840_dbg("now setting Composite input\n");
263
264 /* Video Input Control */
265 if (state->cardtype == CARDTYPE_PG600) {
266 cx25840_write(client, 0x103, 0x00);
267 } else {
268 cx25840_write(client, 0x103, 0x02);
269 }
270
271 /* INPUT_MODE=0 */
272 cx25840_and_or(client, 0x401, ~0x6, 0x00);
273 break;
274
275 case CX25840_SVIDEO0:
276 case CX25840_SVIDEO1:
277 cx25840_dbg("now setting S-Video input\n");
278
279 /* CH_SEL_ADC2=0 */
280 cx25840_and_or(client, 0x102, ~0x2, 0x00);
281
282 /* Video Input Control */
283 if (state->cardtype == CARDTYPE_PG600) {
284 cx25840_write(client, 0x103, 0x02);
285 } else {
286 cx25840_write(client, 0x103, 0x10);
287 }
288
289 /* INPUT_MODE=1 */
290 cx25840_and_or(client, 0x401, ~0x6, 0x02);
291 break;
292
293 default:
294 cx25840_err("%d is not a valid input!\n", input);
295 return -EINVAL;
296 }
297
298 state->input = input;
299 input_change(client);
300 return 0;
301}
302
303/* ----------------------------------------------------------------------- */
304
305static int set_v4lstd(struct i2c_client *client, v4l2_std_id std)
306{
307 u8 fmt;
308
309 switch (std) {
310 /* zero is autodetect */
311 case 0: fmt = 0x0; break;
312 /* default ntsc to ntsc-m */
313 case V4L2_STD_NTSC:
314 case V4L2_STD_NTSC_M: fmt = 0x1; break;
315 case V4L2_STD_NTSC_M_JP: fmt = 0x2; break;
316 case V4L2_STD_NTSC_443: fmt = 0x3; break;
317 case V4L2_STD_PAL: fmt = 0x4; break;
318 case V4L2_STD_PAL_M: fmt = 0x5; break;
319 case V4L2_STD_PAL_N: fmt = 0x6; break;
320 case V4L2_STD_PAL_Nc: fmt = 0x7; break;
321 case V4L2_STD_PAL_60: fmt = 0x8; break;
322 case V4L2_STD_SECAM: fmt = 0xc; break;
323 default:
324 return -ERANGE;
325 }
326
327 cx25840_and_or(client, 0x400, ~0xf, fmt);
328 cx25840_vbi_setup(client);
329 return 0;
330}
331
332v4l2_std_id cx25840_get_v4lstd(struct i2c_client * client)
333{
334 /* check VID_FMT_SEL first */
335 u8 fmt = cx25840_read(client, 0x400) & 0xf;
336
337 if (!fmt) {
338 /* check AFD_FMT_STAT if set to autodetect */
339 fmt = cx25840_read(client, 0x40d) & 0xf;
340 }
341
342 switch (fmt) {
343 case 0x1: return V4L2_STD_NTSC_M;
344 case 0x2: return V4L2_STD_NTSC_M_JP;
345 case 0x3: return V4L2_STD_NTSC_443;
346 case 0x4: return V4L2_STD_PAL;
347 case 0x5: return V4L2_STD_PAL_M;
348 case 0x6: return V4L2_STD_PAL_N;
349 case 0x7: return V4L2_STD_PAL_Nc;
350 case 0x8: return V4L2_STD_PAL_60;
351 case 0xc: return V4L2_STD_SECAM;
352 default: return V4L2_STD_UNKNOWN;
353 }
354}
355
356/* ----------------------------------------------------------------------- */
357
358static int set_v4lctrl(struct i2c_client *client, struct v4l2_control *ctrl)
359{
360 struct cx25840_state *state = i2c_get_clientdata(client);
361
362 switch (ctrl->id) {
363 case CX25840_CID_CARDTYPE:
364 switch (ctrl->value) {
365 case CARDTYPE_PVR150:
366 case CARDTYPE_PG600:
367 state->cardtype = ctrl->value;
368 break;
369 default:
370 return -ERANGE;
371 }
372
373 set_input(client, state->input);
374 break;
375
376 case V4L2_CID_BRIGHTNESS:
377 if (ctrl->value < 0 || ctrl->value > 255) {
378 cx25840_err("invalid brightness setting %d\n",
379 ctrl->value);
380 return -ERANGE;
381 }
382
383 cx25840_write(client, 0x414, ctrl->value - 128);
384 break;
385
386 case V4L2_CID_CONTRAST:
387 if (ctrl->value < 0 || ctrl->value > 127) {
388 cx25840_err("invalid contrast setting %d\n",
389 ctrl->value);
390 return -ERANGE;
391 }
392
393 cx25840_write(client, 0x415, ctrl->value << 1);
394 break;
395
396 case V4L2_CID_SATURATION:
397 if (ctrl->value < 0 || ctrl->value > 127) {
398 cx25840_err("invalid saturation setting %d\n",
399 ctrl->value);
400 return -ERANGE;
401 }
402
403 cx25840_write(client, 0x420, ctrl->value << 1);
404 cx25840_write(client, 0x421, ctrl->value << 1);
405 break;
406
407 case V4L2_CID_HUE:
408 if (ctrl->value < -127 || ctrl->value > 127) {
409 cx25840_err("invalid hue setting %d\n", ctrl->value);
410 return -ERANGE;
411 }
412
413 cx25840_write(client, 0x422, ctrl->value);
414 break;
415
416 case V4L2_CID_AUDIO_VOLUME:
417 case V4L2_CID_AUDIO_BASS:
418 case V4L2_CID_AUDIO_TREBLE:
419 case V4L2_CID_AUDIO_BALANCE:
420 case V4L2_CID_AUDIO_MUTE:
421 return cx25840_audio(client, VIDIOC_S_CTRL, ctrl);
422 }
423
424 return 0;
425}
426
427static int get_v4lctrl(struct i2c_client *client, struct v4l2_control *ctrl)
428{
429 struct cx25840_state *state = i2c_get_clientdata(client);
430
431 switch (ctrl->id) {
432 case CX25840_CID_CARDTYPE:
433 ctrl->value = state->cardtype;
434 break;
435 case V4L2_CID_BRIGHTNESS:
436 ctrl->value = cx25840_read(client, 0x414) + 128;
437 break;
438 case V4L2_CID_CONTRAST:
439 ctrl->value = cx25840_read(client, 0x415) >> 1;
440 break;
441 case V4L2_CID_SATURATION:
442 ctrl->value = cx25840_read(client, 0x420) >> 1;
443 break;
444 case V4L2_CID_HUE:
445 ctrl->value = cx25840_read(client, 0x422);
446 break;
447 case V4L2_CID_AUDIO_VOLUME:
448 case V4L2_CID_AUDIO_BASS:
449 case V4L2_CID_AUDIO_TREBLE:
450 case V4L2_CID_AUDIO_BALANCE:
451 case V4L2_CID_AUDIO_MUTE:
452 return cx25840_audio(client, VIDIOC_G_CTRL, ctrl);
453 default:
454 return -EINVAL;
455 }
456
457 return 0;
458}
459
460/* ----------------------------------------------------------------------- */
461
462static int get_v4lfmt(struct i2c_client *client, struct v4l2_format *fmt)
463{
464 switch (fmt->type) {
465 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
466 return cx25840_vbi(client, VIDIOC_G_FMT, fmt);
467 default:
468 return -EINVAL;
469 }
470
471 return 0;
472}
473
474static int set_v4lfmt(struct i2c_client *client, struct v4l2_format *fmt)
475{
476 struct v4l2_pix_format *pix;
477 int HSC, VSC, Vsrc, Hsrc, filter, Vlines;
478 int is_pal = !(cx25840_get_v4lstd(client) & V4L2_STD_NTSC);
479
480 switch (fmt->type) {
481 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
482 pix = &(fmt->fmt.pix);
483
484 Vsrc = (cx25840_read(client, 0x476) & 0x3f) << 4;
485 Vsrc |= (cx25840_read(client, 0x475) & 0xf0) >> 4;
486
487 Hsrc = (cx25840_read(client, 0x472) & 0x3f) << 4;
488 Hsrc |= (cx25840_read(client, 0x471) & 0xf0) >> 4;
489
490 Vlines = pix->height + (is_pal ? 4 : 7);
491
492 if ((pix->width * 16 < Hsrc) || (Hsrc < pix->width) ||
493 (Vlines * 8 < Vsrc) || (Vsrc < Vlines)) {
494 cx25840_err("%dx%d is not a valid size!\n",
495 pix->width, pix->height);
496 return -ERANGE;
497 }
498
499 HSC = (Hsrc * (1 << 20)) / pix->width - (1 << 20);
500 VSC = (1 << 16) - (Vsrc * (1 << 9) / Vlines - (1 << 9));
501 VSC &= 0x1fff;
502
503 if (pix->width >= 385)
504 filter = 0;
505 else if (pix->width > 192)
506 filter = 1;
507 else if (pix->width > 96)
508 filter = 2;
509 else
510 filter = 3;
511
512 cx25840_dbg("decoder set size %dx%d -> scale %ux%u\n",
513 pix->width, pix->height, HSC, VSC);
514
515 /* HSCALE=HSC */
516 cx25840_write(client, 0x418, HSC & 0xff);
517 cx25840_write(client, 0x419, (HSC >> 8) & 0xff);
518 cx25840_write(client, 0x41a, HSC >> 16);
519 /* VSCALE=VSC */
520 cx25840_write(client, 0x41c, VSC & 0xff);
521 cx25840_write(client, 0x41d, VSC >> 8);
522 /* VS_INTRLACE=1 VFILT=filter */
523 cx25840_write(client, 0x41e, 0x8 | filter);
524 break;
525
526 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
527 return cx25840_vbi(client, VIDIOC_S_FMT, fmt);
528
529 case V4L2_BUF_TYPE_VBI_CAPTURE:
530 return cx25840_vbi(client, VIDIOC_S_FMT, fmt);
531
532 default:
533 return -EINVAL;
534 }
535
536 return 0;
537}
538
539/* ----------------------------------------------------------------------- */
540
541static int cx25840_command(struct i2c_client *client, unsigned int cmd,
542 void *arg)
543{
544 struct cx25840_state *state = i2c_get_clientdata(client);
545 struct v4l2_tuner *vt = arg;
546 int result = 0;
547
548 switch (cmd) {
549 case 0:
550 break;
551
552#ifdef CONFIG_VIDEO_ADV_DEBUG
553 /* ioctls to allow direct access to the
554 * cx25840 registers for testing */
555 case VIDIOC_INT_G_REGISTER:
556 {
557 struct v4l2_register *reg = arg;
558
559 if (reg->i2c_id != I2C_DRIVERID_CX25840)
560 return -EINVAL;
561 reg->val = cx25840_read(client, reg->reg & 0x0fff);
562 break;
563 }
564
565 case VIDIOC_INT_S_REGISTER:
566 {
567 struct v4l2_register *reg = arg;
568
569 if (reg->i2c_id != I2C_DRIVERID_CX25840)
570 return -EINVAL;
571 if (!capable(CAP_SYS_ADMIN))
572 return -EPERM;
573 cx25840_write(client, reg->reg & 0x0fff, reg->val & 0xff);
574 break;
575 }
576#endif
577
578 case VIDIOC_INT_DECODE_VBI_LINE:
579 return cx25840_vbi(client, cmd, arg);
580
581 case VIDIOC_INT_AUDIO_CLOCK_FREQ:
582 case AUDC_SET_INPUT:
583 result = cx25840_audio(client, cmd, arg);
584 break;
585
586 case VIDIOC_STREAMON:
587 cx25840_dbg("enable output\n");
588 cx25840_write(client, 0x115, 0x8c);
589 cx25840_write(client, 0x116, 0x07);
590 break;
591
592 case VIDIOC_STREAMOFF:
593 cx25840_dbg("disable output\n");
594 cx25840_write(client, 0x115, 0x00);
595 cx25840_write(client, 0x116, 0x00);
596 break;
597
598 case VIDIOC_LOG_STATUS:
599 log_status(client);
600 break;
601
602 case VIDIOC_G_CTRL:
603 result = get_v4lctrl(client, (struct v4l2_control *)arg);
604 break;
605
606 case VIDIOC_S_CTRL:
607 result = set_v4lctrl(client, (struct v4l2_control *)arg);
608 break;
609
610 case VIDIOC_G_STD:
611 *(v4l2_std_id *)arg = cx25840_get_v4lstd(client);
612 break;
613
614 case VIDIOC_S_STD:
615 result = set_v4lstd(client, *(v4l2_std_id *)arg);
616 break;
617
618 case VIDIOC_G_INPUT:
619 *(int *)arg = state->input;
620 break;
621
622 case VIDIOC_S_INPUT:
623 result = set_input(client, *(int *)arg);
624 break;
625
626 case VIDIOC_S_FREQUENCY:
627 input_change(client);
628 break;
629
630 case VIDIOC_G_TUNER:
631 {
632 u8 mode = cx25840_read(client, 0x804);
633 u8 pref = cx25840_read(client, 0x809) & 0xf;
634 u8 vpres = cx25840_read(client, 0x80a) & 0x10;
635 int val = 0;
636
637 vt->capability |=
638 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LANG1 |
639 V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
640
641 vt->signal = vpres ? 0xffff : 0x0;
642
643 /* get rxsubchans and audmode */
644 if ((mode & 0xf) == 1)
645 val |= V4L2_TUNER_SUB_STEREO;
646 else
647 val |= V4L2_TUNER_SUB_MONO;
648
649 if (mode == 2 || mode == 4)
650 val |= V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
651
652 if (mode & 0x10)
653 val |= V4L2_TUNER_SUB_SAP;
654
655 vt->rxsubchans = val;
656
657 switch (pref) {
658 case 0:
659 vt->audmode = V4L2_TUNER_MODE_MONO;
660 break;
661 case 1:
662 case 2:
663 vt->audmode = V4L2_TUNER_MODE_LANG2;
664 break;
665 case 4:
666 default:
667 vt->audmode = V4L2_TUNER_MODE_STEREO;
668 }
669 break;
670 }
671
672 case VIDIOC_S_TUNER:
673 switch (vt->audmode) {
674 case V4L2_TUNER_MODE_MONO:
675 case V4L2_TUNER_MODE_LANG1:
676 /* Force PREF_MODE to MONO */
677 cx25840_and_or(client, 0x809, ~0xf, 0x00);
678 break;
679 case V4L2_TUNER_MODE_STEREO:
680 /* Force PREF_MODE to STEREO */
681 cx25840_and_or(client, 0x809, ~0xf, 0x04);
682 break;
683 case V4L2_TUNER_MODE_LANG2:
684 /* Force PREF_MODE to LANG2 */
685 cx25840_and_or(client, 0x809, ~0xf, 0x01);
686 break;
687 }
688 break;
689
690 case VIDIOC_G_FMT:
691 result = get_v4lfmt(client, (struct v4l2_format *)arg);
692 break;
693
694 case VIDIOC_S_FMT:
695 result = set_v4lfmt(client, (struct v4l2_format *)arg);
696 break;
697
698 case VIDIOC_INT_RESET:
699 cx25840_initialize(client, 0);
700 break;
701
702 case VIDIOC_INT_G_CHIP_IDENT:
703 *(enum v4l2_chip_ident *)arg =
704 V4L2_IDENT_CX25840 + ((cx25840_read(client, 0x100) >> 4) & 0xf);
705 break;
706
707 default:
708 cx25840_err("invalid ioctl %x\n", cmd);
709 return -EINVAL;
710 }
711
712 return result;
713}
714
715/* ----------------------------------------------------------------------- */
716
717struct i2c_driver i2c_driver_cx25840;
718
719static int cx25840_detect_client(struct i2c_adapter *adapter, int address,
720 int kind)
721{
722 struct i2c_client *client;
723 struct cx25840_state *state;
724 u16 device_id;
725
726 /* Check if the adapter supports the needed features
727 * Not until kernel version 2.6.11 did the bit-algo
728 * correctly report that it would do an I2C-level xfer */
729 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
730 return 0;
731
732 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
733 if (client == 0)
734 return -ENOMEM;
735
736 memset(client, 0, sizeof(struct i2c_client));
737 client->addr = address;
738 client->adapter = adapter;
739 client->driver = &i2c_driver_cx25840;
740 client->flags = I2C_CLIENT_ALLOW_USE;
741 snprintf(client->name, sizeof(client->name) - 1, "cx25840");
742
743 cx25840_dbg("detecting cx25840 client on address 0x%x\n", address << 1);
744
745 device_id = cx25840_read(client, 0x101) << 8;
746 device_id |= cx25840_read(client, 0x100);
747
748 /* The high byte of the device ID should be
749 * 0x84 if chip is present */
750 if ((device_id & 0xff00) != 0x8400) {
751 cx25840_dbg("cx25840 not found\n");
752 kfree(client);
753 return 0;
754 }
755
756 cx25840_info("cx25%3x-2%x found @ 0x%x (%s)\n",
757 (device_id & 0xfff0) >> 4,
758 (device_id & 0x0f) < 3 ? (device_id & 0x0f) + 1 : 3,
759 address << 1, adapter->name);
760
761 state = kmalloc(sizeof(struct cx25840_state), GFP_KERNEL);
762 if (state == NULL) {
763 kfree(client);
764 return -ENOMEM;
765 }
766
767 i2c_set_clientdata(client, state);
768 memset(state, 0, sizeof(struct cx25840_state));
769 state->input = CX25840_TUNER;
770 state->audclk_freq = V4L2_AUDCLK_48_KHZ;
771 state->audio_input = AUDIO_TUNER;
772 state->cardtype = CARDTYPE_PVR150;
773
774 cx25840_initialize(client, 1);
775
776 i2c_attach_client(client);
777
778 return 0;
779}
780
781static int cx25840_attach_adapter(struct i2c_adapter *adapter)
782{
783#ifdef I2C_CLASS_TV_ANALOG
784 if (adapter->class & I2C_CLASS_TV_ANALOG)
785#else
786 if (adapter->id == I2C_HW_B_BT848)
787#endif
788 return i2c_probe(adapter, &addr_data, &cx25840_detect_client);
789 return 0;
790}
791
792static int cx25840_detach_client(struct i2c_client *client)
793{
794 struct cx25840_state *state = i2c_get_clientdata(client);
795 int err;
796
797 err = i2c_detach_client(client);
798 if (err) {
799 return err;
800 }
801
802 kfree(state);
803 kfree(client);
804
805 return 0;
806}
807
808/* ----------------------------------------------------------------------- */
809
810struct i2c_driver i2c_driver_cx25840 = {
811 .name = "cx25840",
812
813 .id = I2C_DRIVERID_CX25840,
814 .flags = I2C_DF_NOTIFY,
815
816 .attach_adapter = cx25840_attach_adapter,
817 .detach_client = cx25840_detach_client,
818 .command = cx25840_command,
819 .owner = THIS_MODULE,
820};
821
822
823static int __init m__init(void)
824{
825 return i2c_add_driver(&i2c_driver_cx25840);
826}
827
828static void __exit m__exit(void)
829{
830 i2c_del_driver(&i2c_driver_cx25840);
831}
832
833module_init(m__init);
834module_exit(m__exit);
835
836/* ----------------------------------------------------------------------- */
837
838static void log_status(struct i2c_client *client)
839{
840 static const char *const fmt_strs[] = {
841 "0x0",
842 "NTSC-M", "NTSC-J", "NTSC-4.43",
843 "PAL-BDGHI", "PAL-M", "PAL-N", "PAL-Nc", "PAL-60",
844 "0x9", "0xA", "0xB",
845 "SECAM",
846 "0xD", "0xE", "0xF"
847 };
848
849 struct cx25840_state *state = i2c_get_clientdata(client);
850 u8 microctrl_vidfmt = cx25840_read(client, 0x80a);
851 u8 vidfmt_sel = cx25840_read(client, 0x400) & 0xf;
852 u8 gen_stat1 = cx25840_read(client, 0x40d);
853 u8 download_ctl = cx25840_read(client, 0x803);
854 u8 mod_det_stat0 = cx25840_read(client, 0x804);
855 u8 mod_det_stat1 = cx25840_read(client, 0x805);
856 u8 audio_config = cx25840_read(client, 0x808);
857 u8 pref_mode = cx25840_read(client, 0x809);
858 u8 afc0 = cx25840_read(client, 0x80b);
859 u8 mute_ctl = cx25840_read(client, 0x8d3);
860 char *p;
861
862 cx25840_info("Video signal: %spresent\n",
863 (microctrl_vidfmt & 0x10) ? "" : "not ");
864 cx25840_info("Detected format: %s\n",
865 fmt_strs[gen_stat1 & 0xf]);
866
867 switch (mod_det_stat0) {
868 case 0x00: p = "mono"; break;
869 case 0x01: p = "stereo"; break;
870 case 0x02: p = "dual"; break;
871 case 0x04: p = "tri"; break;
872 case 0x10: p = "mono with SAP"; break;
873 case 0x11: p = "stereo with SAP"; break;
874 case 0x12: p = "dual with SAP"; break;
875 case 0x14: p = "tri with SAP"; break;
876 case 0xfe: p = "forced mode"; break;
877 default: p = "not defined";
878 }
879 cx25840_info("Detected audio mode: %s\n", p);
880
881 switch (mod_det_stat1) {
882 case 0x00: p = "not defined"; break;
883 case 0x01: p = "EIAJ"; break;
884 case 0x02: p = "A2-M"; break;
885 case 0x03: p = "A2-BG"; break;
886 case 0x04: p = "A2-DK1"; break;
887 case 0x05: p = "A2-DK2"; break;
888 case 0x06: p = "A2-DK3"; break;
889 case 0x07: p = "A1 (6.0 MHz FM Mono)"; break;
890 case 0x08: p = "AM-L"; break;
891 case 0x09: p = "NICAM-BG"; break;
892 case 0x0a: p = "NICAM-DK"; break;
893 case 0x0b: p = "NICAM-I"; break;
894 case 0x0c: p = "NICAM-L"; break;
895 case 0x0d: p = "BTSC/EIAJ/A2-M Mono (4.5 MHz FMMono)"; break;
896 case 0x0e: p = "IF FM Radio"; break;
897 case 0x0f: p = "BTSC"; break;
898 case 0x10: p = "high-deviation FM"; break;
899 case 0x11: p = "very high-deviation FM"; break;
900 case 0xfd: p = "unknown audio standard"; break;
901 case 0xfe: p = "forced audio standard"; break;
902 case 0xff: p = "no detected audio standard"; break;
903 default: p = "not defined";
904 }
905 cx25840_info("Detected audio standard: %s\n", p);
906 cx25840_info("Audio muted: %s\n",
907 (mute_ctl & 0x2) ? "yes" : "no");
908 cx25840_info("Audio microcontroller: %s\n",
909 (download_ctl & 0x10) ? "running" : "stopped");
910
911 switch (audio_config >> 4) {
912 case 0x00: p = "undefined"; break;
913 case 0x01: p = "BTSC"; break;
914 case 0x02: p = "EIAJ"; break;
915 case 0x03: p = "A2-M"; break;
916 case 0x04: p = "A2-BG"; break;
917 case 0x05: p = "A2-DK1"; break;
918 case 0x06: p = "A2-DK2"; break;
919 case 0x07: p = "A2-DK3"; break;
920 case 0x08: p = "A1 (6.0 MHz FM Mono)"; break;
921 case 0x09: p = "AM-L"; break;
922 case 0x0a: p = "NICAM-BG"; break;
923 case 0x0b: p = "NICAM-DK"; break;
924 case 0x0c: p = "NICAM-I"; break;
925 case 0x0d: p = "NICAM-L"; break;
926 case 0x0e: p = "FM radio"; break;
927 case 0x0f: p = "automatic detection"; break;
928 default: p = "undefined";
929 }
930 cx25840_info("Configured audio standard: %s\n", p);
931
932 if ((audio_config >> 4) < 0xF) {
933 switch (audio_config & 0xF) {
934 case 0x00: p = "MONO1 (LANGUAGE A/Mono L+R channel for BTSC, EIAJ, A2)"; break;
935 case 0x01: p = "MONO2 (LANGUAGE B)"; break;
936 case 0x02: p = "MONO3 (STEREO forced MONO)"; break;
937 case 0x03: p = "MONO4 (NICAM ANALOG-Language C/Analog Fallback)"; break;
938 case 0x04: p = "STEREO"; break;
939 case 0x05: p = "DUAL1 (AB)"; break;
940 case 0x06: p = "DUAL2 (AC) (FM)"; break;
941 case 0x07: p = "DUAL3 (BC) (FM)"; break;
942 case 0x08: p = "DUAL4 (AC) (AM)"; break;
943 case 0x09: p = "DUAL5 (BC) (AM)"; break;
944 case 0x0a: p = "SAP"; break;
945 default: p = "undefined";
946 }
947 cx25840_info("Configured audio mode: %s\n", p);
948 } else {
949 switch (audio_config & 0xF) {
950 case 0x00: p = "BG"; break;
951 case 0x01: p = "DK1"; break;
952 case 0x02: p = "DK2"; break;
953 case 0x03: p = "DK3"; break;
954 case 0x04: p = "I"; break;
955 case 0x05: p = "L"; break;
956 case 0x06: p = "BTSC"; break;
957 case 0x07: p = "EIAJ"; break;
958 case 0x08: p = "A2-M"; break;
959 case 0x09: p = "FM Radio"; break;
960 case 0x0f: p = "automatic standard and mode detection"; break;
961 default: p = "undefined";
962 }
963 cx25840_info("Configured audio system: %s\n", p);
964 }
965
966 cx25840_info("Specified standard: %s\n",
967 vidfmt_sel ? fmt_strs[vidfmt_sel] : "automatic detection");
968
969 switch (state->input) {
970 case CX25840_COMPOSITE0: p = "Composite 0"; break;
971 case CX25840_COMPOSITE1: p = "Composite 1"; break;
972 case CX25840_SVIDEO0: p = "S-Video 0"; break;
973 case CX25840_SVIDEO1: p = "S-Video 1"; break;
974 case CX25840_TUNER: p = "Tuner"; break;
975 }
976 cx25840_info("Specified input: %s\n", p);
977 cx25840_info("Specified audio input: %s\n",
978 state->audio_input == 0 ? "Tuner" : "External");
979
980 switch (state->audclk_freq) {
981 case V4L2_AUDCLK_441_KHZ: p = "44.1 kHz"; break;
982 case V4L2_AUDCLK_48_KHZ: p = "48 kHz"; break;
983 case V4L2_AUDCLK_32_KHZ: p = "32 kHz"; break;
984 default: p = "undefined";
985 }
986 cx25840_info("Specified audioclock freq: %s\n", p);
987
988 switch (pref_mode & 0xf) {
989 case 0: p = "mono/language A"; break;
990 case 1: p = "language B"; break;
991 case 2: p = "language C"; break;
992 case 3: p = "analog fallback"; break;
993 case 4: p = "stereo"; break;
994 case 5: p = "language AC"; break;
995 case 6: p = "language BC"; break;
996 case 7: p = "language AB"; break;
997 default: p = "undefined";
998 }
999 cx25840_info("Preferred audio mode: %s\n", p);
1000
1001 if ((audio_config & 0xf) == 0xf) {
1002 switch ((afc0 >> 3) & 0x3) {
1003 case 0: p = "system DK"; break;
1004 case 1: p = "system L"; break;
1005 case 2: p = "autodetect"; break;
1006 default: p = "undefined";
1007 }
1008 cx25840_info("Selected 65 MHz format: %s\n", p);
1009
1010 switch (afc0 & 0x7) {
1011 case 0: p = "chroma"; break;
1012 case 1: p = "BTSC"; break;
1013 case 2: p = "EIAJ"; break;
1014 case 3: p = "A2-M"; break;
1015 case 4: p = "autodetect"; break;
1016 default: p = "undefined";
1017 }
1018 cx25840_info("Selected 45 MHz format: %s\n", p);
1019 }
1020}
diff --git a/drivers/media/video/cx25840/cx25840-firmware.c b/drivers/media/video/cx25840/cx25840-firmware.c
new file mode 100644
index 000000000000..df9d50a75542
--- /dev/null
+++ b/drivers/media/video/cx25840/cx25840-firmware.c
@@ -0,0 +1,167 @@
1/* cx25840 firmware functions
2 *
3 * This program is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU General Public License
5 * as published by the Free Software Foundation; either version 2
6 * of the License, or (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 */
17
18
19#include <linux/module.h>
20#include <linux/i2c.h>
21#include <linux/i2c-algo-bit.h>
22#include <linux/firmware.h>
23#include <media/v4l2-common.h>
24
25#include "cx25840.h"
26
27#define FWFILE "v4l-cx25840.fw"
28#define FWSEND 1024
29
30#define FWDEV(x) &((x)->adapter->dev)
31
32static int fastfw = 1;
33static char *firmware = FWFILE;
34
35module_param(fastfw, bool, 0444);
36module_param(firmware, charp, 0444);
37
38MODULE_PARM_DESC(fastfw, "Load firmware fast [0=100MHz 1=333MHz (default)]");
39MODULE_PARM_DESC(firmware, "Firmware image [default: " FWFILE "]");
40
41static inline void set_i2c_delay(struct i2c_client *client, int delay)
42{
43 struct i2c_algo_bit_data *algod = client->adapter->algo_data;
44
45 /* We aren't guaranteed to be using algo_bit,
46 * so avoid the null pointer dereference
47 * and disable the 'fast firmware load' */
48 if (algod) {
49 algod->udelay = delay;
50 } else {
51 fastfw = 0;
52 }
53}
54
55static inline void start_fw_load(struct i2c_client *client)
56{
57 /* DL_ADDR_LB=0 DL_ADDR_HB=0 */
58 cx25840_write(client, 0x800, 0x00);
59 cx25840_write(client, 0x801, 0x00);
60 // DL_MAP=3 DL_AUTO_INC=0 DL_ENABLE=1
61 cx25840_write(client, 0x803, 0x0b);
62 /* AUTO_INC_DIS=1 */
63 cx25840_write(client, 0x000, 0x20);
64
65 if (fastfw)
66 set_i2c_delay(client, 3);
67}
68
69static inline void end_fw_load(struct i2c_client *client)
70{
71 if (fastfw)
72 set_i2c_delay(client, 10);
73
74 /* AUTO_INC_DIS=0 */
75 cx25840_write(client, 0x000, 0x00);
76 /* DL_ENABLE=0 */
77 cx25840_write(client, 0x803, 0x03);
78}
79
80static inline int check_fw_load(struct i2c_client *client, int size)
81{
82 /* DL_ADDR_HB DL_ADDR_LB */
83 int s = cx25840_read(client, 0x801) << 8;
84 s |= cx25840_read(client, 0x800);
85
86 if (size != s) {
87 cx25840_err("firmware %s load failed\n", firmware);
88 return -EINVAL;
89 }
90
91 cx25840_info("loaded %s firmware (%d bytes)\n", firmware, size);
92 return 0;
93}
94
95static inline int fw_write(struct i2c_client *client, u8 * data, int size)
96{
97 if (i2c_master_send(client, data, size) < size) {
98
99 if (fastfw) {
100 cx25840_err("333MHz i2c firmware load failed\n");
101 fastfw = 0;
102 set_i2c_delay(client, 10);
103
104 if (i2c_master_send(client, data, size) < size) {
105 cx25840_err
106 ("100MHz i2c firmware load failed\n");
107 return -ENOSYS;
108 }
109
110 } else {
111 cx25840_err("firmware load i2c failure\n");
112 return -ENOSYS;
113 }
114
115 }
116
117 return 0;
118}
119
120int cx25840_loadfw(struct i2c_client *client)
121{
122 const struct firmware *fw = NULL;
123 u8 buffer[4], *ptr;
124 int size, send, retval;
125
126 if (request_firmware(&fw, firmware, FWDEV(client)) != 0) {
127 cx25840_err("unable to open firmware %s\n", firmware);
128 return -EINVAL;
129 }
130
131 start_fw_load(client);
132
133 buffer[0] = 0x08;
134 buffer[1] = 0x02;
135 buffer[2] = fw->data[0];
136 buffer[3] = fw->data[1];
137 retval = fw_write(client, buffer, 4);
138
139 if (retval < 0) {
140 release_firmware(fw);
141 return retval;
142 }
143
144 size = fw->size - 2;
145 ptr = fw->data;
146 while (size > 0) {
147 ptr[0] = 0x08;
148 ptr[1] = 0x02;
149 send = size > (FWSEND - 2) ? FWSEND : size + 2;
150 retval = fw_write(client, ptr, send);
151
152 if (retval < 0) {
153 release_firmware(fw);
154 return retval;
155 }
156
157 size -= FWSEND - 2;
158 ptr += FWSEND - 2;
159 }
160
161 end_fw_load(client);
162
163 size = fw->size;
164 release_firmware(fw);
165
166 return check_fw_load(client, size);
167}
diff --git a/drivers/media/video/cx25840/cx25840-vbi.c b/drivers/media/video/cx25840/cx25840-vbi.c
new file mode 100644
index 000000000000..13ba4e15ddea
--- /dev/null
+++ b/drivers/media/video/cx25840/cx25840-vbi.c
@@ -0,0 +1,315 @@
1/* cx25840 VBI functions
2 *
3 * This program is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU General Public License
5 * as published by the Free Software Foundation; either version 2
6 * of the License, or (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 */
17
18
19#include <linux/videodev2.h>
20#include <linux/i2c.h>
21#include <media/v4l2-common.h>
22
23#include "cx25840.h"
24
25static inline int odd_parity(u8 c)
26{
27 c ^= (c >> 4);
28 c ^= (c >> 2);
29 c ^= (c >> 1);
30
31 return c & 1;
32}
33
34static inline int decode_vps(u8 * dst, u8 * p)
35{
36 static const u8 biphase_tbl[] = {
37 0xf0, 0x78, 0x70, 0xf0, 0xb4, 0x3c, 0x34, 0xb4,
38 0xb0, 0x38, 0x30, 0xb0, 0xf0, 0x78, 0x70, 0xf0,
39 0xd2, 0x5a, 0x52, 0xd2, 0x96, 0x1e, 0x16, 0x96,
40 0x92, 0x1a, 0x12, 0x92, 0xd2, 0x5a, 0x52, 0xd2,
41 0xd0, 0x58, 0x50, 0xd0, 0x94, 0x1c, 0x14, 0x94,
42 0x90, 0x18, 0x10, 0x90, 0xd0, 0x58, 0x50, 0xd0,
43 0xf0, 0x78, 0x70, 0xf0, 0xb4, 0x3c, 0x34, 0xb4,
44 0xb0, 0x38, 0x30, 0xb0, 0xf0, 0x78, 0x70, 0xf0,
45 0xe1, 0x69, 0x61, 0xe1, 0xa5, 0x2d, 0x25, 0xa5,
46 0xa1, 0x29, 0x21, 0xa1, 0xe1, 0x69, 0x61, 0xe1,
47 0xc3, 0x4b, 0x43, 0xc3, 0x87, 0x0f, 0x07, 0x87,
48 0x83, 0x0b, 0x03, 0x83, 0xc3, 0x4b, 0x43, 0xc3,
49 0xc1, 0x49, 0x41, 0xc1, 0x85, 0x0d, 0x05, 0x85,
50 0x81, 0x09, 0x01, 0x81, 0xc1, 0x49, 0x41, 0xc1,
51 0xe1, 0x69, 0x61, 0xe1, 0xa5, 0x2d, 0x25, 0xa5,
52 0xa1, 0x29, 0x21, 0xa1, 0xe1, 0x69, 0x61, 0xe1,
53 0xe0, 0x68, 0x60, 0xe0, 0xa4, 0x2c, 0x24, 0xa4,
54 0xa0, 0x28, 0x20, 0xa0, 0xe0, 0x68, 0x60, 0xe0,
55 0xc2, 0x4a, 0x42, 0xc2, 0x86, 0x0e, 0x06, 0x86,
56 0x82, 0x0a, 0x02, 0x82, 0xc2, 0x4a, 0x42, 0xc2,
57 0xc0, 0x48, 0x40, 0xc0, 0x84, 0x0c, 0x04, 0x84,
58 0x80, 0x08, 0x00, 0x80, 0xc0, 0x48, 0x40, 0xc0,
59 0xe0, 0x68, 0x60, 0xe0, 0xa4, 0x2c, 0x24, 0xa4,
60 0xa0, 0x28, 0x20, 0xa0, 0xe0, 0x68, 0x60, 0xe0,
61 0xf0, 0x78, 0x70, 0xf0, 0xb4, 0x3c, 0x34, 0xb4,
62 0xb0, 0x38, 0x30, 0xb0, 0xf0, 0x78, 0x70, 0xf0,
63 0xd2, 0x5a, 0x52, 0xd2, 0x96, 0x1e, 0x16, 0x96,
64 0x92, 0x1a, 0x12, 0x92, 0xd2, 0x5a, 0x52, 0xd2,
65 0xd0, 0x58, 0x50, 0xd0, 0x94, 0x1c, 0x14, 0x94,
66 0x90, 0x18, 0x10, 0x90, 0xd0, 0x58, 0x50, 0xd0,
67 0xf0, 0x78, 0x70, 0xf0, 0xb4, 0x3c, 0x34, 0xb4,
68 0xb0, 0x38, 0x30, 0xb0, 0xf0, 0x78, 0x70, 0xf0,
69 };
70
71 u8 c, err = 0;
72 int i;
73
74 for (i = 0; i < 2 * 13; i += 2) {
75 err |= biphase_tbl[p[i]] | biphase_tbl[p[i + 1]];
76 c = (biphase_tbl[p[i + 1]] & 0xf) |
77 ((biphase_tbl[p[i]] & 0xf) << 4);
78 dst[i / 2] = c;
79 }
80
81 return err & 0xf0;
82}
83
84void cx25840_vbi_setup(struct i2c_client *client)
85{
86 v4l2_std_id std = cx25840_get_v4lstd(client);
87
88 if (std & ~V4L2_STD_NTSC) {
89 /* datasheet startup, step 8d */
90 cx25840_write(client, 0x49f, 0x11);
91
92 cx25840_write(client, 0x470, 0x84);
93 cx25840_write(client, 0x471, 0x00);
94 cx25840_write(client, 0x472, 0x2d);
95 cx25840_write(client, 0x473, 0x5d);
96
97 cx25840_write(client, 0x474, 0x24);
98 cx25840_write(client, 0x475, 0x40);
99 cx25840_write(client, 0x476, 0x24);
100 cx25840_write(client, 0x477, 0x28);
101
102 cx25840_write(client, 0x478, 0x1f);
103 cx25840_write(client, 0x479, 0x02);
104
105 if (std & V4L2_STD_SECAM) {
106 cx25840_write(client, 0x47a, 0x80);
107 cx25840_write(client, 0x47b, 0x00);
108 cx25840_write(client, 0x47c, 0x5f);
109 cx25840_write(client, 0x47d, 0x42);
110 } else {
111 cx25840_write(client, 0x47a, 0x90);
112 cx25840_write(client, 0x47b, 0x20);
113 cx25840_write(client, 0x47c, 0x63);
114 cx25840_write(client, 0x47d, 0x82);
115 }
116
117 cx25840_write(client, 0x47e, 0x0a);
118 cx25840_write(client, 0x47f, 0x01);
119 } else {
120 /* datasheet startup, step 8d */
121 cx25840_write(client, 0x49f, 0x14);
122
123 cx25840_write(client, 0x470, 0x7a);
124 cx25840_write(client, 0x471, 0x00);
125 cx25840_write(client, 0x472, 0x2d);
126 cx25840_write(client, 0x473, 0x5b);
127
128 cx25840_write(client, 0x474, 0x1a);
129 cx25840_write(client, 0x475, 0x70);
130 cx25840_write(client, 0x476, 0x1e);
131 cx25840_write(client, 0x477, 0x1e);
132
133 cx25840_write(client, 0x478, 0x1f);
134 cx25840_write(client, 0x479, 0x02);
135 cx25840_write(client, 0x47a, 0x50);
136 cx25840_write(client, 0x47b, 0x66);
137
138 cx25840_write(client, 0x47c, 0x1f);
139 cx25840_write(client, 0x47d, 0x7c);
140 cx25840_write(client, 0x47e, 0x08);
141 cx25840_write(client, 0x47f, 0x00);
142 }
143}
144
145int cx25840_vbi(struct i2c_client *client, unsigned int cmd, void *arg)
146{
147 struct v4l2_format *fmt;
148 struct v4l2_sliced_vbi_format *svbi;
149
150 switch (cmd) {
151 case VIDIOC_G_FMT:
152 {
153 static u16 lcr2vbi[] = {
154 0, V4L2_SLICED_TELETEXT_B, 0, /* 1 */
155 0, V4L2_SLICED_WSS_625, 0, /* 4 */
156 V4L2_SLICED_CAPTION_525, /* 6 */
157 0, 0, V4L2_SLICED_VPS, 0, 0, /* 9 */
158 0, 0, 0, 0
159 };
160 int i;
161
162 fmt = arg;
163 if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
164 return -EINVAL;
165 svbi = &fmt->fmt.sliced;
166 memset(svbi, 0, sizeof(*svbi));
167 /* we're done if raw VBI is active */
168 if ((cx25840_read(client, 0x404) & 0x10) == 0)
169 break;
170
171 for (i = 7; i <= 23; i++) {
172 u8 v = cx25840_read(client, 0x424 + i - 7);
173
174 svbi->service_lines[0][i] = lcr2vbi[v >> 4];
175 svbi->service_lines[1][i] = lcr2vbi[v & 0xf];
176 svbi->service_set |=
177 svbi->service_lines[0][i] | svbi->service_lines[1][i];
178 }
179 break;
180 }
181
182 case VIDIOC_S_FMT:
183 {
184 int is_pal = !(cx25840_get_v4lstd(client) & V4L2_STD_NTSC);
185 int vbi_offset = is_pal ? 1 : 0;
186 int i, x;
187 u8 lcr[24];
188
189 fmt = arg;
190 if (fmt->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
191 return -EINVAL;
192 svbi = &fmt->fmt.sliced;
193 if (svbi->service_set == 0) {
194 /* raw VBI */
195 memset(svbi, 0, sizeof(*svbi));
196
197 /* Setup VBI */
198 cx25840_vbi_setup(client);
199
200 /* VBI Offset */
201 cx25840_write(client, 0x47f, vbi_offset);
202 cx25840_write(client, 0x404, 0x2e);
203 break;
204 }
205
206 for (x = 0; x <= 23; x++)
207 lcr[x] = 0x00;
208
209 /* Setup VBI */
210 cx25840_vbi_setup(client);
211
212 /* Sliced VBI */
213 cx25840_write(client, 0x404, 0x36); /* Ancillery data */
214 cx25840_write(client, 0x406, 0x13);
215 cx25840_write(client, 0x47f, vbi_offset);
216
217 if (is_pal) {
218 for (i = 0; i <= 6; i++)
219 svbi->service_lines[0][i] =
220 svbi->service_lines[1][i] = 0;
221 } else {
222 for (i = 0; i <= 9; i++)
223 svbi->service_lines[0][i] =
224 svbi->service_lines[1][i] = 0;
225
226 for (i = 22; i <= 23; i++)
227 svbi->service_lines[0][i] =
228 svbi->service_lines[1][i] = 0;
229 }
230
231 for (i = 7; i <= 23; i++) {
232 for (x = 0; x <= 1; x++) {
233 switch (svbi->service_lines[1-x][i]) {
234 case V4L2_SLICED_TELETEXT_B:
235 lcr[i] |= 1 << (4 * x);
236 break;
237 case V4L2_SLICED_WSS_625:
238 lcr[i] |= 4 << (4 * x);
239 break;
240 case V4L2_SLICED_CAPTION_525:
241 lcr[i] |= 6 << (4 * x);
242 break;
243 case V4L2_SLICED_VPS:
244 lcr[i] |= 9 << (4 * x);
245 break;
246 }
247 }
248 }
249
250 for (x = 1, i = 0x424; i <= 0x434; i++, x++) {
251 cx25840_write(client, i, lcr[6 + x]);
252 }
253
254 cx25840_write(client, 0x43c, 0x16);
255
256 if (is_pal) {
257 cx25840_write(client, 0x474, 0x2a);
258 } else {
259 cx25840_write(client, 0x474, 0x1a + 6);
260 }
261 break;
262 }
263
264 case VIDIOC_INT_DECODE_VBI_LINE:
265 {
266 struct v4l2_decode_vbi_line *vbi = arg;
267 u8 *p = vbi->p;
268 int id1, id2, l, err = 0;
269
270 if (p[0] || p[1] != 0xff || p[2] != 0xff ||
271 (p[3] != 0x55 && p[3] != 0x91)) {
272 vbi->line = vbi->type = 0;
273 break;
274 }
275
276 p += 4;
277 id1 = p[-1];
278 id2 = p[0] & 0xf;
279 l = p[2] & 0x3f;
280 l += 5;
281 p += 4;
282
283 switch (id2) {
284 case 1:
285 id2 = V4L2_SLICED_TELETEXT_B;
286 break;
287 case 4:
288 id2 = V4L2_SLICED_WSS_625;
289 break;
290 case 6:
291 id2 = V4L2_SLICED_CAPTION_525;
292 err = !odd_parity(p[0]) || !odd_parity(p[1]);
293 break;
294 case 9:
295 id2 = V4L2_SLICED_VPS;
296 if (decode_vps(p, p) != 0) {
297 err = 1;
298 }
299 break;
300 default:
301 id2 = 0;
302 err = 1;
303 break;
304 }
305
306 vbi->type = err ? 0 : id2;
307 vbi->line = err ? 0 : l;
308 vbi->is_second_field = err ? 0 : (id1 == 0x55);
309 vbi->p = p;
310 break;
311 }
312 }
313
314 return 0;
315}
diff --git a/drivers/media/video/cx25840/cx25840.h b/drivers/media/video/cx25840/cx25840.h
new file mode 100644
index 000000000000..5c3f0639fb77
--- /dev/null
+++ b/drivers/media/video/cx25840/cx25840.h
@@ -0,0 +1,85 @@
1/* cx25840 API header
2 *
3 * Copyright (C) 2003-2004 Chris Kennedy
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 */
19
20#ifndef _CX25840_H_
21#define _CX25840_H_
22
23
24#include <linux/videodev2.h>
25#include <linux/i2c.h>
26
27extern int cx25840_debug;
28
29#define cx25840_dbg(fmt, arg...) do { if (cx25840_debug) \
30 printk(KERN_INFO "%s debug %d-%04x: " fmt, client->driver->name, \
31 i2c_adapter_id(client->adapter), client->addr , ## arg); } while (0)
32
33#define cx25840_err(fmt, arg...) do { \
34 printk(KERN_ERR "%s %d-%04x: " fmt, client->driver->name, \
35 i2c_adapter_id(client->adapter), client->addr , ## arg); } while (0)
36
37#define cx25840_info(fmt, arg...) do { \
38 printk(KERN_INFO "%s %d-%04x: " fmt, client->driver->name, \
39 i2c_adapter_id(client->adapter), client->addr , ## arg); } while (0)
40
41#define CX25840_CID_CARDTYPE (V4L2_CID_PRIVATE_BASE+0)
42
43enum cx25840_cardtype {
44 CARDTYPE_PVR150,
45 CARDTYPE_PG600
46};
47
48enum cx25840_input {
49 CX25840_TUNER,
50 CX25840_COMPOSITE0,
51 CX25840_COMPOSITE1,
52 CX25840_SVIDEO0,
53 CX25840_SVIDEO1
54};
55
56struct cx25840_state {
57 enum cx25840_cardtype cardtype;
58 enum cx25840_input input;
59 int audio_input;
60 enum v4l2_audio_clock_freq audclk_freq;
61};
62
63/* ----------------------------------------------------------------------- */
64/* cx25850-core.c */
65int cx25840_write(struct i2c_client *client, u16 addr, u8 value);
66int cx25840_write4(struct i2c_client *client, u16 addr, u32 value);
67u8 cx25840_read(struct i2c_client *client, u16 addr);
68u32 cx25840_read4(struct i2c_client *client, u16 addr);
69int cx25840_and_or(struct i2c_client *client, u16 addr, u8 mask, u8 value);
70v4l2_std_id cx25840_get_v4lstd(struct i2c_client *client);
71
72/* ----------------------------------------------------------------------- */
73/* cx25850-firmware.c */
74int cx25840_loadfw(struct i2c_client *client);
75
76/* ----------------------------------------------------------------------- */
77/* cx25850-audio.c */
78int cx25840_audio(struct i2c_client *client, unsigned int cmd, void *arg);
79
80/* ----------------------------------------------------------------------- */
81/* cx25850-vbi.c */
82void cx25840_vbi_setup(struct i2c_client *client);
83int cx25840_vbi(struct i2c_client *client, unsigned int cmd, void *arg);
84
85#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-15 14:56:20 -0500