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