drivers/media/video/pvrusb2/pvrusb2-cx2584x-v4l.c

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