V4L/DVB (11180): pvrusb2: Tie in msp3400 sub-device support
[linux-2.6] / drivers / media / video / pvrusb2 / pvrusb2-cx2584x-v4l.c
1 /*
2  *
3  *
4  *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
5  *  Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
6  *
7  *  This program is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License as published by
9  *  the Free Software Foundation; either version 2 of the License
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 /*
23
24    This source file is specifically designed to interface with the
25    cx2584x, in kernels 2.6.16 or newer.
26
27 */
28
29 #include "pvrusb2-cx2584x-v4l.h"
30 #include "pvrusb2-video-v4l.h"
31 #include "pvrusb2-i2c-cmd-v4l2.h"
32
33
34 #include "pvrusb2-hdw-internal.h"
35 #include "pvrusb2-debug.h"
36 #include <media/cx25840.h>
37 #include <linux/videodev2.h>
38 #include <media/v4l2-common.h>
39 #include <linux/errno.h>
40 #include <linux/slab.h>
41
42 struct pvr2_v4l_cx2584x {
43         struct pvr2_i2c_handler handler;
44         struct pvr2_decoder_ctrl ctrl;
45         struct pvr2_i2c_client *client;
46         struct pvr2_hdw *hdw;
47         unsigned long stale_mask;
48 };
49
50
51 struct routing_scheme_item {
52         int vid;
53         int aud;
54 };
55
56 struct routing_scheme {
57         const struct routing_scheme_item *def;
58         unsigned int cnt;
59 };
60
61 static const struct routing_scheme_item routing_scheme0[] = {
62         [PVR2_CVAL_INPUT_TV] = {
63                 .vid = CX25840_COMPOSITE7,
64                 .aud = CX25840_AUDIO8,
65         },
66         [PVR2_CVAL_INPUT_RADIO] = { /* Treat the same as composite */
67                 .vid = CX25840_COMPOSITE3,
68                 .aud = CX25840_AUDIO_SERIAL,
69         },
70         [PVR2_CVAL_INPUT_COMPOSITE] = {
71                 .vid = CX25840_COMPOSITE3,
72                 .aud = CX25840_AUDIO_SERIAL,
73         },
74         [PVR2_CVAL_INPUT_SVIDEO] = {
75                 .vid = CX25840_SVIDEO1,
76                 .aud = CX25840_AUDIO_SERIAL,
77         },
78 };
79
80 /* Specific to gotview device */
81 static const struct routing_scheme_item routing_schemegv[] = {
82         [PVR2_CVAL_INPUT_TV] = {
83                 .vid = CX25840_COMPOSITE2,
84                 .aud = CX25840_AUDIO5,
85         },
86         [PVR2_CVAL_INPUT_RADIO] = {
87                 /* line-in is used for radio and composite.  A GPIO is
88                    used to switch between the two choices. */
89                 .vid = CX25840_COMPOSITE1,
90                 .aud = CX25840_AUDIO_SERIAL,
91         },
92         [PVR2_CVAL_INPUT_COMPOSITE] = {
93                 .vid = CX25840_COMPOSITE1,
94                 .aud = CX25840_AUDIO_SERIAL,
95         },
96         [PVR2_CVAL_INPUT_SVIDEO] = {
97                 .vid = (CX25840_SVIDEO_LUMA3|CX25840_SVIDEO_CHROMA4),
98                 .aud = CX25840_AUDIO_SERIAL,
99         },
100 };
101
102 static const struct routing_scheme routing_schemes[] = {
103         [PVR2_ROUTING_SCHEME_HAUPPAUGE] = {
104                 .def = routing_scheme0,
105                 .cnt = ARRAY_SIZE(routing_scheme0),
106         },
107         [PVR2_ROUTING_SCHEME_GOTVIEW] = {
108                 .def = routing_schemegv,
109                 .cnt = ARRAY_SIZE(routing_schemegv),
110         },
111 };
112
113 static void set_input(struct pvr2_v4l_cx2584x *ctxt)
114 {
115         struct pvr2_hdw *hdw = ctxt->hdw;
116         struct v4l2_routing route;
117         enum cx25840_video_input vid_input;
118         enum cx25840_audio_input aud_input;
119         const struct routing_scheme *sp;
120         unsigned int sid = hdw->hdw_desc->signal_routing_scheme;
121
122         memset(&route,0,sizeof(route));
123
124         if ((sid < ARRAY_SIZE(routing_schemes)) &&
125             ((sp = routing_schemes + sid) != NULL) &&
126             (hdw->input_val >= 0) &&
127             (hdw->input_val < sp->cnt)) {
128                 vid_input = sp->def[hdw->input_val].vid;
129                 aud_input = sp->def[hdw->input_val].aud;
130         } else {
131                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
132                            "*** WARNING *** i2c cx2584x set_input:"
133                            " Invalid routing scheme (%u) and/or input (%d)",
134                            sid,hdw->input_val);
135                 return;
136         }
137
138         pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx2584x set_input vid=0x%x aud=0x%x",
139                    vid_input,aud_input);
140         route.input = (u32)vid_input;
141         pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_S_VIDEO_ROUTING,&route);
142         route.input = (u32)aud_input;
143         pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_S_AUDIO_ROUTING,&route);
144 }
145
146
147 static int check_input(struct pvr2_v4l_cx2584x *ctxt)
148 {
149         struct pvr2_hdw *hdw = ctxt->hdw;
150         return hdw->input_dirty != 0;
151 }
152
153
154 static void set_audio(struct pvr2_v4l_cx2584x *ctxt)
155 {
156         u32 val;
157         struct pvr2_hdw *hdw = ctxt->hdw;
158
159         pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx2584x set_audio %d",
160                    hdw->srate_val);
161         switch (hdw->srate_val) {
162         default:
163         case V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000:
164                 val = 48000;
165                 break;
166         case V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100:
167                 val = 44100;
168                 break;
169         case V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000:
170                 val = 32000;
171                 break;
172         }
173         pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_AUDIO_CLOCK_FREQ,&val);
174 }
175
176
177 static int check_audio(struct pvr2_v4l_cx2584x *ctxt)
178 {
179         struct pvr2_hdw *hdw = ctxt->hdw;
180         return hdw->srate_dirty != 0;
181 }
182
183
184 struct pvr2_v4l_cx2584x_ops {
185         void (*update)(struct pvr2_v4l_cx2584x *);
186         int (*check)(struct pvr2_v4l_cx2584x *);
187 };
188
189
190 static const struct pvr2_v4l_cx2584x_ops decoder_ops[] = {
191         { .update = set_input, .check = check_input},
192         { .update = set_audio, .check = check_audio},
193 };
194
195
196 static void decoder_detach(struct pvr2_v4l_cx2584x *ctxt)
197 {
198         ctxt->client->handler = NULL;
199         pvr2_hdw_set_decoder(ctxt->hdw,NULL);
200         kfree(ctxt);
201 }
202
203
204 static int decoder_check(struct pvr2_v4l_cx2584x *ctxt)
205 {
206         unsigned long msk;
207         unsigned int idx;
208
209         for (idx = 0; idx < ARRAY_SIZE(decoder_ops); idx++) {
210                 msk = 1 << idx;
211                 if (ctxt->stale_mask & msk) continue;
212                 if (decoder_ops[idx].check(ctxt)) {
213                         ctxt->stale_mask |= msk;
214                 }
215         }
216         return ctxt->stale_mask != 0;
217 }
218
219
220 static void decoder_update(struct pvr2_v4l_cx2584x *ctxt)
221 {
222         unsigned long msk;
223         unsigned int idx;
224
225         for (idx = 0; idx < ARRAY_SIZE(decoder_ops); idx++) {
226                 msk = 1 << idx;
227                 if (!(ctxt->stale_mask & msk)) continue;
228                 ctxt->stale_mask &= ~msk;
229                 decoder_ops[idx].update(ctxt);
230         }
231 }
232
233
234 static void decoder_enable(struct pvr2_v4l_cx2584x *ctxt,int fl)
235 {
236         pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx25840 decoder_enable(%d)",fl);
237         pvr2_v4l2_cmd_stream(ctxt->client,fl);
238 }
239
240
241 static int decoder_detect(struct pvr2_i2c_client *cp)
242 {
243         int ret;
244         /* Attempt to query the decoder - let's see if it will answer */
245         struct v4l2_queryctrl qc;
246
247         memset(&qc,0,sizeof(qc));
248
249         qc.id = V4L2_CID_BRIGHTNESS;
250
251         ret = pvr2_i2c_client_cmd(cp,VIDIOC_QUERYCTRL,&qc);
252         return ret == 0; /* Return true if it answered */
253 }
254
255
256 static unsigned int decoder_describe(struct pvr2_v4l_cx2584x *ctxt,
257                                      char *buf,unsigned int cnt)
258 {
259         return scnprintf(buf,cnt,"handler: pvrusb2-cx2584x-v4l");
260 }
261
262
263 static void decoder_reset(struct pvr2_v4l_cx2584x *ctxt)
264 {
265         int ret;
266         ret = pvr2_i2c_client_cmd(ctxt->client,VIDIOC_INT_RESET,NULL);
267         pvr2_trace(PVR2_TRACE_CHIPS,"i2c cx25840 decoder_reset (ret=%d)",ret);
268 }
269
270
271 static const struct pvr2_i2c_handler_functions hfuncs = {
272         .detach = (void (*)(void *))decoder_detach,
273         .check = (int (*)(void *))decoder_check,
274         .update = (void (*)(void *))decoder_update,
275         .describe = (unsigned int (*)(void *,char *,unsigned int))decoder_describe,
276 };
277
278
279 int pvr2_i2c_cx2584x_v4l_setup(struct pvr2_hdw *hdw,
280                                struct pvr2_i2c_client *cp)
281 {
282         struct pvr2_v4l_cx2584x *ctxt;
283
284         if (hdw->decoder_ctrl) return 0;
285         if (cp->handler) return 0;
286         if (!decoder_detect(cp)) return 0;
287
288         ctxt = kzalloc(sizeof(*ctxt),GFP_KERNEL);
289         if (!ctxt) return 0;
290
291         ctxt->handler.func_data = ctxt;
292         ctxt->handler.func_table = &hfuncs;
293         ctxt->ctrl.ctxt = ctxt;
294         ctxt->ctrl.detach = (void (*)(void *))decoder_detach;
295         ctxt->ctrl.enable = (void (*)(void *,int))decoder_enable;
296         ctxt->ctrl.force_reset = (void (*)(void*))decoder_reset;
297         ctxt->client = cp;
298         ctxt->hdw = hdw;
299         ctxt->stale_mask = (1 << ARRAY_SIZE(decoder_ops)) - 1;
300         pvr2_hdw_set_decoder(hdw,&ctxt->ctrl);
301         cp->handler = &ctxt->handler;
302         {
303                 /*
304                   Mike Isely <isely@pobox.com> 19-Nov-2006 - This bit
305                   of nuttiness for cx25840 causes that module to
306                   correctly set up its video scaling.  This is really
307                   a problem in the cx25840 module itself, but we work
308                   around it here.  The problem has not been seen in
309                   ivtv because there VBI is supported and set up.  We
310                   don't do VBI here (at least not yet) and thus we
311                   never attempted to even set it up.
312                  */
313                 struct v4l2_format fmt;
314                 memset(&fmt,0,sizeof(fmt));
315                 fmt.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
316                 pvr2_i2c_client_cmd(ctxt->client,VIDIOC_S_FMT,&fmt);
317         }
318         pvr2_trace(PVR2_TRACE_CHIPS,"i2c 0x%x cx2584x V4L2 handler set up",
319                    cp->client->addr);
320         return !0;
321 }
322
323
324
325
326
327 /*
328   Stuff for Emacs to see, in order to encourage consistent editing style:
329   *** Local Variables: ***
330   *** mode: c ***
331   *** fill-column: 70 ***
332   *** tab-width: 8 ***
333   *** c-basic-offset: 8 ***
334   *** End: ***
335   */