1 /* 2 gpio functions. 3 Merging GPIO support into driver: 4 Copyright (C) 2004 Chris Kennedy <c@groovy.org> 5 Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl> 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, or 10 (at your option) any later version. 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 #include "ivtv-driver.h" 23 #include "ivtv-cards.h" 24 #include "ivtv-gpio.h" 25 #include "tuner-xc2028.h" 26 #include <media/tuner.h> 27 #include <media/v4l2-ctrls.h> 28 29 /* 30 * GPIO assignment of Yuan MPG600/MPG160 31 * 32 * bit 15 14 13 12 | 11 10 9 8 | 7 6 5 4 | 3 2 1 0 33 * OUTPUT IN1 IN0 AM3 AM2 AM1 AM0 34 * INPUT DM1 DM0 35 * 36 * IN* : Input selection 37 * IN1 IN0 38 * 1 1 N/A 39 * 1 0 Line 40 * 0 1 N/A 41 * 0 0 Tuner 42 * 43 * AM* : Audio Mode 44 * AM3 0: Normal 1: Mixed(Sub+Main channel) 45 * AM2 0: Subchannel 1: Main channel 46 * AM1 0: Stereo 1: Mono 47 * AM0 0: Normal 1: Mute 48 * 49 * DM* : Detected tuner audio Mode 50 * DM1 0: Stereo 1: Mono 51 * DM0 0: Multiplex 1: Normal 52 * 53 * GPIO Initial Settings 54 * MPG600 MPG160 55 * DIR 0x3080 0x7080 56 * OUTPUT 0x000C 0x400C 57 * 58 * Special thanks to Makoto Iguchi <iguchi@tahoo.org> and Mr. Anonymous 59 * for analyzing GPIO of MPG160. 60 * 61 ***************************************************************************** 62 * 63 * GPIO assignment of Avermedia M179 (per information direct from AVerMedia) 64 * 65 * bit 15 14 13 12 | 11 10 9 8 | 7 6 5 4 | 3 2 1 0 66 * OUTPUT IN0 AM0 IN1 AM1 AM2 IN2 BR0 BR1 67 * INPUT 68 * 69 * IN* : Input selection 70 * IN0 IN1 IN2 71 * * 1 * Mute 72 * 0 0 0 Line-In 73 * 1 0 0 TV Tuner Audio 74 * 0 0 1 FM Audio 75 * 1 0 1 Mute 76 * 77 * AM* : Audio Mode 78 * AM0 AM1 AM2 79 * 0 0 0 TV Tuner Audio: L_OUT=(L+R)/2, R_OUT=SAP 80 * 0 0 1 TV Tuner Audio: L_OUT=R_OUT=SAP (SAP) 81 * 0 1 0 TV Tuner Audio: L_OUT=L, R_OUT=R (stereo) 82 * 0 1 1 TV Tuner Audio: mute 83 * 1 * * TV Tuner Audio: L_OUT=R_OUT=(L+R)/2 (mono) 84 * 85 * BR* : Audio Sample Rate (BR stands for bitrate for some reason) 86 * BR0 BR1 87 * 0 0 32 kHz 88 * 0 1 44.1 kHz 89 * 1 0 48 kHz 90 * 91 * DM* : Detected tuner audio Mode 92 * Unknown currently 93 * 94 * Special thanks to AVerMedia Technologies, Inc. and Jiun-Kuei Jung at 95 * AVerMedia for providing the GPIO information used to add support 96 * for the M179 cards. 97 */ 98 99 /********************* GPIO stuffs *********************/ 100 101 /* GPIO registers */ 102 #define IVTV_REG_GPIO_IN 0x9008 103 #define IVTV_REG_GPIO_OUT 0x900c 104 #define IVTV_REG_GPIO_DIR 0x9020 105 106 void ivtv_reset_ir_gpio(struct ivtv *itv) 107 { 108 int curdir, curout; 109 110 if (itv->card->type != IVTV_CARD_PVR_150) 111 return; 112 IVTV_DEBUG_INFO("Resetting PVR150 IR\n"); 113 curout = read_reg(IVTV_REG_GPIO_OUT); 114 curdir = read_reg(IVTV_REG_GPIO_DIR); 115 curdir |= 0x80; 116 write_reg(curdir, IVTV_REG_GPIO_DIR); 117 curout = (curout & ~0xF) | 1; 118 write_reg(curout, IVTV_REG_GPIO_OUT); 119 /* We could use something else for smaller time */ 120 schedule_timeout_interruptible(msecs_to_jiffies(1)); 121 curout |= 2; 122 write_reg(curout, IVTV_REG_GPIO_OUT); 123 curdir &= ~0x80; 124 write_reg(curdir, IVTV_REG_GPIO_DIR); 125 } 126 127 /* Xceive tuner reset function */ 128 int ivtv_reset_tuner_gpio(void *dev, int component, int cmd, int value) 129 { 130 struct i2c_algo_bit_data *algo = dev; 131 struct ivtv *itv = algo->data; 132 u32 curout; 133 134 if (cmd != XC2028_TUNER_RESET) 135 return 0; 136 IVTV_DEBUG_INFO("Resetting tuner\n"); 137 curout = read_reg(IVTV_REG_GPIO_OUT); 138 curout &= ~(1 << itv->card->xceive_pin); 139 write_reg(curout, IVTV_REG_GPIO_OUT); 140 schedule_timeout_interruptible(msecs_to_jiffies(1)); 141 142 curout |= 1 << itv->card->xceive_pin; 143 write_reg(curout, IVTV_REG_GPIO_OUT); 144 schedule_timeout_interruptible(msecs_to_jiffies(1)); 145 return 0; 146 } 147 148 static inline struct ivtv *sd_to_ivtv(struct v4l2_subdev *sd) 149 { 150 return container_of(sd, struct ivtv, sd_gpio); 151 } 152 153 static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl) 154 { 155 return &container_of(ctrl->handler, struct ivtv, hdl_gpio)->sd_gpio; 156 } 157 158 static int subdev_s_clock_freq(struct v4l2_subdev *sd, u32 freq) 159 { 160 struct ivtv *itv = sd_to_ivtv(sd); 161 u16 mask, data; 162 163 mask = itv->card->gpio_audio_freq.mask; 164 switch (freq) { 165 case 32000: 166 data = itv->card->gpio_audio_freq.f32000; 167 break; 168 case 44100: 169 data = itv->card->gpio_audio_freq.f44100; 170 break; 171 case 48000: 172 default: 173 data = itv->card->gpio_audio_freq.f48000; 174 break; 175 } 176 if (mask) 177 write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | (data & mask), IVTV_REG_GPIO_OUT); 178 return 0; 179 } 180 181 static int subdev_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt) 182 { 183 struct ivtv *itv = sd_to_ivtv(sd); 184 u16 mask; 185 186 mask = itv->card->gpio_audio_detect.mask; 187 if (mask == 0 || (read_reg(IVTV_REG_GPIO_IN) & mask)) 188 vt->rxsubchans = V4L2_TUNER_SUB_STEREO | 189 V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2; 190 else 191 vt->rxsubchans = V4L2_TUNER_SUB_MONO; 192 return 0; 193 } 194 195 static int subdev_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt) 196 { 197 struct ivtv *itv = sd_to_ivtv(sd); 198 u16 mask, data; 199 200 mask = itv->card->gpio_audio_mode.mask; 201 switch (vt->audmode) { 202 case V4L2_TUNER_MODE_LANG1: 203 data = itv->card->gpio_audio_mode.lang1; 204 break; 205 case V4L2_TUNER_MODE_LANG2: 206 data = itv->card->gpio_audio_mode.lang2; 207 break; 208 case V4L2_TUNER_MODE_MONO: 209 data = itv->card->gpio_audio_mode.mono; 210 break; 211 case V4L2_TUNER_MODE_STEREO: 212 case V4L2_TUNER_MODE_LANG1_LANG2: 213 default: 214 data = itv->card->gpio_audio_mode.stereo; 215 break; 216 } 217 if (mask) 218 write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | (data & mask), IVTV_REG_GPIO_OUT); 219 return 0; 220 } 221 222 static int subdev_s_radio(struct v4l2_subdev *sd) 223 { 224 struct ivtv *itv = sd_to_ivtv(sd); 225 u16 mask, data; 226 227 mask = itv->card->gpio_audio_input.mask; 228 data = itv->card->gpio_audio_input.radio; 229 if (mask) 230 write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | (data & mask), IVTV_REG_GPIO_OUT); 231 return 0; 232 } 233 234 static int subdev_s_audio_routing(struct v4l2_subdev *sd, 235 u32 input, u32 output, u32 config) 236 { 237 struct ivtv *itv = sd_to_ivtv(sd); 238 u16 mask, data; 239 240 if (input > 2) 241 return -EINVAL; 242 mask = itv->card->gpio_audio_input.mask; 243 switch (input) { 244 case 0: 245 data = itv->card->gpio_audio_input.tuner; 246 break; 247 case 1: 248 data = itv->card->gpio_audio_input.linein; 249 break; 250 case 2: 251 default: 252 data = itv->card->gpio_audio_input.radio; 253 break; 254 } 255 if (mask) 256 write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | (data & mask), IVTV_REG_GPIO_OUT); 257 return 0; 258 } 259 260 static int subdev_s_ctrl(struct v4l2_ctrl *ctrl) 261 { 262 struct v4l2_subdev *sd = to_sd(ctrl); 263 struct ivtv *itv = sd_to_ivtv(sd); 264 u16 mask, data; 265 266 switch (ctrl->id) { 267 case V4L2_CID_AUDIO_MUTE: 268 mask = itv->card->gpio_audio_mute.mask; 269 data = ctrl->val ? itv->card->gpio_audio_mute.mute : 0; 270 if (mask) 271 write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | 272 (data & mask), IVTV_REG_GPIO_OUT); 273 return 0; 274 } 275 return -EINVAL; 276 } 277 278 279 static int subdev_log_status(struct v4l2_subdev *sd) 280 { 281 struct ivtv *itv = sd_to_ivtv(sd); 282 283 IVTV_INFO("GPIO status: DIR=0x%04x OUT=0x%04x IN=0x%04x\n", 284 read_reg(IVTV_REG_GPIO_DIR), read_reg(IVTV_REG_GPIO_OUT), 285 read_reg(IVTV_REG_GPIO_IN)); 286 v4l2_ctrl_handler_log_status(&itv->hdl_gpio, sd->name); 287 return 0; 288 } 289 290 static int subdev_s_video_routing(struct v4l2_subdev *sd, 291 u32 input, u32 output, u32 config) 292 { 293 struct ivtv *itv = sd_to_ivtv(sd); 294 u16 mask, data; 295 296 if (input > 2) /* 0:Tuner 1:Composite 2:S-Video */ 297 return -EINVAL; 298 mask = itv->card->gpio_video_input.mask; 299 if (input == 0) 300 data = itv->card->gpio_video_input.tuner; 301 else if (input == 1) 302 data = itv->card->gpio_video_input.composite; 303 else 304 data = itv->card->gpio_video_input.svideo; 305 if (mask) 306 write_reg((read_reg(IVTV_REG_GPIO_OUT) & ~mask) | (data & mask), IVTV_REG_GPIO_OUT); 307 return 0; 308 } 309 310 static const struct v4l2_ctrl_ops gpio_ctrl_ops = { 311 .s_ctrl = subdev_s_ctrl, 312 }; 313 314 static const struct v4l2_subdev_core_ops subdev_core_ops = { 315 .log_status = subdev_log_status, 316 }; 317 318 static const struct v4l2_subdev_tuner_ops subdev_tuner_ops = { 319 .s_radio = subdev_s_radio, 320 .g_tuner = subdev_g_tuner, 321 .s_tuner = subdev_s_tuner, 322 }; 323 324 static const struct v4l2_subdev_audio_ops subdev_audio_ops = { 325 .s_clock_freq = subdev_s_clock_freq, 326 .s_routing = subdev_s_audio_routing, 327 }; 328 329 static const struct v4l2_subdev_video_ops subdev_video_ops = { 330 .s_routing = subdev_s_video_routing, 331 }; 332 333 static const struct v4l2_subdev_ops subdev_ops = { 334 .core = &subdev_core_ops, 335 .tuner = &subdev_tuner_ops, 336 .audio = &subdev_audio_ops, 337 .video = &subdev_video_ops, 338 }; 339 340 int ivtv_gpio_init(struct ivtv *itv) 341 { 342 u16 pin = 0; 343 344 if (itv->card->xceive_pin) 345 pin = 1 << itv->card->xceive_pin; 346 347 if ((itv->card->gpio_init.direction | pin) == 0) 348 return 0; 349 350 IVTV_DEBUG_INFO("GPIO initial dir: %08x out: %08x\n", 351 read_reg(IVTV_REG_GPIO_DIR), read_reg(IVTV_REG_GPIO_OUT)); 352 353 /* init output data then direction */ 354 write_reg(itv->card->gpio_init.initial_value | pin, IVTV_REG_GPIO_OUT); 355 write_reg(itv->card->gpio_init.direction | pin, IVTV_REG_GPIO_DIR); 356 v4l2_subdev_init(&itv->sd_gpio, &subdev_ops); 357 snprintf(itv->sd_gpio.name, sizeof(itv->sd_gpio.name), "%s-gpio", itv->v4l2_dev.name); 358 itv->sd_gpio.grp_id = IVTV_HW_GPIO; 359 v4l2_ctrl_handler_init(&itv->hdl_gpio, 1); 360 v4l2_ctrl_new_std(&itv->hdl_gpio, &gpio_ctrl_ops, 361 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0); 362 if (itv->hdl_gpio.error) 363 return itv->hdl_gpio.error; 364 itv->sd_gpio.ctrl_handler = &itv->hdl_gpio; 365 v4l2_ctrl_handler_setup(&itv->hdl_gpio); 366 return v4l2_device_register_subdev(&itv->v4l2_dev, &itv->sd_gpio); 367 } 368