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 27int 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 msleep(10); 33 34 mutex_lock(&dev->usbc_mutex); 35 dev->usbc_buf[0] = valbuf; 36 ret = usb_control_msg(dev->udev, 37 usb_sndctrlpipe(dev->udev, 0), 38 snd_request, 0x00 | request_type, 39 value, CTRL_DEFAULT_INDEX, 40 dev->usbc_buf, 1, 10000); 41 42 mutex_unlock(&dev->usbc_mutex); 43 v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev, 44 "config call request for value 0x%x returned %d\n", value, 45 ret); 46 47 return ret < 0 ? ret : 0; 48} 49 50struct hdpvr_video_info *get_video_info(struct hdpvr_device *dev) 51{ 52 struct hdpvr_video_info *vidinf = NULL; 53#ifdef HDPVR_DEBUG 54 char print_buf[15]; 55#endif 56 int ret; 57 58 vidinf = kzalloc(sizeof(struct hdpvr_video_info), GFP_KERNEL); 59 if (!vidinf) { 60 v4l2_err(&dev->v4l2_dev, "out of memory\n"); 61 goto err; 62 } 63 64 mutex_lock(&dev->usbc_mutex); 65 ret = usb_control_msg(dev->udev, 66 usb_rcvctrlpipe(dev->udev, 0), 67 0x81, 0x80 | 0x38, 68 0x1400, 0x0003, 69 dev->usbc_buf, 5, 70 1000); 71 if (ret == 5) { 72 vidinf->width = dev->usbc_buf[1] << 8 | dev->usbc_buf[0]; 73 vidinf->height = dev->usbc_buf[3] << 8 | dev->usbc_buf[2]; 74 vidinf->fps = dev->usbc_buf[4]; 75 } 76 77#ifdef HDPVR_DEBUG 78 if (hdpvr_debug & MSG_INFO) { 79 hex_dump_to_buffer(dev->usbc_buf, 5, 16, 1, print_buf, 80 sizeof(print_buf), 0); 81 v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev, 82 "get video info returned: %d, %s\n", ret, print_buf); 83 } 84#endif 85 mutex_unlock(&dev->usbc_mutex); 86 87 if (!vidinf->width || !vidinf->height || !vidinf->fps) { 88 kfree(vidinf); 89 vidinf = NULL; 90 } 91err: 92 return vidinf; 93} 94 95int get_input_lines_info(struct hdpvr_device *dev) 96{ 97#ifdef HDPVR_DEBUG 98 char print_buf[9]; 99#endif 100 int ret, lines; 101 102 mutex_lock(&dev->usbc_mutex); 103 ret = usb_control_msg(dev->udev, 104 usb_rcvctrlpipe(dev->udev, 0), 105 0x81, 0x80 | 0x38, 106 0x1800, 0x0003, 107 dev->usbc_buf, 3, 108 1000); 109 110#ifdef HDPVR_DEBUG 111 if (hdpvr_debug & MSG_INFO) { 112 hex_dump_to_buffer(dev->usbc_buf, 3, 16, 1, print_buf, 113 sizeof(print_buf), 0); 114 v4l2_dbg(MSG_INFO, hdpvr_debug, &dev->v4l2_dev, 115 "get input lines info returned: %d, %s\n", ret, 116 print_buf); 117 } 118#endif 119 lines = dev->usbc_buf[1] << 8 | dev->usbc_buf[0]; 120 mutex_unlock(&dev->usbc_mutex); 121 return lines; 122} 123 124 125int hdpvr_set_bitrate(struct hdpvr_device *dev) 126{ 127 int ret; 128 129 mutex_lock(&dev->usbc_mutex); 130 memset(dev->usbc_buf, 0, 4); 131 dev->usbc_buf[0] = dev->options.bitrate; 132 dev->usbc_buf[2] = dev->options.peak_bitrate; 133 134 ret = usb_control_msg(dev->udev, 135 usb_sndctrlpipe(dev->udev, 0), 136 0x01, 0x38, CTRL_BITRATE_VALUE, 137 CTRL_DEFAULT_INDEX, dev->usbc_buf, 4, 1000); 138 mutex_unlock(&dev->usbc_mutex); 139 140 return ret; 141} 142 143int hdpvr_set_audio(struct hdpvr_device *dev, u8 input, 144 enum v4l2_mpeg_audio_encoding codec) 145{ 146 int ret = 0; 147 148 if (dev->flags & HDPVR_FLAG_AC3_CAP) { 149 mutex_lock(&dev->usbc_mutex); 150 memset(dev->usbc_buf, 0, 2); 151 dev->usbc_buf[0] = input; 152 if (codec == V4L2_MPEG_AUDIO_ENCODING_AAC) 153 dev->usbc_buf[1] = 0; 154 else if (codec == V4L2_MPEG_AUDIO_ENCODING_AC3) 155 dev->usbc_buf[1] = 1; 156 else { 157 mutex_unlock(&dev->usbc_mutex); 158 v4l2_err(&dev->v4l2_dev, "invalid audio codec %d\n", 159 codec); 160 ret = -EINVAL; 161 goto error; 162 } 163 164 ret = usb_control_msg(dev->udev, 165 usb_sndctrlpipe(dev->udev, 0), 166 0x01, 0x38, CTRL_AUDIO_INPUT_VALUE, 167 CTRL_DEFAULT_INDEX, dev->usbc_buf, 2, 168 1000); 169 mutex_unlock(&dev->usbc_mutex); 170 if (ret == 2) 171 ret = 0; 172 } else 173 ret = hdpvr_config_call(dev, CTRL_AUDIO_INPUT_VALUE, 174 dev->options.audio_input+1); 175error: 176 return ret; 177} 178 179int hdpvr_set_options(struct hdpvr_device *dev) 180{ 181 hdpvr_config_call(dev, CTRL_VIDEO_STD_TYPE, dev->options.video_std); 182 183 hdpvr_config_call(dev, CTRL_VIDEO_INPUT_VALUE, 184 dev->options.video_input+1); 185 186 hdpvr_set_audio(dev, dev->options.audio_input+1, 187 dev->options.audio_codec); 188 189 hdpvr_set_bitrate(dev); 190 hdpvr_config_call(dev, CTRL_BITRATE_MODE_VALUE, 191 dev->options.bitrate_mode); 192 hdpvr_config_call(dev, CTRL_GOP_MODE_VALUE, dev->options.gop_mode); 193 194 hdpvr_config_call(dev, CTRL_BRIGHTNESS, dev->options.brightness); 195 hdpvr_config_call(dev, CTRL_CONTRAST, dev->options.contrast); 196 hdpvr_config_call(dev, CTRL_HUE, dev->options.hue); 197 hdpvr_config_call(dev, CTRL_SATURATION, dev->options.saturation); 198 hdpvr_config_call(dev, CTRL_SHARPNESS, dev->options.sharpness); 199 200 return 0; 201} 202