1 /* 2 * Copyright (C) 2009 Francisco Jerez. 3 * All Rights Reserved. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining 6 * a copy of this software and associated documentation files (the 7 * "Software"), to deal in the Software without restriction, including 8 * without limitation the rights to use, copy, modify, merge, publish, 9 * distribute, sublicense, and/or sell copies of the Software, and to 10 * permit persons to whom the Software is furnished to do so, subject to 11 * the following conditions: 12 * 13 * The above copyright notice and this permission notice (including the 14 * next paragraph) shall be included in all copies or substantial 15 * portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 20 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE 21 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 22 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 23 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 24 * 25 */ 26 27 #include "ch7006_priv.h" 28 29 /* DRM encoder functions */ 30 31 static void ch7006_encoder_set_config(struct drm_encoder *encoder, 32 void *params) 33 { 34 struct ch7006_priv *priv = to_ch7006_priv(encoder); 35 36 priv->params = *(struct ch7006_encoder_params *)params; 37 } 38 39 static void ch7006_encoder_destroy(struct drm_encoder *encoder) 40 { 41 struct ch7006_priv *priv = to_ch7006_priv(encoder); 42 43 drm_property_destroy(encoder->dev, priv->scale_property); 44 45 kfree(priv); 46 to_encoder_slave(encoder)->slave_priv = NULL; 47 48 drm_i2c_encoder_destroy(encoder); 49 } 50 51 static void ch7006_encoder_dpms(struct drm_encoder *encoder, int mode) 52 { 53 struct i2c_client *client = drm_i2c_encoder_get_client(encoder); 54 struct ch7006_priv *priv = to_ch7006_priv(encoder); 55 struct ch7006_state *state = &priv->state; 56 57 ch7006_dbg(client, "\n"); 58 59 if (mode == priv->last_dpms) 60 return; 61 priv->last_dpms = mode; 62 63 ch7006_setup_power_state(encoder); 64 65 ch7006_load_reg(client, state, CH7006_POWER); 66 } 67 68 static void ch7006_encoder_save(struct drm_encoder *encoder) 69 { 70 struct i2c_client *client = drm_i2c_encoder_get_client(encoder); 71 struct ch7006_priv *priv = to_ch7006_priv(encoder); 72 73 ch7006_dbg(client, "\n"); 74 75 ch7006_state_save(client, &priv->saved_state); 76 } 77 78 static void ch7006_encoder_restore(struct drm_encoder *encoder) 79 { 80 struct i2c_client *client = drm_i2c_encoder_get_client(encoder); 81 struct ch7006_priv *priv = to_ch7006_priv(encoder); 82 83 ch7006_dbg(client, "\n"); 84 85 ch7006_state_load(client, &priv->saved_state); 86 } 87 88 static bool ch7006_encoder_mode_fixup(struct drm_encoder *encoder, 89 struct drm_display_mode *mode, 90 struct drm_display_mode *adjusted_mode) 91 { 92 struct ch7006_priv *priv = to_ch7006_priv(encoder); 93 94 /* The ch7006 is painfully picky with the input timings so no 95 * custom modes for now... */ 96 97 priv->mode = ch7006_lookup_mode(encoder, mode); 98 99 return !!priv->mode; 100 } 101 102 static int ch7006_encoder_mode_valid(struct drm_encoder *encoder, 103 struct drm_display_mode *mode) 104 { 105 if (ch7006_lookup_mode(encoder, mode)) 106 return MODE_OK; 107 else 108 return MODE_BAD; 109 } 110 111 static void ch7006_encoder_mode_set(struct drm_encoder *encoder, 112 struct drm_display_mode *drm_mode, 113 struct drm_display_mode *adjusted_mode) 114 { 115 struct i2c_client *client = drm_i2c_encoder_get_client(encoder); 116 struct ch7006_priv *priv = to_ch7006_priv(encoder); 117 struct ch7006_encoder_params *params = &priv->params; 118 struct ch7006_state *state = &priv->state; 119 uint8_t *regs = state->regs; 120 struct ch7006_mode *mode = priv->mode; 121 struct ch7006_tv_norm_info *norm = &ch7006_tv_norms[priv->norm]; 122 int start_active; 123 124 ch7006_dbg(client, "\n"); 125 126 regs[CH7006_DISPMODE] = norm->dispmode | mode->dispmode; 127 regs[CH7006_BWIDTH] = 0; 128 regs[CH7006_INPUT_FORMAT] = bitf(CH7006_INPUT_FORMAT_FORMAT, 129 params->input_format); 130 131 regs[CH7006_CLKMODE] = CH7006_CLKMODE_SUBC_LOCK 132 | bitf(CH7006_CLKMODE_XCM, params->xcm) 133 | bitf(CH7006_CLKMODE_PCM, params->pcm); 134 if (params->clock_mode) 135 regs[CH7006_CLKMODE] |= CH7006_CLKMODE_MASTER; 136 if (params->clock_edge) 137 regs[CH7006_CLKMODE] |= CH7006_CLKMODE_POS_EDGE; 138 139 start_active = (drm_mode->htotal & ~0x7) - (drm_mode->hsync_start & ~0x7); 140 regs[CH7006_POV] = bitf(CH7006_POV_START_ACTIVE_8, start_active); 141 regs[CH7006_START_ACTIVE] = bitf(CH7006_START_ACTIVE_0, start_active); 142 143 regs[CH7006_INPUT_SYNC] = 0; 144 if (params->sync_direction) 145 regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_OUTPUT; 146 if (params->sync_encoding) 147 regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_EMBEDDED; 148 if (drm_mode->flags & DRM_MODE_FLAG_PVSYNC) 149 regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_PVSYNC; 150 if (drm_mode->flags & DRM_MODE_FLAG_PHSYNC) 151 regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_PHSYNC; 152 153 regs[CH7006_DETECT] = 0; 154 regs[CH7006_BCLKOUT] = 0; 155 156 regs[CH7006_SUBC_INC3] = 0; 157 if (params->pout_level) 158 regs[CH7006_SUBC_INC3] |= CH7006_SUBC_INC3_POUT_3_3V; 159 160 regs[CH7006_SUBC_INC4] = 0; 161 if (params->active_detect) 162 regs[CH7006_SUBC_INC4] |= CH7006_SUBC_INC4_DS_INPUT; 163 164 regs[CH7006_PLL_CONTROL] = priv->saved_state.regs[CH7006_PLL_CONTROL]; 165 166 ch7006_setup_levels(encoder); 167 ch7006_setup_subcarrier(encoder); 168 ch7006_setup_pll(encoder); 169 ch7006_setup_power_state(encoder); 170 ch7006_setup_properties(encoder); 171 172 ch7006_state_load(client, state); 173 } 174 175 static enum drm_connector_status ch7006_encoder_detect(struct drm_encoder *encoder, 176 struct drm_connector *connector) 177 { 178 struct i2c_client *client = drm_i2c_encoder_get_client(encoder); 179 struct ch7006_priv *priv = to_ch7006_priv(encoder); 180 struct ch7006_state *state = &priv->state; 181 int det; 182 183 ch7006_dbg(client, "\n"); 184 185 ch7006_save_reg(client, state, CH7006_DETECT); 186 ch7006_save_reg(client, state, CH7006_POWER); 187 ch7006_save_reg(client, state, CH7006_CLKMODE); 188 189 ch7006_write(client, CH7006_POWER, CH7006_POWER_RESET | 190 bitfs(CH7006_POWER_LEVEL, NORMAL)); 191 ch7006_write(client, CH7006_CLKMODE, CH7006_CLKMODE_MASTER); 192 193 ch7006_write(client, CH7006_DETECT, CH7006_DETECT_SENSE); 194 195 ch7006_write(client, CH7006_DETECT, 0); 196 197 det = ch7006_read(client, CH7006_DETECT); 198 199 ch7006_load_reg(client, state, CH7006_CLKMODE); 200 ch7006_load_reg(client, state, CH7006_POWER); 201 ch7006_load_reg(client, state, CH7006_DETECT); 202 203 if ((det & (CH7006_DETECT_SVIDEO_Y_TEST| 204 CH7006_DETECT_SVIDEO_C_TEST| 205 CH7006_DETECT_CVBS_TEST)) == 0) 206 priv->subconnector = DRM_MODE_SUBCONNECTOR_SCART; 207 else if ((det & (CH7006_DETECT_SVIDEO_Y_TEST| 208 CH7006_DETECT_SVIDEO_C_TEST)) == 0) 209 priv->subconnector = DRM_MODE_SUBCONNECTOR_SVIDEO; 210 else if ((det & CH7006_DETECT_CVBS_TEST) == 0) 211 priv->subconnector = DRM_MODE_SUBCONNECTOR_Composite; 212 else 213 priv->subconnector = DRM_MODE_SUBCONNECTOR_Unknown; 214 215 drm_connector_property_set_value(connector, 216 encoder->dev->mode_config.tv_subconnector_property, 217 priv->subconnector); 218 219 return priv->subconnector ? connector_status_connected : 220 connector_status_disconnected; 221 } 222 223 static int ch7006_encoder_get_modes(struct drm_encoder *encoder, 224 struct drm_connector *connector) 225 { 226 struct ch7006_priv *priv = to_ch7006_priv(encoder); 227 struct ch7006_mode *mode; 228 int n = 0; 229 230 for (mode = ch7006_modes; mode->mode.clock; mode++) { 231 if (~mode->valid_scales & 1<<priv->scale || 232 ~mode->valid_norms & 1<<priv->norm) 233 continue; 234 235 drm_mode_probed_add(connector, 236 drm_mode_duplicate(encoder->dev, &mode->mode)); 237 238 n++; 239 } 240 241 return n; 242 } 243 244 static int ch7006_encoder_create_resources(struct drm_encoder *encoder, 245 struct drm_connector *connector) 246 { 247 struct ch7006_priv *priv = to_ch7006_priv(encoder); 248 struct drm_device *dev = encoder->dev; 249 struct drm_mode_config *conf = &dev->mode_config; 250 251 drm_mode_create_tv_properties(dev, NUM_TV_NORMS, ch7006_tv_norm_names); 252 253 priv->scale_property = drm_property_create(dev, DRM_MODE_PROP_RANGE, 254 "scale", 2); 255 priv->scale_property->values[0] = 0; 256 priv->scale_property->values[1] = 2; 257 258 drm_connector_attach_property(connector, conf->tv_select_subconnector_property, 259 priv->select_subconnector); 260 drm_connector_attach_property(connector, conf->tv_subconnector_property, 261 priv->subconnector); 262 drm_connector_attach_property(connector, conf->tv_left_margin_property, 263 priv->hmargin); 264 drm_connector_attach_property(connector, conf->tv_bottom_margin_property, 265 priv->vmargin); 266 drm_connector_attach_property(connector, conf->tv_mode_property, 267 priv->norm); 268 drm_connector_attach_property(connector, conf->tv_brightness_property, 269 priv->brightness); 270 drm_connector_attach_property(connector, conf->tv_contrast_property, 271 priv->contrast); 272 drm_connector_attach_property(connector, conf->tv_flicker_reduction_property, 273 priv->flicker); 274 drm_connector_attach_property(connector, priv->scale_property, 275 priv->scale); 276 277 return 0; 278 } 279 280 static int ch7006_encoder_set_property(struct drm_encoder *encoder, 281 struct drm_connector *connector, 282 struct drm_property *property, 283 uint64_t val) 284 { 285 struct i2c_client *client = drm_i2c_encoder_get_client(encoder); 286 struct ch7006_priv *priv = to_ch7006_priv(encoder); 287 struct ch7006_state *state = &priv->state; 288 struct drm_mode_config *conf = &encoder->dev->mode_config; 289 struct drm_crtc *crtc = encoder->crtc; 290 bool modes_changed = false; 291 292 ch7006_dbg(client, "\n"); 293 294 if (property == conf->tv_select_subconnector_property) { 295 priv->select_subconnector = val; 296 297 ch7006_setup_power_state(encoder); 298 299 ch7006_load_reg(client, state, CH7006_POWER); 300 301 } else if (property == conf->tv_left_margin_property) { 302 priv->hmargin = val; 303 304 ch7006_setup_properties(encoder); 305 306 ch7006_load_reg(client, state, CH7006_POV); 307 ch7006_load_reg(client, state, CH7006_HPOS); 308 309 } else if (property == conf->tv_bottom_margin_property) { 310 priv->vmargin = val; 311 312 ch7006_setup_properties(encoder); 313 314 ch7006_load_reg(client, state, CH7006_POV); 315 ch7006_load_reg(client, state, CH7006_VPOS); 316 317 } else if (property == conf->tv_mode_property) { 318 if (connector->dpms != DRM_MODE_DPMS_OFF) 319 return -EINVAL; 320 321 priv->norm = val; 322 323 modes_changed = true; 324 325 } else if (property == conf->tv_brightness_property) { 326 priv->brightness = val; 327 328 ch7006_setup_levels(encoder); 329 330 ch7006_load_reg(client, state, CH7006_BLACK_LEVEL); 331 332 } else if (property == conf->tv_contrast_property) { 333 priv->contrast = val; 334 335 ch7006_setup_properties(encoder); 336 337 ch7006_load_reg(client, state, CH7006_CONTRAST); 338 339 } else if (property == conf->tv_flicker_reduction_property) { 340 priv->flicker = val; 341 342 ch7006_setup_properties(encoder); 343 344 ch7006_load_reg(client, state, CH7006_FFILTER); 345 346 } else if (property == priv->scale_property) { 347 if (connector->dpms != DRM_MODE_DPMS_OFF) 348 return -EINVAL; 349 350 priv->scale = val; 351 352 modes_changed = true; 353 354 } else { 355 return -EINVAL; 356 } 357 358 if (modes_changed) { 359 drm_helper_probe_single_connector_modes(connector, 0, 0); 360 361 /* Disable the crtc to ensure a full modeset is 362 * performed whenever it's turned on again. */ 363 if (crtc) { 364 struct drm_mode_set modeset = { 365 .crtc = crtc, 366 }; 367 368 crtc->funcs->set_config(&modeset); 369 } 370 } 371 372 return 0; 373 } 374 375 static struct drm_encoder_slave_funcs ch7006_encoder_funcs = { 376 .set_config = ch7006_encoder_set_config, 377 .destroy = ch7006_encoder_destroy, 378 .dpms = ch7006_encoder_dpms, 379 .save = ch7006_encoder_save, 380 .restore = ch7006_encoder_restore, 381 .mode_fixup = ch7006_encoder_mode_fixup, 382 .mode_valid = ch7006_encoder_mode_valid, 383 .mode_set = ch7006_encoder_mode_set, 384 .detect = ch7006_encoder_detect, 385 .get_modes = ch7006_encoder_get_modes, 386 .create_resources = ch7006_encoder_create_resources, 387 .set_property = ch7006_encoder_set_property, 388 }; 389 390 391 /* I2C driver functions */ 392 393 static int ch7006_probe(struct i2c_client *client, const struct i2c_device_id *id) 394 { 395 uint8_t addr = CH7006_VERSION_ID; 396 uint8_t val; 397 int ret; 398 399 ch7006_dbg(client, "\n"); 400 401 ret = i2c_master_send(client, &addr, sizeof(addr)); 402 if (ret < 0) 403 goto fail; 404 405 ret = i2c_master_recv(client, &val, sizeof(val)); 406 if (ret < 0) 407 goto fail; 408 409 ch7006_info(client, "Detected version ID: %x\n", val); 410 411 /* I don't know what this is for, but otherwise I get no 412 * signal. 413 */ 414 ch7006_write(client, 0x3d, 0x0); 415 416 return 0; 417 418 fail: 419 ch7006_err(client, "Error %d reading version ID\n", ret); 420 421 return -ENODEV; 422 } 423 424 static int ch7006_remove(struct i2c_client *client) 425 { 426 ch7006_dbg(client, "\n"); 427 428 return 0; 429 } 430 431 static int ch7006_suspend(struct i2c_client *client, pm_message_t mesg) 432 { 433 ch7006_dbg(client, "\n"); 434 435 return 0; 436 } 437 438 static int ch7006_resume(struct i2c_client *client) 439 { 440 ch7006_dbg(client, "\n"); 441 442 ch7006_write(client, 0x3d, 0x0); 443 444 return 0; 445 } 446 447 static int ch7006_encoder_init(struct i2c_client *client, 448 struct drm_device *dev, 449 struct drm_encoder_slave *encoder) 450 { 451 struct ch7006_priv *priv; 452 int i; 453 454 ch7006_dbg(client, "\n"); 455 456 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 457 if (!priv) 458 return -ENOMEM; 459 460 encoder->slave_priv = priv; 461 encoder->slave_funcs = &ch7006_encoder_funcs; 462 463 priv->norm = TV_NORM_PAL; 464 priv->select_subconnector = DRM_MODE_SUBCONNECTOR_Automatic; 465 priv->subconnector = DRM_MODE_SUBCONNECTOR_Unknown; 466 priv->scale = 1; 467 priv->contrast = 50; 468 priv->brightness = 50; 469 priv->flicker = 50; 470 priv->hmargin = 50; 471 priv->vmargin = 50; 472 priv->last_dpms = -1; 473 priv->chip_version = ch7006_read(client, CH7006_VERSION_ID); 474 475 if (ch7006_tv_norm) { 476 for (i = 0; i < NUM_TV_NORMS; i++) { 477 if (!strcmp(ch7006_tv_norm_names[i], ch7006_tv_norm)) { 478 priv->norm = i; 479 break; 480 } 481 } 482 483 if (i == NUM_TV_NORMS) 484 ch7006_err(client, "Invalid TV norm setting \"%s\".\n", 485 ch7006_tv_norm); 486 } 487 488 if (ch7006_scale >= 0 && ch7006_scale <= 2) 489 priv->scale = ch7006_scale; 490 else 491 ch7006_err(client, "Invalid scale setting \"%d\".\n", 492 ch7006_scale); 493 494 return 0; 495 } 496 497 static struct i2c_device_id ch7006_ids[] = { 498 { "ch7006", 0 }, 499 { } 500 }; 501 MODULE_DEVICE_TABLE(i2c, ch7006_ids); 502 503 static struct drm_i2c_encoder_driver ch7006_driver = { 504 .i2c_driver = { 505 .probe = ch7006_probe, 506 .remove = ch7006_remove, 507 .suspend = ch7006_suspend, 508 .resume = ch7006_resume, 509 510 .driver = { 511 .name = "ch7006", 512 }, 513 514 .id_table = ch7006_ids, 515 }, 516 517 .encoder_init = ch7006_encoder_init, 518 }; 519 520 521 /* Module initialization */ 522 523 static int __init ch7006_init(void) 524 { 525 return drm_i2c_encoder_register(THIS_MODULE, &ch7006_driver); 526 } 527 528 static void __exit ch7006_exit(void) 529 { 530 drm_i2c_encoder_unregister(&ch7006_driver); 531 } 532 533 int ch7006_debug; 534 module_param_named(debug, ch7006_debug, int, 0600); 535 MODULE_PARM_DESC(debug, "Enable debug output."); 536 537 char *ch7006_tv_norm; 538 module_param_named(tv_norm, ch7006_tv_norm, charp, 0600); 539 MODULE_PARM_DESC(tv_norm, "Default TV norm.\n" 540 "\t\tSupported: PAL, PAL-M, PAL-N, PAL-Nc, PAL-60, NTSC-M, NTSC-J.\n" 541 "\t\tDefault: PAL"); 542 543 int ch7006_scale = 1; 544 module_param_named(scale, ch7006_scale, int, 0600); 545 MODULE_PARM_DESC(scale, "Default scale.\n" 546 "\t\tSupported: 0 -> Select video modes with a higher blanking ratio.\n" 547 "\t\t\t1 -> Select default video modes.\n" 548 "\t\t\t2 -> Select video modes with a lower blanking ratio."); 549 550 MODULE_AUTHOR("Francisco Jerez <currojerez@riseup.net>"); 551 MODULE_DESCRIPTION("Chrontel ch7006 TV encoder driver"); 552 MODULE_LICENSE("GPL and additional rights"); 553 554 module_init(ch7006_init); 555 module_exit(ch7006_exit); 556