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 } 191