drivers/media/usb/hdpvr/hdpvr-control.c

   1 /*
   2  * Hauppauge HD PVR USB driver - video 4 linux 2 interface
   3  *
   4  * Copyright (C) 2008      Janne Grunau (j@jannau.net)
   5  *
   6  *      This program is free software; you can redistribute it and/or
   7  *      modify it under the terms of the GNU General Public License as
   8  *      published by the Free Software Foundation, version 2.
   9  *
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/errno.h>
  14 #include <linux/init.h>
  15 #include <linux/slab.h>
  16 #include <linux/module.h>
  17 #include <linux/usb.h>
  18 #include <linux/mutex.h>
  19
  20 #include <linux/videodev2.h>
  21
  22 #include <media/v4l2-common.h>
  23
  24 #include "hdpvr.h"
  25
  26
  27 int hdpvr_config_call(struct hdpvr_device *dev, uint value, u8 valbuf)
  28 {
  29         int ret;
  30         char request_type = 0x38, snd_request = 0x01;
  31
  32         mutex_lock(&dev->usbc_mutex);
  33         dev->usbc_buf[0] = valbuf;
  34         ret = usb_control_msg(dev->udev,
  35                               usb_sndctrlpipe(dev->udev, 0),
  36                               snd_request, 0x00 | request_type,
  37                               value, CTRL_DEFAULT_INDEX,
  38                               dev->usbc_buf, 1, 10000);
  39
  40         mutex_unlock(&dev->usbc_mutex);
  41         v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev,
  42                  "config call request for value 0x%x returned %d\n", value,
  43                  ret);
  44
  45         return ret < 0 ? ret : 0;
  46 }
  47
  48 int get_video_info(struct hdpvr_device *dev, struct hdpvr_video_info *vidinf)
  49 {
  50         int ret;
  51
  52         vidinf->valid = false;
  53         mutex_lock(&dev->usbc_mutex);
  54         ret = usb_control_msg(dev->udev,
  55                               usb_rcvctrlpipe(dev->udev, 0),
  56                               0x81, 0x80 | 0x38,
  57                               0x1400, 0x0003,
  58                               dev->usbc_buf, 5,
  59                               1000);
  60
  61 #ifdef HDPVR_DEBUG
  62         if (hdpvr_debug & MSG_INFO) {
  63                 char print_buf[15];
  64                 hex_dump_to_buffer(dev->usbc_buf, 5, 16, 1, print_buf,
  65                                    sizeof(print_buf), 0);
  66                 v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev,
  67                          "get video info returned: %d, %s\n", ret, print_buf);
  68         }
  69 #endif
  70         mutex_unlock(&dev->usbc_mutex);
  71
  72         if (ret < 0)
  73                 return ret;
  74
  75         vidinf->width   = dev->usbc_buf[1] << 8 | dev->usbc_buf[0];
  76         vidinf->height  = dev->usbc_buf[3] << 8 | dev->usbc_buf[2];
  77         vidinf->fps     = dev->usbc_buf[4];
  78         vidinf->valid   = vidinf->width && vidinf->height && vidinf->fps;
  79
  80         return 0;
  81 }
  82
  83 int get_input_lines_info(struct hdpvr_device *dev)
  84 {
  85 #ifdef HDPVR_DEBUG
  86         char print_buf[9];
  87 #endif
  88         int ret, lines;
  89
  90         mutex_lock(&dev->usbc_mutex);
  91         ret = usb_control_msg(dev->udev,
  92                               usb_rcvctrlpipe(dev->udev, 0),
  93                               0x81, 0x80 | 0x38,
  94                               0x1800, 0x0003,
  95                               dev->usbc_buf, 3,
  96                               1000);
  97
  98 #ifdef HDPVR_DEBUG
  99         if (hdpvr_debug & MSG_INFO) {
 100                 hex_dump_to_buffer(dev->usbc_buf, 3, 16, 1, print_buf,
 101                                    sizeof(print_buf), 0);
 102                 v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev,
 103                          "get input lines info returned: %d, %s\n", ret,
 104                          print_buf);
 105         }
 106 #else
 107         (void)ret;      /* suppress compiler warning */
 108 #endif
 109         lines = dev->usbc_buf[1] << 8 | dev->usbc_buf[0];
 110         mutex_unlock(&dev->usbc_mutex);
 111         return lines;
 112 }
 113
 114
 115 int hdpvr_set_bitrate(struct hdpvr_device *dev)
 116 {
 117         int ret;
 118
 119         mutex_lock(&dev->usbc_mutex);
 120         memset(dev->usbc_buf, 0, 4);
 121         dev->usbc_buf[0] = dev->options.bitrate;
 122         dev->usbc_buf[2] = dev->options.peak_bitrate;
 123
 124         ret = usb_control_msg(dev->udev,
 125                               usb_sndctrlpipe(dev->udev, 0),
 126                               0x01, 0x38, CTRL_BITRATE_VALUE,
 127                               CTRL_DEFAULT_INDEX, dev->usbc_buf, 4, 1000);
 128         mutex_unlock(&dev->usbc_mutex);
 129
 130         return ret;
 131 }
 132
 133 int hdpvr_set_audio(struct hdpvr_device *dev, u8 input,
 134                     enum v4l2_mpeg_audio_encoding codec)
 135 {
 136         int ret = 0;
 137
 138         if (dev->flags & HDPVR_FLAG_AC3_CAP) {
 139                 mutex_lock(&dev->usbc_mutex);
 140                 memset(dev->usbc_buf, 0, 2);
 141                 dev->usbc_buf[0] = input;
 142                 if (codec == V4L2_MPEG_AUDIO_ENCODING_AAC)
 143                         dev->usbc_buf[1] = 0;
 144                 else if (codec == V4L2_MPEG_AUDIO_ENCODING_AC3)
 145                         dev->usbc_buf[1] = 1;
 146                 else {
 147                         mutex_unlock(&dev->usbc_mutex);
 148                         v4l2_err(&dev->v4l2_dev, "invalid audio codec %d\n",
 149                                  codec);
 150                         ret = -EINVAL;
 151                         goto error;
 152                 }
 153
 154                 ret = usb_control_msg(dev->udev,
 155                                       usb_sndctrlpipe(dev->udev, 0),
 156                                       0x01, 0x38, CTRL_AUDIO_INPUT_VALUE,
 157                                       CTRL_DEFAULT_INDEX, dev->usbc_buf, 2,
 158                                       1000);
 159                 mutex_unlock(&dev->usbc_mutex);
 160                 if (ret == 2)
 161                         ret = 0;
 162         } else
 163                 ret = hdpvr_config_call(dev, CTRL_AUDIO_INPUT_VALUE, input);
 164 error:
 165         return ret;
 166 }
 167
 168 int hdpvr_set_options(struct hdpvr_device *dev)
 169 {
 170         hdpvr_config_call(dev, CTRL_VIDEO_STD_TYPE, dev->options.video_std);
 171
 172         hdpvr_config_call(dev, CTRL_VIDEO_INPUT_VALUE,
 173                          dev->options.video_input+1);
 174
 175         hdpvr_set_audio(dev, dev->options.audio_input+1,
 176                        dev->options.audio_codec);
 177
 178         hdpvr_set_bitrate(dev);
 179         hdpvr_config_call(dev, CTRL_BITRATE_MODE_VALUE,
 180                          dev->options.bitrate_mode);
 181         hdpvr_config_call(dev, CTRL_GOP_MODE_VALUE, dev->options.gop_mode);
 182
 183         hdpvr_config_call(dev, CTRL_BRIGHTNESS, dev->options.brightness);
 184         hdpvr_config_call(dev, CTRL_CONTRAST,   dev->options.contrast);
 185         hdpvr_config_call(dev, CTRL_HUE,        dev->options.hue);
 186         hdpvr_config_call(dev, CTRL_SATURATION, dev->options.saturation);
 187         hdpvr_config_call(dev, CTRL_SHARPNESS,  dev->options.sharpness);
 188
 189         return 0;
 190 }