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 static 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 static 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 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 1, buf, 16, 674 false); 675 #endif 676 return ret == SAA_OK ? 0 : -EIO; 677 } 678 679 /* Disable the IF block AGC controls */ 680 int saa7164_api_configure_dif(struct saa7164_port *port, u32 std) 681 { 682 struct saa7164_dev *dev = port->dev; 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 0; 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 ®[0], 128, buf); 822 } 823 824 static 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 static int 861 saa7164_api_configure_port_mpeg2ts(struct saa7164_dev *dev, 862 struct saa7164_port *port, 863 struct tmComResTSFormatDescrHeader *tsfmt) 864 { 865 dprintk(DBGLVL_API, " bFormatIndex = 0x%x\n", tsfmt->bFormatIndex); 866 dprintk(DBGLVL_API, " bDataOffset = 0x%x\n", tsfmt->bDataOffset); 867 dprintk(DBGLVL_API, " bPacketLength= 0x%x\n", tsfmt->bPacketLength); 868 dprintk(DBGLVL_API, " bStrideLength= 0x%x\n", tsfmt->bStrideLength); 869 dprintk(DBGLVL_API, " bguid = (....)\n"); 870 871 /* Cache the hardware configuration in the port */ 872 873 port->bufcounter = port->hwcfg.BARLocation; 874 port->pitch = port->hwcfg.BARLocation + (2 * sizeof(u32)); 875 port->bufsize = port->hwcfg.BARLocation + (3 * sizeof(u32)); 876 port->bufoffset = port->hwcfg.BARLocation + (4 * sizeof(u32)); 877 port->bufptr32l = port->hwcfg.BARLocation + 878 (4 * sizeof(u32)) + 879 (sizeof(u32) * port->hwcfg.buffercount) + sizeof(u32); 880 port->bufptr32h = port->hwcfg.BARLocation + 881 (4 * sizeof(u32)) + 882 (sizeof(u32) * port->hwcfg.buffercount); 883 port->bufptr64 = port->hwcfg.BARLocation + 884 (4 * sizeof(u32)) + 885 (sizeof(u32) * port->hwcfg.buffercount); 886 dprintk(DBGLVL_API, " = port->hwcfg.BARLocation = 0x%x\n", 887 port->hwcfg.BARLocation); 888 889 dprintk(DBGLVL_API, " = VS_FORMAT_MPEGTS (becomes dev->ts[%d])\n", 890 port->nr); 891 892 return 0; 893 } 894 895 static int 896 saa7164_api_configure_port_mpeg2ps(struct saa7164_dev *dev, 897 struct saa7164_port *port, 898 struct tmComResPSFormatDescrHeader *fmt) 899 { 900 dprintk(DBGLVL_API, " bFormatIndex = 0x%x\n", fmt->bFormatIndex); 901 dprintk(DBGLVL_API, " wPacketLength= 0x%x\n", fmt->wPacketLength); 902 dprintk(DBGLVL_API, " wPackLength= 0x%x\n", fmt->wPackLength); 903 dprintk(DBGLVL_API, " bPackDataType= 0x%x\n", fmt->bPackDataType); 904 905 /* Cache the hardware configuration in the port */ 906 /* TODO: CHECK THIS in the port config */ 907 port->bufcounter = port->hwcfg.BARLocation; 908 port->pitch = port->hwcfg.BARLocation + (2 * sizeof(u32)); 909 port->bufsize = port->hwcfg.BARLocation + (3 * sizeof(u32)); 910 port->bufoffset = port->hwcfg.BARLocation + (4 * sizeof(u32)); 911 port->bufptr32l = port->hwcfg.BARLocation + 912 (4 * sizeof(u32)) + 913 (sizeof(u32) * port->hwcfg.buffercount) + sizeof(u32); 914 port->bufptr32h = port->hwcfg.BARLocation + 915 (4 * sizeof(u32)) + 916 (sizeof(u32) * port->hwcfg.buffercount); 917 port->bufptr64 = port->hwcfg.BARLocation + 918 (4 * sizeof(u32)) + 919 (sizeof(u32) * port->hwcfg.buffercount); 920 dprintk(DBGLVL_API, " = port->hwcfg.BARLocation = 0x%x\n", 921 port->hwcfg.BARLocation); 922 923 dprintk(DBGLVL_API, " = VS_FORMAT_MPEGPS (becomes dev->enc[%d])\n", 924 port->nr); 925 926 return 0; 927 } 928 929 static int saa7164_api_dump_subdevs(struct saa7164_dev *dev, u8 *buf, int len) 930 { 931 struct saa7164_port *tsport = NULL; 932 struct saa7164_port *encport = NULL; 933 struct saa7164_port *vbiport = NULL; 934 u32 idx, next_offset; 935 int i; 936 struct tmComResDescrHeader *hdr, *t; 937 struct tmComResExtDevDescrHeader *exthdr; 938 struct tmComResPathDescrHeader *pathhdr; 939 struct tmComResAntTermDescrHeader *anttermhdr; 940 struct tmComResTunerDescrHeader *tunerunithdr; 941 struct tmComResDMATermDescrHeader *vcoutputtermhdr; 942 struct tmComResTSFormatDescrHeader *tsfmt; 943 struct tmComResPSFormatDescrHeader *psfmt; 944 struct tmComResSelDescrHeader *psel; 945 struct tmComResProcDescrHeader *pdh; 946 struct tmComResAFeatureDescrHeader *afd; 947 struct tmComResEncoderDescrHeader *edh; 948 struct tmComResVBIFormatDescrHeader *vbifmt; 949 u32 currpath = 0; 950 951 dprintk(DBGLVL_API, 952 "%s(?,?,%d) sizeof(struct tmComResDescrHeader) = %d bytes\n", 953 __func__, len, (u32)sizeof(struct tmComResDescrHeader)); 954 955 for (idx = 0; idx < (len - sizeof(struct tmComResDescrHeader));) { 956 957 hdr = (struct tmComResDescrHeader *)(buf + idx); 958 959 if (hdr->type != CS_INTERFACE) 960 return SAA_ERR_NOT_SUPPORTED; 961 962 dprintk(DBGLVL_API, "@ 0x%x =\n", idx); 963 switch (hdr->subtype) { 964 case GENERAL_REQUEST: 965 dprintk(DBGLVL_API, " GENERAL_REQUEST\n"); 966 break; 967 case VC_TUNER_PATH: 968 dprintk(DBGLVL_API, " VC_TUNER_PATH\n"); 969 pathhdr = (struct tmComResPathDescrHeader *)(buf + idx); 970 dprintk(DBGLVL_API, " pathid = 0x%x\n", 971 pathhdr->pathid); 972 currpath = pathhdr->pathid; 973 break; 974 case VC_INPUT_TERMINAL: 975 dprintk(DBGLVL_API, " VC_INPUT_TERMINAL\n"); 976 anttermhdr = 977 (struct tmComResAntTermDescrHeader *)(buf + idx); 978 dprintk(DBGLVL_API, " terminalid = 0x%x\n", 979 anttermhdr->terminalid); 980 dprintk(DBGLVL_API, " terminaltype = 0x%x\n", 981 anttermhdr->terminaltype); 982 switch (anttermhdr->terminaltype) { 983 case ITT_ANTENNA: 984 dprintk(DBGLVL_API, " = ITT_ANTENNA\n"); 985 break; 986 case LINE_CONNECTOR: 987 dprintk(DBGLVL_API, " = LINE_CONNECTOR\n"); 988 break; 989 case SPDIF_CONNECTOR: 990 dprintk(DBGLVL_API, " = SPDIF_CONNECTOR\n"); 991 break; 992 case COMPOSITE_CONNECTOR: 993 dprintk(DBGLVL_API, 994 " = COMPOSITE_CONNECTOR\n"); 995 break; 996 case SVIDEO_CONNECTOR: 997 dprintk(DBGLVL_API, " = SVIDEO_CONNECTOR\n"); 998 break; 999 case COMPONENT_CONNECTOR: 1000 dprintk(DBGLVL_API, 1001 " = COMPONENT_CONNECTOR\n"); 1002 break; 1003 case STANDARD_DMA: 1004 dprintk(DBGLVL_API, " = STANDARD_DMA\n"); 1005 break; 1006 default: 1007 dprintk(DBGLVL_API, " = undefined (0x%x)\n", 1008 anttermhdr->terminaltype); 1009 } 1010 dprintk(DBGLVL_API, " assocterminal= 0x%x\n", 1011 anttermhdr->assocterminal); 1012 dprintk(DBGLVL_API, " iterminal = 0x%x\n", 1013 anttermhdr->iterminal); 1014 dprintk(DBGLVL_API, " controlsize = 0x%x\n", 1015 anttermhdr->controlsize); 1016 break; 1017 case VC_OUTPUT_TERMINAL: 1018 dprintk(DBGLVL_API, " VC_OUTPUT_TERMINAL\n"); 1019 vcoutputtermhdr = 1020 (struct tmComResDMATermDescrHeader *)(buf + idx); 1021 dprintk(DBGLVL_API, " unitid = 0x%x\n", 1022 vcoutputtermhdr->unitid); 1023 dprintk(DBGLVL_API, " terminaltype = 0x%x\n", 1024 vcoutputtermhdr->terminaltype); 1025 switch (vcoutputtermhdr->terminaltype) { 1026 case ITT_ANTENNA: 1027 dprintk(DBGLVL_API, " = ITT_ANTENNA\n"); 1028 break; 1029 case LINE_CONNECTOR: 1030 dprintk(DBGLVL_API, " = LINE_CONNECTOR\n"); 1031 break; 1032 case SPDIF_CONNECTOR: 1033 dprintk(DBGLVL_API, " = SPDIF_CONNECTOR\n"); 1034 break; 1035 case COMPOSITE_CONNECTOR: 1036 dprintk(DBGLVL_API, 1037 " = COMPOSITE_CONNECTOR\n"); 1038 break; 1039 case SVIDEO_CONNECTOR: 1040 dprintk(DBGLVL_API, " = SVIDEO_CONNECTOR\n"); 1041 break; 1042 case COMPONENT_CONNECTOR: 1043 dprintk(DBGLVL_API, 1044 " = COMPONENT_CONNECTOR\n"); 1045 break; 1046 case STANDARD_DMA: 1047 dprintk(DBGLVL_API, " = STANDARD_DMA\n"); 1048 break; 1049 default: 1050 dprintk(DBGLVL_API, " = undefined (0x%x)\n", 1051 vcoutputtermhdr->terminaltype); 1052 } 1053 dprintk(DBGLVL_API, " assocterminal= 0x%x\n", 1054 vcoutputtermhdr->assocterminal); 1055 dprintk(DBGLVL_API, " sourceid = 0x%x\n", 1056 vcoutputtermhdr->sourceid); 1057 dprintk(DBGLVL_API, " iterminal = 0x%x\n", 1058 vcoutputtermhdr->iterminal); 1059 dprintk(DBGLVL_API, " BARLocation = 0x%x\n", 1060 vcoutputtermhdr->BARLocation); 1061 dprintk(DBGLVL_API, " flags = 0x%x\n", 1062 vcoutputtermhdr->flags); 1063 dprintk(DBGLVL_API, " interruptid = 0x%x\n", 1064 vcoutputtermhdr->interruptid); 1065 dprintk(DBGLVL_API, " buffercount = 0x%x\n", 1066 vcoutputtermhdr->buffercount); 1067 dprintk(DBGLVL_API, " metadatasize = 0x%x\n", 1068 vcoutputtermhdr->metadatasize); 1069 dprintk(DBGLVL_API, " controlsize = 0x%x\n", 1070 vcoutputtermhdr->controlsize); 1071 dprintk(DBGLVL_API, " numformats = 0x%x\n", 1072 vcoutputtermhdr->numformats); 1073 1074 t = (struct tmComResDescrHeader *) 1075 ((struct tmComResDMATermDescrHeader *)(buf + idx)); 1076 next_offset = idx + (vcoutputtermhdr->len); 1077 for (i = 0; i < vcoutputtermhdr->numformats; i++) { 1078 t = (struct tmComResDescrHeader *) 1079 (buf + next_offset); 1080 switch (t->subtype) { 1081 case VS_FORMAT_MPEG2TS: 1082 tsfmt = 1083 (struct tmComResTSFormatDescrHeader *)t; 1084 if (currpath == 1) 1085 tsport = &dev->ports[SAA7164_PORT_TS1]; 1086 else 1087 tsport = &dev->ports[SAA7164_PORT_TS2]; 1088 memcpy(&tsport->hwcfg, vcoutputtermhdr, 1089 sizeof(*vcoutputtermhdr)); 1090 saa7164_api_configure_port_mpeg2ts(dev, 1091 tsport, tsfmt); 1092 break; 1093 case VS_FORMAT_MPEG2PS: 1094 psfmt = 1095 (struct tmComResPSFormatDescrHeader *)t; 1096 if (currpath == 1) 1097 encport = &dev->ports[SAA7164_PORT_ENC1]; 1098 else 1099 encport = &dev->ports[SAA7164_PORT_ENC2]; 1100 memcpy(&encport->hwcfg, vcoutputtermhdr, 1101 sizeof(*vcoutputtermhdr)); 1102 saa7164_api_configure_port_mpeg2ps(dev, 1103 encport, psfmt); 1104 break; 1105 case VS_FORMAT_VBI: 1106 vbifmt = 1107 (struct tmComResVBIFormatDescrHeader *)t; 1108 if (currpath == 1) 1109 vbiport = &dev->ports[SAA7164_PORT_VBI1]; 1110 else 1111 vbiport = &dev->ports[SAA7164_PORT_VBI2]; 1112 memcpy(&vbiport->hwcfg, vcoutputtermhdr, 1113 sizeof(*vcoutputtermhdr)); 1114 memcpy(&vbiport->vbi_fmt_ntsc, vbifmt, 1115 sizeof(*vbifmt)); 1116 saa7164_api_configure_port_vbi(dev, 1117 vbiport); 1118 break; 1119 case VS_FORMAT_RDS: 1120 dprintk(DBGLVL_API, 1121 " = VS_FORMAT_RDS\n"); 1122 break; 1123 case VS_FORMAT_UNCOMPRESSED: 1124 dprintk(DBGLVL_API, 1125 " = VS_FORMAT_UNCOMPRESSED\n"); 1126 break; 1127 case VS_FORMAT_TYPE: 1128 dprintk(DBGLVL_API, 1129 " = VS_FORMAT_TYPE\n"); 1130 break; 1131 default: 1132 dprintk(DBGLVL_API, 1133 " = undefined (0x%x)\n", 1134 t->subtype); 1135 } 1136 next_offset += t->len; 1137 } 1138 1139 break; 1140 case TUNER_UNIT: 1141 dprintk(DBGLVL_API, " TUNER_UNIT\n"); 1142 tunerunithdr = 1143 (struct tmComResTunerDescrHeader *)(buf + idx); 1144 dprintk(DBGLVL_API, " unitid = 0x%x\n", 1145 tunerunithdr->unitid); 1146 dprintk(DBGLVL_API, " sourceid = 0x%x\n", 1147 tunerunithdr->sourceid); 1148 dprintk(DBGLVL_API, " iunit = 0x%x\n", 1149 tunerunithdr->iunit); 1150 dprintk(DBGLVL_API, " tuningstandards = 0x%x\n", 1151 tunerunithdr->tuningstandards); 1152 dprintk(DBGLVL_API, " controlsize = 0x%x\n", 1153 tunerunithdr->controlsize); 1154 dprintk(DBGLVL_API, " controls = 0x%x\n", 1155 tunerunithdr->controls); 1156 1157 if (tunerunithdr->unitid == tunerunithdr->iunit) { 1158 if (currpath == 1) 1159 encport = &dev->ports[SAA7164_PORT_ENC1]; 1160 else 1161 encport = &dev->ports[SAA7164_PORT_ENC2]; 1162 memcpy(&encport->tunerunit, tunerunithdr, 1163 sizeof(struct tmComResTunerDescrHeader)); 1164 dprintk(DBGLVL_API, 1165 " (becomes dev->enc[%d] tuner)\n", 1166 encport->nr); 1167 } 1168 break; 1169 case VC_SELECTOR_UNIT: 1170 psel = (struct tmComResSelDescrHeader *)(buf + idx); 1171 dprintk(DBGLVL_API, " VC_SELECTOR_UNIT\n"); 1172 dprintk(DBGLVL_API, " unitid = 0x%x\n", 1173 psel->unitid); 1174 dprintk(DBGLVL_API, " nrinpins = 0x%x\n", 1175 psel->nrinpins); 1176 dprintk(DBGLVL_API, " sourceid = 0x%x\n", 1177 psel->sourceid); 1178 break; 1179 case VC_PROCESSING_UNIT: 1180 pdh = (struct tmComResProcDescrHeader *)(buf + idx); 1181 dprintk(DBGLVL_API, " VC_PROCESSING_UNIT\n"); 1182 dprintk(DBGLVL_API, " unitid = 0x%x\n", 1183 pdh->unitid); 1184 dprintk(DBGLVL_API, " sourceid = 0x%x\n", 1185 pdh->sourceid); 1186 dprintk(DBGLVL_API, " controlsize = 0x%x\n", 1187 pdh->controlsize); 1188 if (pdh->controlsize == 0x04) { 1189 if (currpath == 1) 1190 encport = &dev->ports[SAA7164_PORT_ENC1]; 1191 else 1192 encport = &dev->ports[SAA7164_PORT_ENC2]; 1193 memcpy(&encport->vidproc, pdh, 1194 sizeof(struct tmComResProcDescrHeader)); 1195 dprintk(DBGLVL_API, " (becomes dev->enc[%d])\n", 1196 encport->nr); 1197 } 1198 break; 1199 case FEATURE_UNIT: 1200 afd = (struct tmComResAFeatureDescrHeader *)(buf + idx); 1201 dprintk(DBGLVL_API, " FEATURE_UNIT\n"); 1202 dprintk(DBGLVL_API, " unitid = 0x%x\n", 1203 afd->unitid); 1204 dprintk(DBGLVL_API, " sourceid = 0x%x\n", 1205 afd->sourceid); 1206 dprintk(DBGLVL_API, " controlsize = 0x%x\n", 1207 afd->controlsize); 1208 if (currpath == 1) 1209 encport = &dev->ports[SAA7164_PORT_ENC1]; 1210 else 1211 encport = &dev->ports[SAA7164_PORT_ENC2]; 1212 memcpy(&encport->audfeat, afd, 1213 sizeof(struct tmComResAFeatureDescrHeader)); 1214 dprintk(DBGLVL_API, " (becomes dev->enc[%d])\n", 1215 encport->nr); 1216 break; 1217 case ENCODER_UNIT: 1218 edh = (struct tmComResEncoderDescrHeader *)(buf + idx); 1219 dprintk(DBGLVL_API, " ENCODER_UNIT\n"); 1220 dprintk(DBGLVL_API, " subtype = 0x%x\n", edh->subtype); 1221 dprintk(DBGLVL_API, " unitid = 0x%x\n", edh->unitid); 1222 dprintk(DBGLVL_API, " vsourceid = 0x%x\n", 1223 edh->vsourceid); 1224 dprintk(DBGLVL_API, " asourceid = 0x%x\n", 1225 edh->asourceid); 1226 dprintk(DBGLVL_API, " iunit = 0x%x\n", edh->iunit); 1227 if (edh->iunit == edh->unitid) { 1228 if (currpath == 1) 1229 encport = &dev->ports[SAA7164_PORT_ENC1]; 1230 else 1231 encport = &dev->ports[SAA7164_PORT_ENC2]; 1232 memcpy(&encport->encunit, edh, 1233 sizeof(struct tmComResEncoderDescrHeader)); 1234 dprintk(DBGLVL_API, 1235 " (becomes dev->enc[%d])\n", 1236 encport->nr); 1237 } 1238 break; 1239 case EXTENSION_UNIT: 1240 dprintk(DBGLVL_API, " EXTENSION_UNIT\n"); 1241 exthdr = (struct tmComResExtDevDescrHeader *)(buf + idx); 1242 dprintk(DBGLVL_API, " unitid = 0x%x\n", 1243 exthdr->unitid); 1244 dprintk(DBGLVL_API, " deviceid = 0x%x\n", 1245 exthdr->deviceid); 1246 dprintk(DBGLVL_API, " devicetype = 0x%x\n", 1247 exthdr->devicetype); 1248 if (exthdr->devicetype & 0x1) 1249 dprintk(DBGLVL_API, " = Decoder Device\n"); 1250 if (exthdr->devicetype & 0x2) 1251 dprintk(DBGLVL_API, " = GPIO Source\n"); 1252 if (exthdr->devicetype & 0x4) 1253 dprintk(DBGLVL_API, " = Video Decoder\n"); 1254 if (exthdr->devicetype & 0x8) 1255 dprintk(DBGLVL_API, " = Audio Decoder\n"); 1256 if (exthdr->devicetype & 0x20) 1257 dprintk(DBGLVL_API, " = Crossbar\n"); 1258 if (exthdr->devicetype & 0x40) 1259 dprintk(DBGLVL_API, " = Tuner\n"); 1260 if (exthdr->devicetype & 0x80) 1261 dprintk(DBGLVL_API, " = IF PLL\n"); 1262 if (exthdr->devicetype & 0x100) 1263 dprintk(DBGLVL_API, " = Demodulator\n"); 1264 if (exthdr->devicetype & 0x200) 1265 dprintk(DBGLVL_API, " = RDS Decoder\n"); 1266 if (exthdr->devicetype & 0x400) 1267 dprintk(DBGLVL_API, " = Encoder\n"); 1268 if (exthdr->devicetype & 0x800) 1269 dprintk(DBGLVL_API, " = IR Decoder\n"); 1270 if (exthdr->devicetype & 0x1000) 1271 dprintk(DBGLVL_API, " = EEPROM\n"); 1272 if (exthdr->devicetype & 0x2000) 1273 dprintk(DBGLVL_API, 1274 " = VBI Decoder\n"); 1275 if (exthdr->devicetype & 0x10000) 1276 dprintk(DBGLVL_API, 1277 " = Streaming Device\n"); 1278 if (exthdr->devicetype & 0x20000) 1279 dprintk(DBGLVL_API, 1280 " = DRM Device\n"); 1281 if (exthdr->devicetype & 0x40000000) 1282 dprintk(DBGLVL_API, 1283 " = Generic Device\n"); 1284 if (exthdr->devicetype & 0x80000000) 1285 dprintk(DBGLVL_API, 1286 " = Config Space Device\n"); 1287 dprintk(DBGLVL_API, " numgpiopins = 0x%x\n", 1288 exthdr->numgpiopins); 1289 dprintk(DBGLVL_API, " numgpiogroups = 0x%x\n", 1290 exthdr->numgpiogroups); 1291 dprintk(DBGLVL_API, " controlsize = 0x%x\n", 1292 exthdr->controlsize); 1293 if (exthdr->devicetype & 0x80) { 1294 if (currpath == 1) 1295 encport = &dev->ports[SAA7164_PORT_ENC1]; 1296 else 1297 encport = &dev->ports[SAA7164_PORT_ENC2]; 1298 memcpy(&encport->ifunit, exthdr, 1299 sizeof(struct tmComResExtDevDescrHeader)); 1300 dprintk(DBGLVL_API, 1301 " (becomes dev->enc[%d])\n", 1302 encport->nr); 1303 } 1304 break; 1305 case PVC_INFRARED_UNIT: 1306 dprintk(DBGLVL_API, " PVC_INFRARED_UNIT\n"); 1307 break; 1308 case DRM_UNIT: 1309 dprintk(DBGLVL_API, " DRM_UNIT\n"); 1310 break; 1311 default: 1312 dprintk(DBGLVL_API, "default %d\n", hdr->subtype); 1313 } 1314 1315 dprintk(DBGLVL_API, " 1.%x\n", hdr->len); 1316 dprintk(DBGLVL_API, " 2.%x\n", hdr->type); 1317 dprintk(DBGLVL_API, " 3.%x\n", hdr->subtype); 1318 dprintk(DBGLVL_API, " 4.%x\n", hdr->unitid); 1319 1320 idx += hdr->len; 1321 } 1322 1323 return 0; 1324 } 1325 1326 int saa7164_api_enum_subdevs(struct saa7164_dev *dev) 1327 { 1328 int ret; 1329 u32 buflen = 0; 1330 u8 *buf; 1331 1332 dprintk(DBGLVL_API, "%s()\n", __func__); 1333 1334 /* Get the total descriptor length */ 1335 ret = saa7164_cmd_send(dev, 0, GET_LEN, 1336 GET_DESCRIPTORS_CONTROL, sizeof(buflen), &buflen); 1337 if (ret != SAA_OK) 1338 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret); 1339 1340 dprintk(DBGLVL_API, "%s() total descriptor size = %d bytes.\n", 1341 __func__, buflen); 1342 1343 /* Allocate enough storage for all of the descs */ 1344 buf = kzalloc(buflen, GFP_KERNEL); 1345 if (!buf) 1346 return SAA_ERR_NO_RESOURCES; 1347 1348 /* Retrieve them */ 1349 ret = saa7164_cmd_send(dev, 0, GET_CUR, 1350 GET_DESCRIPTORS_CONTROL, buflen, buf); 1351 if (ret != SAA_OK) { 1352 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret); 1353 goto out; 1354 } 1355 1356 if (saa_debug & DBGLVL_API) 1357 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 1, buf, 1358 buflen & ~15, false); 1359 1360 saa7164_api_dump_subdevs(dev, buf, buflen); 1361 1362 out: 1363 kfree(buf); 1364 return ret; 1365 } 1366 1367 int saa7164_api_i2c_read(struct saa7164_i2c *bus, u8 addr, u32 reglen, u8 *reg, 1368 u32 datalen, u8 *data) 1369 { 1370 struct saa7164_dev *dev = bus->dev; 1371 u16 len = 0; 1372 int unitid; 1373 u8 buf[256]; 1374 int ret; 1375 1376 dprintk(DBGLVL_API, "%s()\n", __func__); 1377 1378 if (reglen > 4) 1379 return -EIO; 1380 1381 /* Prepare the send buffer */ 1382 /* Bytes 00-03 source register length 1383 * 04-07 source bytes to read 1384 * 08... register address 1385 */ 1386 memset(buf, 0, sizeof(buf)); 1387 memcpy((buf + 2 * sizeof(u32) + 0), reg, reglen); 1388 *((u32 *)(buf + 0 * sizeof(u32))) = reglen; 1389 *((u32 *)(buf + 1 * sizeof(u32))) = datalen; 1390 1391 unitid = saa7164_i2caddr_to_unitid(bus, addr); 1392 if (unitid < 0) { 1393 printk(KERN_ERR 1394 "%s() error, cannot translate regaddr 0x%x to unitid\n", 1395 __func__, addr); 1396 return -EIO; 1397 } 1398 1399 ret = saa7164_cmd_send(bus->dev, unitid, GET_LEN, 1400 EXU_REGISTER_ACCESS_CONTROL, sizeof(len), &len); 1401 if (ret != SAA_OK) { 1402 printk(KERN_ERR "%s() error, ret(1) = 0x%x\n", __func__, ret); 1403 return -EIO; 1404 } 1405 1406 dprintk(DBGLVL_API, "%s() len = %d bytes\n", __func__, len); 1407 1408 if (saa_debug & DBGLVL_I2C) 1409 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 1, buf, 1410 32, false); 1411 1412 ret = saa7164_cmd_send(bus->dev, unitid, GET_CUR, 1413 EXU_REGISTER_ACCESS_CONTROL, len, &buf); 1414 if (ret != SAA_OK) 1415 printk(KERN_ERR "%s() error, ret(2) = 0x%x\n", __func__, ret); 1416 else { 1417 if (saa_debug & DBGLVL_I2C) 1418 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 1, 1419 buf, sizeof(buf), false); 1420 memcpy(data, (buf + 2 * sizeof(u32) + reglen), datalen); 1421 } 1422 1423 return ret == SAA_OK ? 0 : -EIO; 1424 } 1425 1426 /* For a given 8 bit i2c address device, write the buffer */ 1427 int saa7164_api_i2c_write(struct saa7164_i2c *bus, u8 addr, u32 datalen, 1428 u8 *data) 1429 { 1430 struct saa7164_dev *dev = bus->dev; 1431 u16 len = 0; 1432 int unitid; 1433 int reglen; 1434 u8 buf[256]; 1435 int ret; 1436 1437 dprintk(DBGLVL_API, "%s()\n", __func__); 1438 1439 if ((datalen == 0) || (datalen > 232)) 1440 return -EIO; 1441 1442 memset(buf, 0, sizeof(buf)); 1443 1444 unitid = saa7164_i2caddr_to_unitid(bus, addr); 1445 if (unitid < 0) { 1446 printk(KERN_ERR 1447 "%s() error, cannot translate regaddr 0x%x to unitid\n", 1448 __func__, addr); 1449 return -EIO; 1450 } 1451 1452 reglen = saa7164_i2caddr_to_reglen(bus, addr); 1453 if (reglen < 0) { 1454 printk(KERN_ERR 1455 "%s() error, cannot translate regaddr to reglen\n", 1456 __func__); 1457 return -EIO; 1458 } 1459 1460 ret = saa7164_cmd_send(bus->dev, unitid, GET_LEN, 1461 EXU_REGISTER_ACCESS_CONTROL, sizeof(len), &len); 1462 if (ret != SAA_OK) { 1463 printk(KERN_ERR "%s() error, ret(1) = 0x%x\n", __func__, ret); 1464 return -EIO; 1465 } 1466 1467 dprintk(DBGLVL_API, "%s() len = %d bytes\n", __func__, len); 1468 1469 /* Prepare the send buffer */ 1470 /* Bytes 00-03 dest register length 1471 * 04-07 dest bytes to write 1472 * 08... register address 1473 */ 1474 *((u32 *)(buf + 0 * sizeof(u32))) = reglen; 1475 *((u32 *)(buf + 1 * sizeof(u32))) = datalen - reglen; 1476 memcpy((buf + 2 * sizeof(u32)), data, datalen); 1477 1478 if (saa_debug & DBGLVL_I2C) 1479 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 1, 1480 buf, sizeof(buf), false); 1481 1482 ret = saa7164_cmd_send(bus->dev, unitid, SET_CUR, 1483 EXU_REGISTER_ACCESS_CONTROL, len, &buf); 1484 if (ret != SAA_OK) 1485 printk(KERN_ERR "%s() error, ret(2) = 0x%x\n", __func__, ret); 1486 1487 return ret == SAA_OK ? 0 : -EIO; 1488 } 1489 1490 static int saa7164_api_modify_gpio(struct saa7164_dev *dev, u8 unitid, 1491 u8 pin, u8 state) 1492 { 1493 int ret; 1494 struct tmComResGPIO t; 1495 1496 dprintk(DBGLVL_API, "%s(0x%x, %d, %d)\n", 1497 __func__, unitid, pin, state); 1498 1499 if ((pin > 7) || (state > 2)) 1500 return SAA_ERR_BAD_PARAMETER; 1501 1502 t.pin = pin; 1503 t.state = state; 1504 1505 ret = saa7164_cmd_send(dev, unitid, SET_CUR, 1506 EXU_GPIO_CONTROL, sizeof(t), &t); 1507 if (ret != SAA_OK) 1508 printk(KERN_ERR "%s() error, ret = 0x%x\n", 1509 __func__, ret); 1510 1511 return ret; 1512 } 1513 1514 int saa7164_api_set_gpiobit(struct saa7164_dev *dev, u8 unitid, 1515 u8 pin) 1516 { 1517 return saa7164_api_modify_gpio(dev, unitid, pin, 1); 1518 } 1519 1520 int saa7164_api_clear_gpiobit(struct saa7164_dev *dev, u8 unitid, 1521 u8 pin) 1522 { 1523 return saa7164_api_modify_gpio(dev, unitid, pin, 0); 1524 } 1525 1526