drivers/media/video/saa7164/saa7164-api.c

   1 /*
   2  *  Driver for the NXP SAA7164 PCIe bridge
   3  *
   4  *  Copyright (c) 2010 Steven Toth <stoth@kernellabs.com>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *
  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., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <linux/wait.h>
  23 #include <linux/slab.h>
  24
  25 #include "saa7164.h"
  26
  27 int saa7164_api_get_load_info(struct saa7164_dev *dev, struct tmFwInfoStruct *i)
  28 {
  29         int ret;
  30
  31         if (!(saa_debug & DBGLVL_CPU))
  32                 return 0;
  33
  34         dprintk(DBGLVL_API, "%s()\n", __func__);
  35
  36         i->deviceinst = 0;
  37         i->devicespec = 0;
  38         i->mode = 0;
  39         i->status = 0;
  40
  41         ret = saa7164_cmd_send(dev, 0, GET_CUR,
  42                 GET_FW_STATUS_CONTROL, sizeof(struct tmFwInfoStruct), i);
  43         if (ret != SAA_OK)
  44                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
  45
  46         printk(KERN_INFO "saa7164[%d]-CPU: %d percent", dev->nr, i->CPULoad);
  47
  48         return ret;
  49 }
  50
  51 int saa7164_api_collect_debug(struct saa7164_dev *dev)
  52 {
  53         struct tmComResDebugGetData d;
  54         u8 more = 255;
  55         int ret;
  56
  57         dprintk(DBGLVL_API, "%s()\n", __func__);
  58
  59         while (more--) {
  60
  61                 memset(&d, 0, sizeof(d));
  62
  63                 ret = saa7164_cmd_send(dev, 0, GET_CUR,
  64                         GET_DEBUG_DATA_CONTROL, sizeof(d), &d);
  65                 if (ret != SAA_OK)
  66                         printk(KERN_ERR "%s() error, ret = 0x%x\n",
  67                                 __func__, ret);
  68
  69                 if (d.dwResult != SAA_OK)
  70                         break;
  71
  72                 printk(KERN_INFO "saa7164[%d]-FWMSG: %s", dev->nr,
  73                         d.ucDebugData);
  74         }
  75
  76         return 0;
  77 }
  78
  79 int saa7164_api_set_debug(struct saa7164_dev *dev, u8 level)
  80 {
  81         struct tmComResDebugSetLevel lvl;
  82         int ret;
  83
  84         dprintk(DBGLVL_API, "%s(level=%d)\n", __func__, level);
  85
  86         /* Retrieve current state */
  87         ret = saa7164_cmd_send(dev, 0, GET_CUR,
  88                 SET_DEBUG_LEVEL_CONTROL, sizeof(lvl), &lvl);
  89         if (ret != SAA_OK)
  90                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
  91
  92         dprintk(DBGLVL_API, "%s() Was %d\n", __func__, lvl.dwDebugLevel);
  93
  94         lvl.dwDebugLevel = level;
  95
  96         /* set new state */
  97         ret = saa7164_cmd_send(dev, 0, SET_CUR,
  98                 SET_DEBUG_LEVEL_CONTROL, sizeof(lvl), &lvl);
  99         if (ret != SAA_OK)
 100                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 101
 102         return ret;
 103 }
 104
 105 int saa7164_api_set_vbi_format(struct saa7164_port *port)
 106 {
 107         struct saa7164_dev *dev = port->dev;
 108         struct tmComResProbeCommit fmt, rsp;
 109         int ret;
 110
 111         dprintk(DBGLVL_API, "%s(nr=%d, unitid=0x%x)\n", __func__,
 112                 port->nr, port->hwcfg.unitid);
 113
 114         fmt.bmHint = 0;
 115         fmt.bFormatIndex = 1;
 116         fmt.bFrameIndex = 1;
 117
 118         /* Probe, see if it can support this format */
 119         ret = saa7164_cmd_send(port->dev, port->hwcfg.unitid,
 120                 SET_CUR, SAA_PROBE_CONTROL, sizeof(fmt), &fmt);
 121         if (ret != SAA_OK)
 122                 printk(KERN_ERR "%s() set error, ret = 0x%x\n", __func__, ret);
 123
 124         /* See of the format change was successful */
 125         ret = saa7164_cmd_send(port->dev, port->hwcfg.unitid,
 126                 GET_CUR, SAA_PROBE_CONTROL, sizeof(rsp), &rsp);
 127         if (ret != SAA_OK) {
 128                 printk(KERN_ERR "%s() get error, ret = 0x%x\n", __func__, ret);
 129         } else {
 130                 /* Compare requested vs received, should be same */
 131                 if (memcmp(&fmt, &rsp, sizeof(rsp)) == 0) {
 132                         dprintk(DBGLVL_API, "SET/PROBE Verified\n");
 133
 134                         /* Ask the device to select the negotiated format */
 135                         ret = saa7164_cmd_send(port->dev, port->hwcfg.unitid,
 136                                 SET_CUR, SAA_COMMIT_CONTROL, sizeof(fmt), &fmt);
 137                         if (ret != SAA_OK)
 138                                 printk(KERN_ERR "%s() commit error, ret = 0x%x\n",
 139                                         __func__, ret);
 140
 141                         ret = saa7164_cmd_send(port->dev, port->hwcfg.unitid,
 142                                 GET_CUR, SAA_COMMIT_CONTROL, sizeof(rsp), &rsp);
 143                         if (ret != SAA_OK)
 144                                 printk(KERN_ERR "%s() GET commit error, ret = 0x%x\n",
 145                                         __func__, ret);
 146
 147                         if (memcmp(&fmt, &rsp, sizeof(rsp)) != 0) {
 148                                 printk(KERN_ERR "%s() memcmp error, ret = 0x%x\n",
 149                                         __func__, ret);
 150                         } else
 151                                 dprintk(DBGLVL_API, "SET/COMMIT Verified\n");
 152
 153                         dprintk(DBGLVL_API, "rsp.bmHint = 0x%x\n", rsp.bmHint);
 154                         dprintk(DBGLVL_API, "rsp.bFormatIndex = 0x%x\n",
 155                                 rsp.bFormatIndex);
 156                         dprintk(DBGLVL_API, "rsp.bFrameIndex = 0x%x\n",
 157                                 rsp.bFrameIndex);
 158                 } else
 159                         printk(KERN_ERR "%s() compare failed\n", __func__);
 160         }
 161
 162         if (ret == SAA_OK)
 163                 dprintk(DBGLVL_API, "%s(nr=%d) Success\n", __func__, port->nr);
 164
 165         return ret;
 166 }
 167
 168 int saa7164_api_set_gop_size(struct saa7164_port *port)
 169 {
 170         struct saa7164_dev *dev = port->dev;
 171         struct tmComResEncVideoGopStructure gs;
 172         int ret;
 173
 174         dprintk(DBGLVL_ENC, "%s()\n", __func__);
 175
 176         gs.ucRefFrameDist = port->encoder_params.refdist;
 177         gs.ucGOPSize = port->encoder_params.gop_size;
 178         ret = saa7164_cmd_send(port->dev, port->hwcfg.sourceid, SET_CUR,
 179                 EU_VIDEO_GOP_STRUCTURE_CONTROL,
 180                 sizeof(gs), &gs);
 181         if (ret != SAA_OK)
 182                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 183
 184         return ret;
 185 }
 186
 187 int saa7164_api_set_encoder(struct saa7164_port *port)
 188 {
 189         struct saa7164_dev *dev = port->dev;
 190         struct tmComResEncVideoBitRate vb;
 191         struct tmComResEncAudioBitRate ab;
 192         int ret;
 193
 194         dprintk(DBGLVL_ENC, "%s() unitid=0x%x\n", __func__,
 195                 port->hwcfg.sourceid);
 196
 197         if (port->encoder_params.stream_type == V4L2_MPEG_STREAM_TYPE_MPEG2_PS)
 198                 port->encoder_profile = EU_PROFILE_PS_DVD;
 199         else
 200                 port->encoder_profile = EU_PROFILE_TS_HQ;
 201
 202         ret = saa7164_cmd_send(port->dev, port->hwcfg.sourceid, SET_CUR,
 203                 EU_PROFILE_CONTROL, sizeof(u8), &port->encoder_profile);
 204         if (ret != SAA_OK)
 205                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 206
 207         /* Resolution */
 208         ret = saa7164_cmd_send(port->dev, port->hwcfg.sourceid, SET_CUR,
 209                 EU_PROFILE_CONTROL, sizeof(u8), &port->encoder_profile);
 210         if (ret != SAA_OK)
 211                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 212
 213         /* Establish video bitrates */
 214         if (port->encoder_params.bitrate_mode ==
 215                 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
 216                 vb.ucVideoBitRateMode = EU_VIDEO_BIT_RATE_MODE_CONSTANT;
 217         else
 218                 vb.ucVideoBitRateMode = EU_VIDEO_BIT_RATE_MODE_VARIABLE_PEAK;
 219         vb.dwVideoBitRate = port->encoder_params.bitrate;
 220         vb.dwVideoBitRatePeak = port->encoder_params.bitrate_peak;
 221         ret = saa7164_cmd_send(port->dev, port->hwcfg.sourceid, SET_CUR,
 222                 EU_VIDEO_BIT_RATE_CONTROL,
 223                 sizeof(struct tmComResEncVideoBitRate),
 224                 &vb);
 225         if (ret != SAA_OK)
 226                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 227
 228         /* Establish audio bitrates */
 229         ab.ucAudioBitRateMode = 0;
 230         ab.dwAudioBitRate = 384000;
 231         ab.dwAudioBitRatePeak = ab.dwAudioBitRate;
 232         ret = saa7164_cmd_send(port->dev, port->hwcfg.sourceid, SET_CUR,
 233                 EU_AUDIO_BIT_RATE_CONTROL,
 234                 sizeof(struct tmComResEncAudioBitRate),
 235                 &ab);
 236         if (ret != SAA_OK)
 237                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
 238                         ret);
 239
 240         saa7164_api_set_aspect_ratio(port);
 241         saa7164_api_set_gop_size(port);
 242
 243         return ret;
 244 }
 245
 246 int saa7164_api_get_encoder(struct saa7164_port *port)
 247 {
 248         struct saa7164_dev *dev = port->dev;
 249         struct tmComResEncVideoBitRate v;
 250         struct tmComResEncAudioBitRate a;
 251         struct tmComResEncVideoInputAspectRatio ar;
 252         int ret;
 253
 254         dprintk(DBGLVL_ENC, "%s() unitid=0x%x\n", __func__,
 255                 port->hwcfg.sourceid);
 256
 257         port->encoder_profile = 0;
 258         port->video_format = 0;
 259         port->video_resolution = 0;
 260         port->audio_format = 0;
 261
 262         ret = saa7164_cmd_send(port->dev, port->hwcfg.sourceid, GET_CUR,
 263                 EU_PROFILE_CONTROL, sizeof(u8), &port->encoder_profile);
 264         if (ret != SAA_OK)
 265                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 266
 267         ret = saa7164_cmd_send(port->dev, port->hwcfg.sourceid, GET_CUR,
 268                 EU_VIDEO_RESOLUTION_CONTROL, sizeof(u8),
 269                 &port->video_resolution);
 270         if (ret != SAA_OK)
 271                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 272
 273         ret = saa7164_cmd_send(port->dev, port->hwcfg.sourceid, GET_CUR,
 274                 EU_VIDEO_FORMAT_CONTROL, sizeof(u8), &port->video_format);
 275         if (ret != SAA_OK)
 276                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 277
 278         ret = saa7164_cmd_send(port->dev, port->hwcfg.sourceid, GET_CUR,
 279                 EU_VIDEO_BIT_RATE_CONTROL, sizeof(v), &v);
 280         if (ret != SAA_OK)
 281                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 282
 283         ret = saa7164_cmd_send(port->dev, port->hwcfg.sourceid, GET_CUR,
 284                 EU_AUDIO_FORMAT_CONTROL, sizeof(u8), &port->audio_format);
 285         if (ret != SAA_OK)
 286                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 287
 288         ret = saa7164_cmd_send(port->dev, port->hwcfg.sourceid, GET_CUR,
 289                 EU_AUDIO_BIT_RATE_CONTROL, sizeof(a), &a);
 290         if (ret != SAA_OK)
 291                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 292
 293         /* Aspect Ratio */
 294         ar.width = 0;
 295         ar.height = 0;
 296         ret = saa7164_cmd_send(port->dev, port->hwcfg.sourceid, GET_CUR,
 297                 EU_VIDEO_INPUT_ASPECT_CONTROL,
 298                 sizeof(struct tmComResEncVideoInputAspectRatio), &ar);
 299         if (ret != SAA_OK)
 300                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 301
 302         dprintk(DBGLVL_ENC, "encoder_profile = %d\n", port->encoder_profile);
 303         dprintk(DBGLVL_ENC, "video_format    = %d\n", port->video_format);
 304         dprintk(DBGLVL_ENC, "audio_format    = %d\n", port->audio_format);
 305         dprintk(DBGLVL_ENC, "video_resolution= %d\n", port->video_resolution);
 306         dprintk(DBGLVL_ENC, "v.ucVideoBitRateMode = %d\n",
 307                 v.ucVideoBitRateMode);
 308         dprintk(DBGLVL_ENC, "v.dwVideoBitRate     = %d\n",
 309                 v.dwVideoBitRate);
 310         dprintk(DBGLVL_ENC, "v.dwVideoBitRatePeak = %d\n",
 311                 v.dwVideoBitRatePeak);
 312         dprintk(DBGLVL_ENC, "a.ucVideoBitRateMode = %d\n",
 313                 a.ucAudioBitRateMode);
 314         dprintk(DBGLVL_ENC, "a.dwVideoBitRate     = %d\n",
 315                 a.dwAudioBitRate);
 316         dprintk(DBGLVL_ENC, "a.dwVideoBitRatePeak = %d\n",
 317                 a.dwAudioBitRatePeak);
 318         dprintk(DBGLVL_ENC, "aspect.width / height = %d:%d\n",
 319                 ar.width, ar.height);
 320
 321         return ret;
 322 }
 323
 324 int saa7164_api_set_aspect_ratio(struct saa7164_port *port)
 325 {
 326         struct saa7164_dev *dev = port->dev;
 327         struct tmComResEncVideoInputAspectRatio ar;
 328         int ret;
 329
 330         dprintk(DBGLVL_ENC, "%s(%d)\n", __func__,
 331                 port->encoder_params.ctl_aspect);
 332
 333         switch (port->encoder_params.ctl_aspect) {
 334         case V4L2_MPEG_VIDEO_ASPECT_1x1:
 335                 ar.width = 1;
 336                 ar.height = 1;
 337                 break;
 338         case V4L2_MPEG_VIDEO_ASPECT_4x3:
 339                 ar.width = 4;
 340                 ar.height = 3;
 341                 break;
 342         case V4L2_MPEG_VIDEO_ASPECT_16x9:
 343                 ar.width = 16;
 344                 ar.height = 9;
 345                 break;
 346         case V4L2_MPEG_VIDEO_ASPECT_221x100:
 347                 ar.width = 221;
 348                 ar.height = 100;
 349                 break;
 350         default:
 351                 BUG();
 352         }
 353
 354         dprintk(DBGLVL_ENC, "%s(%d) now %d:%d\n", __func__,
 355                 port->encoder_params.ctl_aspect,
 356                 ar.width, ar.height);
 357
 358         /* Aspect Ratio */
 359         ret = saa7164_cmd_send(port->dev, port->hwcfg.sourceid, SET_CUR,
 360                 EU_VIDEO_INPUT_ASPECT_CONTROL,
 361                 sizeof(struct tmComResEncVideoInputAspectRatio), &ar);
 362         if (ret != SAA_OK)
 363                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 364
 365         return ret;
 366 }
 367
 368 int saa7164_api_set_usercontrol(struct saa7164_port *port, u8 ctl)
 369 {
 370         struct saa7164_dev *dev = port->dev;
 371         int ret;
 372         u16 val;
 373
 374         if (ctl == PU_BRIGHTNESS_CONTROL)
 375                 val = port->ctl_brightness;
 376         else
 377         if (ctl == PU_CONTRAST_CONTROL)
 378                 val = port->ctl_contrast;
 379         else
 380         if (ctl == PU_HUE_CONTROL)
 381                 val = port->ctl_hue;
 382         else
 383         if (ctl == PU_SATURATION_CONTROL)
 384                 val = port->ctl_saturation;
 385         else
 386         if (ctl == PU_SHARPNESS_CONTROL)
 387                 val = port->ctl_sharpness;
 388         else
 389                 return -EINVAL;
 390
 391         dprintk(DBGLVL_ENC, "%s() unitid=0x%x ctl=%d, val=%d\n",
 392                 __func__, port->encunit.vsourceid, ctl, val);
 393
 394         ret = saa7164_cmd_send(port->dev, port->encunit.vsourceid, SET_CUR,
 395                 ctl, sizeof(u16), &val);
 396         if (ret != SAA_OK)
 397                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 398
 399         return ret;
 400 }
 401
 402 int saa7164_api_get_usercontrol(struct saa7164_port *port, u8 ctl)
 403 {
 404         struct saa7164_dev *dev = port->dev;
 405         int ret;
 406         u16 val;
 407
 408         ret = saa7164_cmd_send(port->dev, port->encunit.vsourceid, GET_CUR,
 409                 ctl, sizeof(u16), &val);
 410         if (ret != SAA_OK) {
 411                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 412                 return ret;
 413         }
 414
 415         dprintk(DBGLVL_ENC, "%s() ctl=%d, val=%d\n",
 416                 __func__, ctl, val);
 417
 418         if (ctl == PU_BRIGHTNESS_CONTROL)
 419                 port->ctl_brightness = val;
 420         else
 421         if (ctl == PU_CONTRAST_CONTROL)
 422                 port->ctl_contrast = val;
 423         else
 424         if (ctl == PU_HUE_CONTROL)
 425                 port->ctl_hue = val;
 426         else
 427         if (ctl == PU_SATURATION_CONTROL)
 428                 port->ctl_saturation = val;
 429         else
 430         if (ctl == PU_SHARPNESS_CONTROL)
 431                 port->ctl_sharpness = val;
 432
 433         return ret;
 434 }
 435
 436 int saa7164_api_set_videomux(struct saa7164_port *port)
 437 {
 438         struct saa7164_dev *dev = port->dev;
 439         u8 inputs[] = { 1, 2, 2, 2, 5, 5, 5 };
 440         int ret;
 441
 442         dprintk(DBGLVL_ENC, "%s() v_mux=%d a_mux=%d\n",
 443                 __func__, port->mux_input, inputs[port->mux_input - 1]);
 444
 445         /* Audio Mute */
 446         ret = saa7164_api_audio_mute(port, 1);
 447         if (ret != SAA_OK)
 448                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 449
 450         /* Video Mux */
 451         ret = saa7164_cmd_send(port->dev, port->vidproc.sourceid, SET_CUR,
 452                 SU_INPUT_SELECT_CONTROL, sizeof(u8), &port->mux_input);
 453         if (ret != SAA_OK)
 454                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 455
 456         /* Audio Mux */
 457         ret = saa7164_cmd_send(port->dev, port->audfeat.sourceid, SET_CUR,
 458                 SU_INPUT_SELECT_CONTROL, sizeof(u8),
 459                 &inputs[port->mux_input - 1]);
 460         if (ret != SAA_OK)
 461                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 462
 463         /* Audio UnMute */
 464         ret = saa7164_api_audio_mute(port, 0);
 465         if (ret != SAA_OK)
 466                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 467
 468         return ret;
 469 }
 470
 471 int saa7164_api_audio_mute(struct saa7164_port *port, int mute)
 472 {
 473         struct saa7164_dev *dev = port->dev;
 474         u8 v = mute;
 475         int ret;
 476
 477         dprintk(DBGLVL_API, "%s(%d)\n", __func__, mute);
 478
 479         ret = saa7164_cmd_send(port->dev, port->audfeat.unitid, SET_CUR,
 480                 MUTE_CONTROL, sizeof(u8), &v);
 481         if (ret != SAA_OK)
 482                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 483
 484         return ret;
 485 }
 486
 487 /* 0 = silence, 0xff = full */
 488 int saa7164_api_set_audio_volume(struct saa7164_port *port, s8 level)
 489 {
 490         struct saa7164_dev *dev = port->dev;
 491         s16 v, min, max;
 492         int ret;
 493
 494         dprintk(DBGLVL_API, "%s(%d)\n", __func__, level);
 495
 496         /* Obtain the min/max ranges */
 497         ret = saa7164_cmd_send(port->dev, port->audfeat.unitid, GET_MIN,
 498                 VOLUME_CONTROL, sizeof(u16), &min);
 499         if (ret != SAA_OK)
 500                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 501
 502         ret = saa7164_cmd_send(port->dev, port->audfeat.unitid, GET_MAX,
 503                 VOLUME_CONTROL, sizeof(u16), &max);
 504         if (ret != SAA_OK)
 505                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 506
 507         ret = saa7164_cmd_send(port->dev, port->audfeat.unitid, GET_CUR,
 508                 (0x01 << 8) | VOLUME_CONTROL, sizeof(u16), &v);
 509         if (ret != SAA_OK)
 510                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 511
 512         dprintk(DBGLVL_API, "%s(%d) min=%d max=%d cur=%d\n", __func__,
 513                 level, min, max, v);
 514
 515         v = level;
 516         if (v < min)
 517                 v = min;
 518         if (v > max)
 519                 v = max;
 520
 521         /* Left */
 522         ret = saa7164_cmd_send(port->dev, port->audfeat.unitid, SET_CUR,
 523                 (0x01 << 8) | VOLUME_CONTROL, sizeof(s16), &v);
 524         if (ret != SAA_OK)
 525                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 526
 527         /* Right */
 528         ret = saa7164_cmd_send(port->dev, port->audfeat.unitid, SET_CUR,
 529                 (0x02 << 8) | VOLUME_CONTROL, sizeof(s16), &v);
 530         if (ret != SAA_OK)
 531                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 532
 533         ret = saa7164_cmd_send(port->dev, port->audfeat.unitid, GET_CUR,
 534                 (0x01 << 8) | VOLUME_CONTROL, sizeof(u16), &v);
 535         if (ret != SAA_OK)
 536                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 537
 538         dprintk(DBGLVL_API, "%s(%d) min=%d max=%d cur=%d\n", __func__,
 539                 level, min, max, v);
 540
 541         return ret;
 542 }
 543
 544 int saa7164_api_set_audio_std(struct saa7164_port *port)
 545 {
 546         struct saa7164_dev *dev = port->dev;
 547         struct tmComResAudioDefaults lvl;
 548         struct tmComResTunerStandard tvaudio;
 549         int ret;
 550
 551         dprintk(DBGLVL_API, "%s()\n", __func__);
 552
 553         /* Establish default levels */
 554         lvl.ucDecoderLevel = TMHW_LEV_ADJ_DECLEV_DEFAULT;
 555         lvl.ucDecoderFM_Level = TMHW_LEV_ADJ_DECLEV_DEFAULT;
 556         lvl.ucMonoLevel = TMHW_LEV_ADJ_MONOLEV_DEFAULT;
 557         lvl.ucNICAM_Level = TMHW_LEV_ADJ_NICLEV_DEFAULT;
 558         lvl.ucSAP_Level = TMHW_LEV_ADJ_SAPLEV_DEFAULT;
 559         lvl.ucADC_Level = TMHW_LEV_ADJ_ADCLEV_DEFAULT;
 560         ret = saa7164_cmd_send(port->dev, port->audfeat.unitid, SET_CUR,
 561                 AUDIO_DEFAULT_CONTROL, sizeof(struct tmComResAudioDefaults),
 562                 &lvl);
 563         if (ret != SAA_OK)
 564                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 565
 566         /* Manually select the appropriate TV audio standard */
 567         if (port->encodernorm.id & V4L2_STD_NTSC) {
 568                 tvaudio.std = TU_STANDARD_NTSC_M;
 569                 tvaudio.country = 1;
 570         } else {
 571                 tvaudio.std = TU_STANDARD_PAL_I;
 572                 tvaudio.country = 44;
 573         }
 574
 575         ret = saa7164_cmd_send(port->dev, port->tunerunit.unitid, SET_CUR,
 576                 TU_STANDARD_CONTROL, sizeof(tvaudio), &tvaudio);
 577         if (ret != SAA_OK)
 578                 printk(KERN_ERR "%s() TU_STANDARD_CONTROL error, ret = 0x%x\n",
 579                         __func__, ret);
 580         return ret;
 581 }
 582
 583 int saa7164_api_set_audio_detection(struct saa7164_port *port, int autodetect)
 584 {
 585         struct saa7164_dev *dev = port->dev;
 586         struct tmComResTunerStandardAuto p;
 587         int ret;
 588
 589         dprintk(DBGLVL_API, "%s(%d)\n", __func__, autodetect);
 590
 591         /* Disable TV Audio autodetect if not already set (buggy) */
 592         if (autodetect)
 593                 p.mode = TU_STANDARD_AUTO;
 594         else
 595                 p.mode = TU_STANDARD_MANUAL;
 596         ret = saa7164_cmd_send(port->dev, port->tunerunit.unitid, SET_CUR,
 597                 TU_STANDARD_AUTO_CONTROL, sizeof(p), &p);
 598         if (ret != SAA_OK)
 599                 printk(KERN_ERR
 600                         "%s() TU_STANDARD_AUTO_CONTROL error, ret = 0x%x\n",
 601                         __func__, ret);
 602
 603         return ret;
 604 }
 605
 606 int saa7164_api_get_videomux(struct saa7164_port *port)
 607 {
 608         struct saa7164_dev *dev = port->dev;
 609         int ret;
 610
 611         ret = saa7164_cmd_send(port->dev, port->vidproc.sourceid, GET_CUR,
 612                 SU_INPUT_SELECT_CONTROL, sizeof(u8), &port->mux_input);
 613         if (ret != SAA_OK)
 614                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 615
 616         dprintk(DBGLVL_ENC, "%s() v_mux=%d\n",
 617                 __func__, port->mux_input);
 618
 619         return ret;
 620 }
 621
 622 int saa7164_api_set_dif(struct saa7164_port *port, u8 reg, u8 val)
 623 {
 624         struct saa7164_dev *dev = port->dev;
 625
 626         u16 len = 0;
 627         u8 buf[256];
 628         int ret;
 629         u8 mas;
 630
 631         dprintk(DBGLVL_API, "%s(nr=%d type=%d val=%x)\n", __func__,
 632                 port->nr, port->type, val);
 633
 634         if (port->nr == 0)
 635                 mas = 0xd0;
 636         else
 637                 mas = 0xe0;
 638
 639         memset(buf, 0, sizeof(buf));
 640
 641         buf[0x00] = 0x04;
 642         buf[0x01] = 0x00;
 643         buf[0x02] = 0x00;
 644         buf[0x03] = 0x00;
 645
 646         buf[0x04] = 0x04;
 647         buf[0x05] = 0x00;
 648         buf[0x06] = 0x00;
 649         buf[0x07] = 0x00;
 650
 651         buf[0x08] = reg;
 652         buf[0x09] = 0x26;
 653         buf[0x0a] = mas;
 654         buf[0x0b] = 0xb0;
 655
 656         buf[0x0c] = val;
 657         buf[0x0d] = 0x00;
 658         buf[0x0e] = 0x00;
 659         buf[0x0f] = 0x00;
 660
 661         ret = saa7164_cmd_send(dev, port->ifunit.unitid, GET_LEN,
 662                 EXU_REGISTER_ACCESS_CONTROL, sizeof(len), &len);
 663         if (ret != SAA_OK) {
 664                 printk(KERN_ERR "%s() error, ret(1) = 0x%x\n", __func__, ret);
 665                 return -EIO;
 666         }
 667
 668         ret = saa7164_cmd_send(dev, port->ifunit.unitid, SET_CUR,
 669                 EXU_REGISTER_ACCESS_CONTROL, len, &buf);
 670         if (ret != SAA_OK)
 671                 printk(KERN_ERR "%s() error, ret(2) = 0x%x\n", __func__, ret);
 672 #if 0
 673         saa7164_dumphex16(dev, buf, 16);
 674 #endif
 675         return ret == SAA_OK ? 0 : -EIO;
 676 }
 677
 678 /* Disable the IF block AGC controls */
 679 int saa7164_api_configure_dif(struct saa7164_port *port, u32 std)
 680 {
 681         struct saa7164_dev *dev = port->dev;
 682         int ret = 0;
 683         u8 agc_disable;
 684
 685         dprintk(DBGLVL_API, "%s(nr=%d, 0x%x)\n", __func__, port->nr, std);
 686
 687         if (std & V4L2_STD_NTSC) {
 688                 dprintk(DBGLVL_API, " NTSC\n");
 689                 saa7164_api_set_dif(port, 0x00, 0x01); /* Video Standard */
 690                 agc_disable = 0;
 691         } else if (std & V4L2_STD_PAL_I) {
 692                 dprintk(DBGLVL_API, " PAL-I\n");
 693                 saa7164_api_set_dif(port, 0x00, 0x08); /* Video Standard */
 694                 agc_disable = 0;
 695         } else if (std & V4L2_STD_PAL_M) {
 696                 dprintk(DBGLVL_API, " PAL-M\n");
 697                 saa7164_api_set_dif(port, 0x00, 0x01); /* Video Standard */
 698                 agc_disable = 0;
 699         } else if (std & V4L2_STD_PAL_N) {
 700                 dprintk(DBGLVL_API, " PAL-N\n");
 701                 saa7164_api_set_dif(port, 0x00, 0x01); /* Video Standard */
 702                 agc_disable = 0;
 703         } else if (std & V4L2_STD_PAL_Nc) {
 704                 dprintk(DBGLVL_API, " PAL-Nc\n");
 705                 saa7164_api_set_dif(port, 0x00, 0x01); /* Video Standard */
 706                 agc_disable = 0;
 707         } else if (std & V4L2_STD_PAL_B) {
 708                 dprintk(DBGLVL_API, " PAL-B\n");
 709                 saa7164_api_set_dif(port, 0x00, 0x02); /* Video Standard */
 710                 agc_disable = 0;
 711         } else if (std & V4L2_STD_PAL_DK) {
 712                 dprintk(DBGLVL_API, " PAL-DK\n");
 713                 saa7164_api_set_dif(port, 0x00, 0x10); /* Video Standard */
 714                 agc_disable = 0;
 715         } else if (std & V4L2_STD_SECAM_L) {
 716                 dprintk(DBGLVL_API, " SECAM-L\n");
 717                 saa7164_api_set_dif(port, 0x00, 0x20); /* Video Standard */
 718                 agc_disable = 0;
 719         } else {
 720                 /* Unknown standard, assume DTV */
 721                 dprintk(DBGLVL_API, " Unknown (assuming DTV)\n");
 722                 /* Undefinded Video Standard */
 723                 saa7164_api_set_dif(port, 0x00, 0x80);
 724                 agc_disable = 1;
 725         }
 726
 727         saa7164_api_set_dif(port, 0x48, 0xa0); /* AGC Functions 1 */
 728         saa7164_api_set_dif(port, 0xc0, agc_disable); /* AGC Output Disable */
 729         saa7164_api_set_dif(port, 0x7c, 0x04); /* CVBS EQ */
 730         saa7164_api_set_dif(port, 0x04, 0x01); /* Active */
 731         msleep(100);
 732         saa7164_api_set_dif(port, 0x04, 0x00); /* Active (again) */
 733         msleep(100);
 734
 735         return ret;
 736 }
 737
 738 /* Ensure the dif is in the correct state for the operating mode
 739  * (analog / dtv). We only configure the diff through the analog encoder
 740  * so when we're in digital mode we need to find the appropriate encoder
 741  * and use it to configure the DIF.
 742  */
 743 int saa7164_api_initialize_dif(struct saa7164_port *port)
 744 {
 745         struct saa7164_dev *dev = port->dev;
 746         struct saa7164_port *p = NULL;
 747         int ret = -EINVAL;
 748         u32 std = 0;
 749
 750         dprintk(DBGLVL_API, "%s(nr=%d type=%d)\n", __func__,
 751                 port->nr, port->type);
 752
 753         if (port->type == SAA7164_MPEG_ENCODER) {
 754                 /* Pick any analog standard to init the diff.
 755                  * we'll come back during encoder_init'
 756                  * and set the correct standard if requried.
 757                  */
 758                 std = V4L2_STD_NTSC;
 759         } else
 760         if (port->type == SAA7164_MPEG_DVB) {
 761                 if (port->nr == SAA7164_PORT_TS1)
 762                         p = &dev->ports[SAA7164_PORT_ENC1];
 763                 else
 764                         p = &dev->ports[SAA7164_PORT_ENC2];
 765         } else
 766         if (port->type == SAA7164_MPEG_VBI) {
 767                 std = V4L2_STD_NTSC;
 768                 if (port->nr == SAA7164_PORT_VBI1)
 769                         p = &dev->ports[SAA7164_PORT_ENC1];
 770                 else
 771                         p = &dev->ports[SAA7164_PORT_ENC2];
 772         } else
 773                 BUG();
 774
 775         if (p)
 776                 ret = saa7164_api_configure_dif(p, std);
 777
 778         return ret;
 779 }
 780
 781 int saa7164_api_transition_port(struct saa7164_port *port, u8 mode)
 782 {
 783         struct saa7164_dev *dev = port->dev;
 784
 785         int ret;
 786
 787         dprintk(DBGLVL_API, "%s(nr=%d unitid=0x%x,%d)\n",
 788                 __func__, port->nr, port->hwcfg.unitid, mode);
 789
 790         ret = saa7164_cmd_send(port->dev, port->hwcfg.unitid, SET_CUR,
 791                 SAA_STATE_CONTROL, sizeof(mode), &mode);
 792         if (ret != SAA_OK)
 793                 printk(KERN_ERR "%s(portnr %d unitid 0x%x) error, ret = 0x%x\n",
 794                         __func__, port->nr, port->hwcfg.unitid, ret);
 795
 796         return ret;
 797 }
 798
 799 int saa7164_api_get_fw_version(struct saa7164_dev *dev, u32 *version)
 800 {
 801         int ret;
 802
 803         ret = saa7164_cmd_send(dev, 0, GET_CUR,
 804                 GET_FW_VERSION_CONTROL, sizeof(u32), version);
 805         if (ret != SAA_OK)
 806                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
 807
 808         return ret;
 809 }
 810
 811 int saa7164_api_read_eeprom(struct saa7164_dev *dev, u8 *buf, int buflen)
 812 {
 813         u8 reg[] = { 0x0f, 0x00 };
 814
 815         if (buflen < 128)
 816                 return -ENOMEM;
 817
 818         /* Assumption: Hauppauge eeprom is at 0xa0 on on bus 0 */
 819         /* TODO: Pull the details from the boards struct */
 820         return saa7164_api_i2c_read(&dev->i2c_bus[0], 0xa0 >> 1, sizeof(reg),
 821                 &reg[0], 128, buf);
 822 }
 823
 824 int saa7164_api_configure_port_vbi(struct saa7164_dev *dev,
 825         struct saa7164_port *port)
 826 {
 827         struct tmComResVBIFormatDescrHeader *fmt = &port->vbi_fmt_ntsc;
 828
 829         dprintk(DBGLVL_API, "    bFormatIndex  = 0x%x\n", fmt->bFormatIndex);
 830         dprintk(DBGLVL_API, "    VideoStandard = 0x%x\n", fmt->VideoStandard);
 831         dprintk(DBGLVL_API, "    StartLine     = %d\n", fmt->StartLine);
 832         dprintk(DBGLVL_API, "    EndLine       = %d\n", fmt->EndLine);
 833         dprintk(DBGLVL_API, "    FieldRate     = %d\n", fmt->FieldRate);
 834         dprintk(DBGLVL_API, "    bNumLines     = %d\n", fmt->bNumLines);
 835
 836         /* Cache the hardware configuration in the port */
 837
 838         port->bufcounter = port->hwcfg.BARLocation;
 839         port->pitch = port->hwcfg.BARLocation + (2 * sizeof(u32));
 840         port->bufsize = port->hwcfg.BARLocation + (3 * sizeof(u32));
 841         port->bufoffset = port->hwcfg.BARLocation + (4 * sizeof(u32));
 842         port->bufptr32l = port->hwcfg.BARLocation +
 843                 (4 * sizeof(u32)) +
 844                 (sizeof(u32) * port->hwcfg.buffercount) + sizeof(u32);
 845         port->bufptr32h = port->hwcfg.BARLocation +
 846                 (4 * sizeof(u32)) +
 847                 (sizeof(u32) * port->hwcfg.buffercount);
 848         port->bufptr64 = port->hwcfg.BARLocation +
 849                 (4 * sizeof(u32)) +
 850                 (sizeof(u32) * port->hwcfg.buffercount);
 851         dprintk(DBGLVL_API, "   = port->hwcfg.BARLocation = 0x%x\n",
 852                 port->hwcfg.BARLocation);
 853
 854         dprintk(DBGLVL_API, "   = VS_FORMAT_VBI (becomes dev->en[%d])\n",
 855                 port->nr);
 856
 857         return 0;
 858 }
 859
 860 int saa7164_api_configure_port_mpeg2ts(struct saa7164_dev *dev,
 861         struct saa7164_port *port,
 862         struct tmComResTSFormatDescrHeader *tsfmt)
 863 {
 864         dprintk(DBGLVL_API, "    bFormatIndex = 0x%x\n", tsfmt->bFormatIndex);
 865         dprintk(DBGLVL_API, "    bDataOffset  = 0x%x\n", tsfmt->bDataOffset);
 866         dprintk(DBGLVL_API, "    bPacketLength= 0x%x\n", tsfmt->bPacketLength);
 867         dprintk(DBGLVL_API, "    bStrideLength= 0x%x\n", tsfmt->bStrideLength);
 868         dprintk(DBGLVL_API, "    bguid        = (....)\n");
 869
 870         /* Cache the hardware configuration in the port */
 871
 872         port->bufcounter = port->hwcfg.BARLocation;
 873         port->pitch = port->hwcfg.BARLocation + (2 * sizeof(u32));
 874         port->bufsize = port->hwcfg.BARLocation + (3 * sizeof(u32));
 875         port->bufoffset = port->hwcfg.BARLocation + (4 * sizeof(u32));
 876         port->bufptr32l = port->hwcfg.BARLocation +
 877                 (4 * sizeof(u32)) +
 878                 (sizeof(u32) * port->hwcfg.buffercount) + sizeof(u32);
 879         port->bufptr32h = port->hwcfg.BARLocation +
 880                 (4 * sizeof(u32)) +
 881                 (sizeof(u32) * port->hwcfg.buffercount);
 882         port->bufptr64 = port->hwcfg.BARLocation +
 883                 (4 * sizeof(u32)) +
 884                 (sizeof(u32) * port->hwcfg.buffercount);
 885         dprintk(DBGLVL_API, "   = port->hwcfg.BARLocation = 0x%x\n",
 886                 port->hwcfg.BARLocation);
 887
 888         dprintk(DBGLVL_API, "   = VS_FORMAT_MPEGTS (becomes dev->ts[%d])\n",
 889                 port->nr);
 890
 891         return 0;
 892 }
 893
 894 int saa7164_api_configure_port_mpeg2ps(struct saa7164_dev *dev,
 895         struct saa7164_port *port,
 896         struct tmComResPSFormatDescrHeader *fmt)
 897 {
 898         dprintk(DBGLVL_API, "    bFormatIndex = 0x%x\n", fmt->bFormatIndex);
 899         dprintk(DBGLVL_API, "    wPacketLength= 0x%x\n", fmt->wPacketLength);
 900         dprintk(DBGLVL_API, "    wPackLength=   0x%x\n", fmt->wPackLength);
 901         dprintk(DBGLVL_API, "    bPackDataType= 0x%x\n", fmt->bPackDataType);
 902
 903         /* Cache the hardware configuration in the port */
 904         /* TODO: CHECK THIS in the port config */
 905         port->bufcounter = port->hwcfg.BARLocation;
 906         port->pitch = port->hwcfg.BARLocation + (2 * sizeof(u32));
 907         port->bufsize = port->hwcfg.BARLocation + (3 * sizeof(u32));
 908         port->bufoffset = port->hwcfg.BARLocation + (4 * sizeof(u32));
 909         port->bufptr32l = port->hwcfg.BARLocation +
 910                 (4 * sizeof(u32)) +
 911                 (sizeof(u32) * port->hwcfg.buffercount) + sizeof(u32);
 912         port->bufptr32h = port->hwcfg.BARLocation +
 913                 (4 * sizeof(u32)) +
 914                 (sizeof(u32) * port->hwcfg.buffercount);
 915         port->bufptr64 = port->hwcfg.BARLocation +
 916                 (4 * sizeof(u32)) +
 917                 (sizeof(u32) * port->hwcfg.buffercount);
 918         dprintk(DBGLVL_API, "   = port->hwcfg.BARLocation = 0x%x\n",
 919                 port->hwcfg.BARLocation);
 920
 921         dprintk(DBGLVL_API, "   = VS_FORMAT_MPEGPS (becomes dev->enc[%d])\n",
 922                 port->nr);
 923
 924         return 0;
 925 }
 926
 927 int saa7164_api_dump_subdevs(struct saa7164_dev *dev, u8 *buf, int len)
 928 {
 929         struct saa7164_port *tsport = NULL;
 930         struct saa7164_port *encport = NULL;
 931         struct saa7164_port *vbiport = NULL;
 932         u32 idx, next_offset;
 933         int i;
 934         struct tmComResDescrHeader *hdr, *t;
 935         struct tmComResExtDevDescrHeader *exthdr;
 936         struct tmComResPathDescrHeader *pathhdr;
 937         struct tmComResAntTermDescrHeader *anttermhdr;
 938         struct tmComResTunerDescrHeader *tunerunithdr;
 939         struct tmComResDMATermDescrHeader *vcoutputtermhdr;
 940         struct tmComResTSFormatDescrHeader *tsfmt;
 941         struct tmComResPSFormatDescrHeader *psfmt;
 942         struct tmComResSelDescrHeader *psel;
 943         struct tmComResProcDescrHeader *pdh;
 944         struct tmComResAFeatureDescrHeader *afd;
 945         struct tmComResEncoderDescrHeader *edh;
 946         struct tmComResVBIFormatDescrHeader *vbifmt;
 947         u32 currpath = 0;
 948
 949         dprintk(DBGLVL_API,
 950                 "%s(?,?,%d) sizeof(struct tmComResDescrHeader) = %d bytes\n",
 951                 __func__, len, (u32)sizeof(struct tmComResDescrHeader));
 952
 953         for (idx = 0; idx < (len - sizeof(struct tmComResDescrHeader));) {
 954
 955                 hdr = (struct tmComResDescrHeader *)(buf + idx);
 956
 957                 if (hdr->type != CS_INTERFACE)
 958                         return SAA_ERR_NOT_SUPPORTED;
 959
 960                 dprintk(DBGLVL_API, "@ 0x%x =\n", idx);
 961                 switch (hdr->subtype) {
 962                 case GENERAL_REQUEST:
 963                         dprintk(DBGLVL_API, " GENERAL_REQUEST\n");
 964                         break;
 965                 case VC_TUNER_PATH:
 966                         dprintk(DBGLVL_API, " VC_TUNER_PATH\n");
 967                         pathhdr = (struct tmComResPathDescrHeader *)(buf + idx);
 968                         dprintk(DBGLVL_API, "  pathid = 0x%x\n",
 969                                 pathhdr->pathid);
 970                         currpath = pathhdr->pathid;
 971                         break;
 972                 case VC_INPUT_TERMINAL:
 973                         dprintk(DBGLVL_API, " VC_INPUT_TERMINAL\n");
 974                         anttermhdr =
 975                                 (struct tmComResAntTermDescrHeader *)(buf + idx);
 976                         dprintk(DBGLVL_API, "  terminalid   = 0x%x\n",
 977                                 anttermhdr->terminalid);
 978                         dprintk(DBGLVL_API, "  terminaltype = 0x%x\n",
 979                                 anttermhdr->terminaltype);
 980                         switch (anttermhdr->terminaltype) {
 981                         case ITT_ANTENNA:
 982                                 dprintk(DBGLVL_API, "   = ITT_ANTENNA\n");
 983                                 break;
 984                         case LINE_CONNECTOR:
 985                                 dprintk(DBGLVL_API, "   = LINE_CONNECTOR\n");
 986                                 break;
 987                         case SPDIF_CONNECTOR:
 988                                 dprintk(DBGLVL_API, "   = SPDIF_CONNECTOR\n");
 989                                 break;
 990                         case COMPOSITE_CONNECTOR:
 991                                 dprintk(DBGLVL_API,
 992                                         "   = COMPOSITE_CONNECTOR\n");
 993                                 break;
 994                         case SVIDEO_CONNECTOR:
 995                                 dprintk(DBGLVL_API, "   = SVIDEO_CONNECTOR\n");
 996                                 break;
 997                         case COMPONENT_CONNECTOR:
 998                                 dprintk(DBGLVL_API,
 999                                         "   = COMPONENT_CONNECTOR\n");
1000                                 break;
1001                         case STANDARD_DMA:
1002                                 dprintk(DBGLVL_API, "   = STANDARD_DMA\n");
1003                                 break;
1004                         default:
1005                                 dprintk(DBGLVL_API, "   = undefined (0x%x)\n",
1006                                         anttermhdr->terminaltype);
1007                         }
1008                         dprintk(DBGLVL_API, "  assocterminal= 0x%x\n",
1009                                 anttermhdr->assocterminal);
1010                         dprintk(DBGLVL_API, "  iterminal    = 0x%x\n",
1011                                 anttermhdr->iterminal);
1012                         dprintk(DBGLVL_API, "  controlsize  = 0x%x\n",
1013                                 anttermhdr->controlsize);
1014                         break;
1015                 case VC_OUTPUT_TERMINAL:
1016                         dprintk(DBGLVL_API, " VC_OUTPUT_TERMINAL\n");
1017                         vcoutputtermhdr =
1018                                 (struct tmComResDMATermDescrHeader *)(buf + idx);
1019                         dprintk(DBGLVL_API, "  unitid = 0x%x\n",
1020                                 vcoutputtermhdr->unitid);
1021                         dprintk(DBGLVL_API, "  terminaltype = 0x%x\n",
1022                                 vcoutputtermhdr->terminaltype);
1023                         switch (vcoutputtermhdr->terminaltype) {
1024                         case ITT_ANTENNA:
1025                                 dprintk(DBGLVL_API, "   = ITT_ANTENNA\n");
1026                                 break;
1027                         case LINE_CONNECTOR:
1028                                 dprintk(DBGLVL_API, "   = LINE_CONNECTOR\n");
1029                                 break;
1030                         case SPDIF_CONNECTOR:
1031                                 dprintk(DBGLVL_API, "   = SPDIF_CONNECTOR\n");
1032                                 break;
1033                         case COMPOSITE_CONNECTOR:
1034                                 dprintk(DBGLVL_API,
1035                                         "   = COMPOSITE_CONNECTOR\n");
1036                                 break;
1037                         case SVIDEO_CONNECTOR:
1038                                 dprintk(DBGLVL_API, "   = SVIDEO_CONNECTOR\n");
1039                                 break;
1040                         case COMPONENT_CONNECTOR:
1041                                 dprintk(DBGLVL_API,
1042                                         "   = COMPONENT_CONNECTOR\n");
1043                                 break;
1044                         case STANDARD_DMA:
1045                                 dprintk(DBGLVL_API, "   = STANDARD_DMA\n");
1046                                 break;
1047                         default:
1048                                 dprintk(DBGLVL_API, "   = undefined (0x%x)\n",
1049                                         vcoutputtermhdr->terminaltype);
1050                         }
1051                         dprintk(DBGLVL_API, "  assocterminal= 0x%x\n",
1052                                 vcoutputtermhdr->assocterminal);
1053                         dprintk(DBGLVL_API, "  sourceid     = 0x%x\n",
1054                                 vcoutputtermhdr->sourceid);
1055                         dprintk(DBGLVL_API, "  iterminal    = 0x%x\n",
1056                                 vcoutputtermhdr->iterminal);
1057                         dprintk(DBGLVL_API, "  BARLocation  = 0x%x\n",
1058                                 vcoutputtermhdr->BARLocation);
1059                         dprintk(DBGLVL_API, "  flags        = 0x%x\n",
1060                                 vcoutputtermhdr->flags);
1061                         dprintk(DBGLVL_API, "  interruptid  = 0x%x\n",
1062                                 vcoutputtermhdr->interruptid);
1063                         dprintk(DBGLVL_API, "  buffercount  = 0x%x\n",
1064                                 vcoutputtermhdr->buffercount);
1065                         dprintk(DBGLVL_API, "  metadatasize = 0x%x\n",
1066                                 vcoutputtermhdr->metadatasize);
1067                         dprintk(DBGLVL_API, "  controlsize  = 0x%x\n",
1068                                 vcoutputtermhdr->controlsize);
1069                         dprintk(DBGLVL_API, "  numformats   = 0x%x\n",
1070                                 vcoutputtermhdr->numformats);
1071
1072                         t = (struct tmComResDescrHeader *)
1073                                 ((struct tmComResDMATermDescrHeader *)(buf + idx));
1074                         next_offset = idx + (vcoutputtermhdr->len);
1075                         for (i = 0; i < vcoutputtermhdr->numformats; i++) {
1076                                 t = (struct tmComResDescrHeader *)
1077                                         (buf + next_offset);
1078                                 switch (t->subtype) {
1079                                 case VS_FORMAT_MPEG2TS:
1080                                         tsfmt =
1081                                         (struct tmComResTSFormatDescrHeader *)t;
1082                                         if (currpath == 1)
1083                                                 tsport = &dev->ports[SAA7164_PORT_TS1];
1084                                         else
1085                                                 tsport = &dev->ports[SAA7164_PORT_TS2];
1086                                         memcpy(&tsport->hwcfg, vcoutputtermhdr,
1087                                                 sizeof(*vcoutputtermhdr));
1088                                         saa7164_api_configure_port_mpeg2ts(dev,
1089                                                 tsport, tsfmt);
1090                                         break;
1091                                 case VS_FORMAT_MPEG2PS:
1092                                         psfmt =
1093                                         (struct tmComResPSFormatDescrHeader *)t;
1094                                         if (currpath == 1)
1095                                                 encport = &dev->ports[SAA7164_PORT_ENC1];
1096                                         else
1097                                                 encport = &dev->ports[SAA7164_PORT_ENC2];
1098                                         memcpy(&encport->hwcfg, vcoutputtermhdr,
1099                                                 sizeof(*vcoutputtermhdr));
1100                                         saa7164_api_configure_port_mpeg2ps(dev,
1101                                                 encport, psfmt);
1102                                         break;
1103                                 case VS_FORMAT_VBI:
1104                                         vbifmt =
1105                                         (struct tmComResVBIFormatDescrHeader *)t;
1106                                         if (currpath == 1)
1107                                                 vbiport = &dev->ports[SAA7164_PORT_VBI1];
1108                                         else
1109                                                 vbiport = &dev->ports[SAA7164_PORT_VBI2];
1110                                         memcpy(&vbiport->hwcfg, vcoutputtermhdr,
1111                                                 sizeof(*vcoutputtermhdr));
1112                                         memcpy(&vbiport->vbi_fmt_ntsc, vbifmt,
1113                                                 sizeof(*vbifmt));
1114                                         saa7164_api_configure_port_vbi(dev,
1115                                                 vbiport);
1116                                         break;
1117                                 case VS_FORMAT_RDS:
1118                                         dprintk(DBGLVL_API,
1119                                                 "   = VS_FORMAT_RDS\n");
1120                                         break;
1121                                 case VS_FORMAT_UNCOMPRESSED:
1122                                         dprintk(DBGLVL_API,
1123                                         "   = VS_FORMAT_UNCOMPRESSED\n");
1124                                         break;
1125                                 case VS_FORMAT_TYPE:
1126                                         dprintk(DBGLVL_API,
1127                                                 "   = VS_FORMAT_TYPE\n");
1128                                         break;
1129                                 default:
1130                                         dprintk(DBGLVL_API,
1131                                                 "   = undefined (0x%x)\n",
1132                                                 t->subtype);
1133                                 }
1134                                 next_offset += t->len;
1135                         }
1136
1137                         break;
1138                 case TUNER_UNIT:
1139                         dprintk(DBGLVL_API, " TUNER_UNIT\n");
1140                         tunerunithdr =
1141                                 (struct tmComResTunerDescrHeader *)(buf + idx);
1142                         dprintk(DBGLVL_API, "  unitid = 0x%x\n",
1143                                 tunerunithdr->unitid);
1144                         dprintk(DBGLVL_API, "  sourceid = 0x%x\n",
1145                                 tunerunithdr->sourceid);
1146                         dprintk(DBGLVL_API, "  iunit = 0x%x\n",
1147                                 tunerunithdr->iunit);
1148                         dprintk(DBGLVL_API, "  tuningstandards = 0x%x\n",
1149                                 tunerunithdr->tuningstandards);
1150                         dprintk(DBGLVL_API, "  controlsize = 0x%x\n",
1151                                 tunerunithdr->controlsize);
1152                         dprintk(DBGLVL_API, "  controls = 0x%x\n",
1153                                 tunerunithdr->controls);
1154
1155                         if (tunerunithdr->unitid == tunerunithdr->iunit) {
1156                                 if (currpath == 1)
1157                                         encport = &dev->ports[SAA7164_PORT_ENC1];
1158                                 else
1159                                         encport = &dev->ports[SAA7164_PORT_ENC2];
1160                                 memcpy(&encport->tunerunit, tunerunithdr,
1161                                         sizeof(struct tmComResTunerDescrHeader));
1162                                 dprintk(DBGLVL_API,
1163                                         "  (becomes dev->enc[%d] tuner)\n",
1164                                         encport->nr);
1165                         }
1166                         break;
1167                 case VC_SELECTOR_UNIT:
1168                         psel = (struct tmComResSelDescrHeader *)(buf + idx);
1169                         dprintk(DBGLVL_API, " VC_SELECTOR_UNIT\n");
1170                         dprintk(DBGLVL_API, "  unitid = 0x%x\n",
1171                                 psel->unitid);
1172                         dprintk(DBGLVL_API, "  nrinpins = 0x%x\n",
1173                                 psel->nrinpins);
1174                         dprintk(DBGLVL_API, "  sourceid = 0x%x\n",
1175                                 psel->sourceid);
1176                         break;
1177                 case VC_PROCESSING_UNIT:
1178                         pdh = (struct tmComResProcDescrHeader *)(buf + idx);
1179                         dprintk(DBGLVL_API, " VC_PROCESSING_UNIT\n");
1180                         dprintk(DBGLVL_API, "  unitid = 0x%x\n",
1181                                 pdh->unitid);
1182                         dprintk(DBGLVL_API, "  sourceid = 0x%x\n",
1183                                 pdh->sourceid);
1184                         dprintk(DBGLVL_API, "  controlsize = 0x%x\n",
1185                                 pdh->controlsize);
1186                         if (pdh->controlsize == 0x04) {
1187                                 if (currpath == 1)
1188                                         encport = &dev->ports[SAA7164_PORT_ENC1];
1189                                 else
1190                                         encport = &dev->ports[SAA7164_PORT_ENC2];
1191                                 memcpy(&encport->vidproc, pdh,
1192                                         sizeof(struct tmComResProcDescrHeader));
1193                                 dprintk(DBGLVL_API, "  (becomes dev->enc[%d])\n",
1194                                         encport->nr);
1195                         }
1196                         break;
1197                 case FEATURE_UNIT:
1198                         afd = (struct tmComResAFeatureDescrHeader *)(buf + idx);
1199                         dprintk(DBGLVL_API, " FEATURE_UNIT\n");
1200                         dprintk(DBGLVL_API, "  unitid = 0x%x\n",
1201                                 afd->unitid);
1202                         dprintk(DBGLVL_API, "  sourceid = 0x%x\n",
1203                                 afd->sourceid);
1204                         dprintk(DBGLVL_API, "  controlsize = 0x%x\n",
1205                                 afd->controlsize);
1206                         if (currpath == 1)
1207                                 encport = &dev->ports[SAA7164_PORT_ENC1];
1208                         else
1209                                 encport = &dev->ports[SAA7164_PORT_ENC2];
1210                         memcpy(&encport->audfeat, afd,
1211                                 sizeof(struct tmComResAFeatureDescrHeader));
1212                         dprintk(DBGLVL_API, "  (becomes dev->enc[%d])\n",
1213                                 encport->nr);
1214                         break;
1215                 case ENCODER_UNIT:
1216                         edh = (struct tmComResEncoderDescrHeader *)(buf + idx);
1217                         dprintk(DBGLVL_API, " ENCODER_UNIT\n");
1218                         dprintk(DBGLVL_API, "  subtype = 0x%x\n", edh->subtype);
1219                         dprintk(DBGLVL_API, "  unitid = 0x%x\n", edh->unitid);
1220                         dprintk(DBGLVL_API, "  vsourceid = 0x%x\n",
1221                         edh->vsourceid);
1222                         dprintk(DBGLVL_API, "  asourceid = 0x%x\n",
1223                                 edh->asourceid);
1224                         dprintk(DBGLVL_API, "  iunit = 0x%x\n", edh->iunit);
1225                         if (edh->iunit == edh->unitid) {
1226                                 if (currpath == 1)
1227                                         encport = &dev->ports[SAA7164_PORT_ENC1];
1228                                 else
1229                                         encport = &dev->ports[SAA7164_PORT_ENC2];
1230                                 memcpy(&encport->encunit, edh,
1231                                         sizeof(struct tmComResEncoderDescrHeader));
1232                                 dprintk(DBGLVL_API,
1233                                         "  (becomes dev->enc[%d])\n",
1234                                         encport->nr);
1235                         }
1236                         break;
1237                 case EXTENSION_UNIT:
1238                         dprintk(DBGLVL_API, " EXTENSION_UNIT\n");
1239                         exthdr = (struct tmComResExtDevDescrHeader *)(buf + idx);
1240                         dprintk(DBGLVL_API, "  unitid = 0x%x\n",
1241                                 exthdr->unitid);
1242                         dprintk(DBGLVL_API, "  deviceid = 0x%x\n",
1243                                 exthdr->deviceid);
1244                         dprintk(DBGLVL_API, "  devicetype = 0x%x\n",
1245                                 exthdr->devicetype);
1246                         if (exthdr->devicetype & 0x1)
1247                                 dprintk(DBGLVL_API, "   = Decoder Device\n");
1248                         if (exthdr->devicetype & 0x2)
1249                                 dprintk(DBGLVL_API, "   = GPIO Source\n");
1250                         if (exthdr->devicetype & 0x4)
1251                                 dprintk(DBGLVL_API, "   = Video Decoder\n");
1252                         if (exthdr->devicetype & 0x8)
1253                                 dprintk(DBGLVL_API, "   = Audio Decoder\n");
1254                         if (exthdr->devicetype & 0x20)
1255                                 dprintk(DBGLVL_API, "   = Crossbar\n");
1256                         if (exthdr->devicetype & 0x40)
1257                                 dprintk(DBGLVL_API, "   = Tuner\n");
1258                         if (exthdr->devicetype & 0x80)
1259                                 dprintk(DBGLVL_API, "   = IF PLL\n");
1260                         if (exthdr->devicetype & 0x100)
1261                                 dprintk(DBGLVL_API, "   = Demodulator\n");
1262                         if (exthdr->devicetype & 0x200)
1263                                 dprintk(DBGLVL_API, "   = RDS Decoder\n");
1264                         if (exthdr->devicetype & 0x400)
1265                                 dprintk(DBGLVL_API, "   = Encoder\n");
1266                         if (exthdr->devicetype & 0x800)
1267                                 dprintk(DBGLVL_API, "   = IR Decoder\n");
1268                         if (exthdr->devicetype & 0x1000)
1269                                 dprintk(DBGLVL_API, "   = EEPROM\n");
1270                         if (exthdr->devicetype & 0x2000)
1271                                 dprintk(DBGLVL_API,
1272                                         "   = VBI Decoder\n");
1273                         if (exthdr->devicetype & 0x10000)
1274                                 dprintk(DBGLVL_API,
1275                                         "   = Streaming Device\n");
1276                         if (exthdr->devicetype & 0x20000)
1277                                 dprintk(DBGLVL_API,
1278                                         "   = DRM Device\n");
1279                         if (exthdr->devicetype & 0x40000000)
1280                                 dprintk(DBGLVL_API,
1281                                         "   = Generic Device\n");
1282                         if (exthdr->devicetype & 0x80000000)
1283                                 dprintk(DBGLVL_API,
1284                                         "   = Config Space Device\n");
1285                         dprintk(DBGLVL_API, "  numgpiopins = 0x%x\n",
1286                                 exthdr->numgpiopins);
1287                         dprintk(DBGLVL_API, "  numgpiogroups = 0x%x\n",
1288                                 exthdr->numgpiogroups);
1289                         dprintk(DBGLVL_API, "  controlsize = 0x%x\n",
1290                                 exthdr->controlsize);
1291                         if (exthdr->devicetype & 0x80) {
1292                                 if (currpath == 1)
1293                                         encport = &dev->ports[SAA7164_PORT_ENC1];
1294                                 else
1295                                         encport = &dev->ports[SAA7164_PORT_ENC2];
1296                                 memcpy(&encport->ifunit, exthdr,
1297                                         sizeof(struct tmComResExtDevDescrHeader));
1298                                 dprintk(DBGLVL_API,
1299                                         "  (becomes dev->enc[%d])\n",
1300                                         encport->nr);
1301                         }
1302                         break;
1303                 case PVC_INFRARED_UNIT:
1304                         dprintk(DBGLVL_API, " PVC_INFRARED_UNIT\n");
1305                         break;
1306                 case DRM_UNIT:
1307                         dprintk(DBGLVL_API, " DRM_UNIT\n");
1308                         break;
1309                 default:
1310                         dprintk(DBGLVL_API, "default %d\n", hdr->subtype);
1311                 }
1312
1313                 dprintk(DBGLVL_API, " 1.%x\n", hdr->len);
1314                 dprintk(DBGLVL_API, " 2.%x\n", hdr->type);
1315                 dprintk(DBGLVL_API, " 3.%x\n", hdr->subtype);
1316                 dprintk(DBGLVL_API, " 4.%x\n", hdr->unitid);
1317
1318                 idx += hdr->len;
1319         }
1320
1321         return 0;
1322 }
1323
1324 int saa7164_api_enum_subdevs(struct saa7164_dev *dev)
1325 {
1326         int ret;
1327         u32 buflen = 0;
1328         u8 *buf;
1329
1330         dprintk(DBGLVL_API, "%s()\n", __func__);
1331
1332         /* Get the total descriptor length */
1333         ret = saa7164_cmd_send(dev, 0, GET_LEN,
1334                 GET_DESCRIPTORS_CONTROL, sizeof(buflen), &buflen);
1335         if (ret != SAA_OK)
1336                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
1337
1338         dprintk(DBGLVL_API, "%s() total descriptor size = %d bytes.\n",
1339                 __func__, buflen);
1340
1341         /* Allocate enough storage for all of the descs */
1342         buf = kzalloc(buflen, GFP_KERNEL);
1343         if (!buf)
1344                 return SAA_ERR_NO_RESOURCES;
1345
1346         /* Retrieve them */
1347         ret = saa7164_cmd_send(dev, 0, GET_CUR,
1348                 GET_DESCRIPTORS_CONTROL, buflen, buf);
1349         if (ret != SAA_OK) {
1350                 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
1351                 goto out;
1352         }
1353
1354         if (saa_debug & DBGLVL_API)
1355                 saa7164_dumphex16(dev, buf, (buflen/16)*16);
1356
1357         saa7164_api_dump_subdevs(dev, buf, buflen);
1358
1359 out:
1360         kfree(buf);
1361         return ret;
1362 }
1363
1364 int saa7164_api_i2c_read(struct saa7164_i2c *bus, u8 addr, u32 reglen, u8 *reg,
1365         u32 datalen, u8 *data)
1366 {
1367         struct saa7164_dev *dev = bus->dev;
1368         u16 len = 0;
1369         int unitid;
1370         u32 regval;
1371         u8 buf[256];
1372         int ret;
1373
1374         dprintk(DBGLVL_API, "%s()\n", __func__);
1375
1376         if (reglen > 4)
1377                 return -EIO;
1378
1379         if (reglen == 1)
1380                 regval = *(reg);
1381         else
1382         if (reglen == 2)
1383                 regval = ((*(reg) << 8) || *(reg+1));
1384         else
1385         if (reglen == 3)
1386                 regval = ((*(reg) << 16) | (*(reg+1) << 8) | *(reg+2));
1387         else
1388         if (reglen == 4)
1389                 regval = ((*(reg) << 24) | (*(reg+1) << 16) |
1390                         (*(reg+2) << 8) | *(reg+3));
1391
1392         /* Prepare the send buffer */
1393         /* Bytes 00-03 source register length
1394          *       04-07 source bytes to read
1395          *       08... register address
1396          */
1397         memset(buf, 0, sizeof(buf));
1398         memcpy((buf + 2 * sizeof(u32) + 0), reg, reglen);
1399         *((u32 *)(buf + 0 * sizeof(u32))) = reglen;
1400         *((u32 *)(buf + 1 * sizeof(u32))) = datalen;
1401
1402         unitid = saa7164_i2caddr_to_unitid(bus, addr);
1403         if (unitid < 0) {
1404                 printk(KERN_ERR
1405                         "%s() error, cannot translate regaddr 0x%x to unitid\n",
1406                         __func__, addr);
1407                 return -EIO;
1408         }
1409
1410         ret = saa7164_cmd_send(bus->dev, unitid, GET_LEN,
1411                 EXU_REGISTER_ACCESS_CONTROL, sizeof(len), &len);
1412         if (ret != SAA_OK) {
1413                 printk(KERN_ERR "%s() error, ret(1) = 0x%x\n", __func__, ret);
1414                 return -EIO;
1415         }
1416
1417         dprintk(DBGLVL_API, "%s() len = %d bytes\n", __func__, len);
1418
1419         if (saa_debug & DBGLVL_I2C)
1420                 saa7164_dumphex16(dev, buf, 2 * 16);
1421
1422         ret = saa7164_cmd_send(bus->dev, unitid, GET_CUR,
1423                 EXU_REGISTER_ACCESS_CONTROL, len, &buf);
1424         if (ret != SAA_OK)
1425                 printk(KERN_ERR "%s() error, ret(2) = 0x%x\n", __func__, ret);
1426         else {
1427                 if (saa_debug & DBGLVL_I2C)
1428                         saa7164_dumphex16(dev, buf, sizeof(buf));
1429                 memcpy(data, (buf + 2 * sizeof(u32) + reglen), datalen);
1430         }
1431
1432         return ret == SAA_OK ? 0 : -EIO;
1433 }
1434
1435 /* For a given 8 bit i2c address device, write the buffer */
1436 int saa7164_api_i2c_write(struct saa7164_i2c *bus, u8 addr, u32 datalen,
1437         u8 *data)
1438 {
1439         struct saa7164_dev *dev = bus->dev;
1440         u16 len = 0;
1441         int unitid;
1442         int reglen;
1443         u8 buf[256];
1444         int ret;
1445
1446         dprintk(DBGLVL_API, "%s()\n", __func__);
1447
1448         if ((datalen == 0) || (datalen > 232))
1449                 return -EIO;
1450
1451         memset(buf, 0, sizeof(buf));
1452
1453         unitid = saa7164_i2caddr_to_unitid(bus, addr);
1454         if (unitid < 0) {
1455                 printk(KERN_ERR
1456                         "%s() error, cannot translate regaddr 0x%x to unitid\n",
1457                         __func__, addr);
1458                 return -EIO;
1459         }
1460
1461         reglen = saa7164_i2caddr_to_reglen(bus, addr);
1462         if (reglen < 0) {
1463                 printk(KERN_ERR
1464                         "%s() error, cannot translate regaddr to reglen\n",
1465                         __func__);
1466                 return -EIO;
1467         }
1468
1469         ret = saa7164_cmd_send(bus->dev, unitid, GET_LEN,
1470                 EXU_REGISTER_ACCESS_CONTROL, sizeof(len), &len);
1471         if (ret != SAA_OK) {
1472                 printk(KERN_ERR "%s() error, ret(1) = 0x%x\n", __func__, ret);
1473                 return -EIO;
1474         }
1475
1476         dprintk(DBGLVL_API, "%s() len = %d bytes\n", __func__, len);
1477
1478         /* Prepare the send buffer */
1479         /* Bytes 00-03 dest register length
1480          *       04-07 dest bytes to write
1481          *       08... register address
1482          */
1483         *((u32 *)(buf + 0 * sizeof(u32))) = reglen;
1484         *((u32 *)(buf + 1 * sizeof(u32))) = datalen - reglen;
1485         memcpy((buf + 2 * sizeof(u32)), data, datalen);
1486
1487         if (saa_debug & DBGLVL_I2C)
1488                 saa7164_dumphex16(dev, buf, sizeof(buf));
1489
1490         ret = saa7164_cmd_send(bus->dev, unitid, SET_CUR,
1491                 EXU_REGISTER_ACCESS_CONTROL, len, &buf);
1492         if (ret != SAA_OK)
1493                 printk(KERN_ERR "%s() error, ret(2) = 0x%x\n", __func__, ret);
1494
1495         return ret == SAA_OK ? 0 : -EIO;
1496 }
1497
1498 int saa7164_api_modify_gpio(struct saa7164_dev *dev, u8 unitid,
1499         u8 pin, u8 state)
1500 {
1501         int ret;
1502         struct tmComResGPIO t;
1503
1504         dprintk(DBGLVL_API, "%s(0x%x, %d, %d)\n",
1505                 __func__, unitid, pin, state);
1506
1507         if ((pin > 7) || (state > 2))
1508                 return SAA_ERR_BAD_PARAMETER;
1509
1510         t.pin = pin;
1511         t.state = state;
1512
1513         ret = saa7164_cmd_send(dev, unitid, SET_CUR,
1514                 EXU_GPIO_CONTROL, sizeof(t), &t);
1515         if (ret != SAA_OK)
1516                 printk(KERN_ERR "%s() error, ret = 0x%x\n",
1517                         __func__, ret);
1518
1519         return ret;
1520 }
1521
1522 int saa7164_api_set_gpiobit(struct saa7164_dev *dev, u8 unitid,
1523         u8 pin)
1524 {
1525         return saa7164_api_modify_gpio(dev, unitid, pin, 1);
1526 }
1527
1528 int saa7164_api_clear_gpiobit(struct saa7164_dev *dev, u8 unitid,
1529         u8 pin)
1530 {
1531         return saa7164_api_modify_gpio(dev, unitid, pin, 0);
1532 }
1533