drivers/media/pci/ivtv/ivtv-gpio.c

   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 }