1 /* 2 * Copyright (C) 2010 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 <linux/module.h> 28 29 #include <drm/drmP.h> 30 #include <drm/drm_encoder_slave.h> 31 #include <drm/drm_probe_helper.h> 32 #include <drm/i2c/sil164.h> 33 34 struct sil164_priv { 35 struct sil164_encoder_params config; 36 struct i2c_client *duallink_slave; 37 38 uint8_t saved_state[0x10]; 39 uint8_t saved_slave_state[0x10]; 40 }; 41 42 #define to_sil164_priv(x) \ 43 ((struct sil164_priv *)to_encoder_slave(x)->slave_priv) 44 45 #define sil164_dbg(client, format, ...) do { \ 46 if (drm_debug & DRM_UT_KMS) \ 47 dev_printk(KERN_DEBUG, &client->dev, \ 48 "%s: " format, __func__, ## __VA_ARGS__); \ 49 } while (0) 50 #define sil164_info(client, format, ...) \ 51 dev_info(&client->dev, format, __VA_ARGS__) 52 #define sil164_err(client, format, ...) \ 53 dev_err(&client->dev, format, __VA_ARGS__) 54 55 #define SIL164_I2C_ADDR_MASTER 0x38 56 #define SIL164_I2C_ADDR_SLAVE 0x39 57 58 /* HW register definitions */ 59 60 #define SIL164_VENDOR_LO 0x0 61 #define SIL164_VENDOR_HI 0x1 62 #define SIL164_DEVICE_LO 0x2 63 #define SIL164_DEVICE_HI 0x3 64 #define SIL164_REVISION 0x4 65 #define SIL164_FREQ_MIN 0x6 66 #define SIL164_FREQ_MAX 0x7 67 #define SIL164_CONTROL0 0x8 68 # define SIL164_CONTROL0_POWER_ON 0x01 69 # define SIL164_CONTROL0_EDGE_RISING 0x02 70 # define SIL164_CONTROL0_INPUT_24BIT 0x04 71 # define SIL164_CONTROL0_DUAL_EDGE 0x08 72 # define SIL164_CONTROL0_HSYNC_ON 0x10 73 # define SIL164_CONTROL0_VSYNC_ON 0x20 74 #define SIL164_DETECT 0x9 75 # define SIL164_DETECT_INTR_STAT 0x01 76 # define SIL164_DETECT_HOTPLUG_STAT 0x02 77 # define SIL164_DETECT_RECEIVER_STAT 0x04 78 # define SIL164_DETECT_INTR_MODE_RECEIVER 0x00 79 # define SIL164_DETECT_INTR_MODE_HOTPLUG 0x08 80 # define SIL164_DETECT_OUT_MODE_HIGH 0x00 81 # define SIL164_DETECT_OUT_MODE_INTR 0x10 82 # define SIL164_DETECT_OUT_MODE_RECEIVER 0x20 83 # define SIL164_DETECT_OUT_MODE_HOTPLUG 0x30 84 # define SIL164_DETECT_VSWING_STAT 0x80 85 #define SIL164_CONTROL1 0xa 86 # define SIL164_CONTROL1_DESKEW_ENABLE 0x10 87 # define SIL164_CONTROL1_DESKEW_INCR_SHIFT 5 88 #define SIL164_GPIO 0xb 89 #define SIL164_CONTROL2 0xc 90 # define SIL164_CONTROL2_FILTER_ENABLE 0x01 91 # define SIL164_CONTROL2_FILTER_SETTING_SHIFT 1 92 # define SIL164_CONTROL2_DUALLINK_MASTER 0x40 93 # define SIL164_CONTROL2_SYNC_CONT 0x80 94 #define SIL164_DUALLINK 0xd 95 # define SIL164_DUALLINK_ENABLE 0x10 96 # define SIL164_DUALLINK_SKEW_SHIFT 5 97 #define SIL164_PLLZONE 0xe 98 # define SIL164_PLLZONE_STAT 0x08 99 # define SIL164_PLLZONE_FORCE_ON 0x10 100 # define SIL164_PLLZONE_FORCE_HIGH 0x20 101 102 /* HW access functions */ 103 104 static void 105 sil164_write(struct i2c_client *client, uint8_t addr, uint8_t val) 106 { 107 uint8_t buf[] = {addr, val}; 108 int ret; 109 110 ret = i2c_master_send(client, buf, ARRAY_SIZE(buf)); 111 if (ret < 0) 112 sil164_err(client, "Error %d writing to subaddress 0x%x\n", 113 ret, addr); 114 } 115 116 static uint8_t 117 sil164_read(struct i2c_client *client, uint8_t addr) 118 { 119 uint8_t val; 120 int ret; 121 122 ret = i2c_master_send(client, &addr, sizeof(addr)); 123 if (ret < 0) 124 goto fail; 125 126 ret = i2c_master_recv(client, &val, sizeof(val)); 127 if (ret < 0) 128 goto fail; 129 130 return val; 131 132 fail: 133 sil164_err(client, "Error %d reading from subaddress 0x%x\n", 134 ret, addr); 135 return 0; 136 } 137 138 static void 139 sil164_save_state(struct i2c_client *client, uint8_t *state) 140 { 141 int i; 142 143 for (i = 0x8; i <= 0xe; i++) 144 state[i] = sil164_read(client, i); 145 } 146 147 static void 148 sil164_restore_state(struct i2c_client *client, uint8_t *state) 149 { 150 int i; 151 152 for (i = 0x8; i <= 0xe; i++) 153 sil164_write(client, i, state[i]); 154 } 155 156 static void 157 sil164_set_power_state(struct i2c_client *client, bool on) 158 { 159 uint8_t control0 = sil164_read(client, SIL164_CONTROL0); 160 161 if (on) 162 control0 |= SIL164_CONTROL0_POWER_ON; 163 else 164 control0 &= ~SIL164_CONTROL0_POWER_ON; 165 166 sil164_write(client, SIL164_CONTROL0, control0); 167 } 168 169 static void 170 sil164_init_state(struct i2c_client *client, 171 struct sil164_encoder_params *config, 172 bool duallink) 173 { 174 sil164_write(client, SIL164_CONTROL0, 175 SIL164_CONTROL0_HSYNC_ON | 176 SIL164_CONTROL0_VSYNC_ON | 177 (config->input_edge ? SIL164_CONTROL0_EDGE_RISING : 0) | 178 (config->input_width ? SIL164_CONTROL0_INPUT_24BIT : 0) | 179 (config->input_dual ? SIL164_CONTROL0_DUAL_EDGE : 0)); 180 181 sil164_write(client, SIL164_DETECT, 182 SIL164_DETECT_INTR_STAT | 183 SIL164_DETECT_OUT_MODE_RECEIVER); 184 185 sil164_write(client, SIL164_CONTROL1, 186 (config->input_skew ? SIL164_CONTROL1_DESKEW_ENABLE : 0) | 187 (((config->input_skew + 4) & 0x7) 188 << SIL164_CONTROL1_DESKEW_INCR_SHIFT)); 189 190 sil164_write(client, SIL164_CONTROL2, 191 SIL164_CONTROL2_SYNC_CONT | 192 (config->pll_filter ? 0 : SIL164_CONTROL2_FILTER_ENABLE) | 193 (4 << SIL164_CONTROL2_FILTER_SETTING_SHIFT)); 194 195 sil164_write(client, SIL164_PLLZONE, 0); 196 197 if (duallink) 198 sil164_write(client, SIL164_DUALLINK, 199 SIL164_DUALLINK_ENABLE | 200 (((config->duallink_skew + 4) & 0x7) 201 << SIL164_DUALLINK_SKEW_SHIFT)); 202 else 203 sil164_write(client, SIL164_DUALLINK, 0); 204 } 205 206 /* DRM encoder functions */ 207 208 static void 209 sil164_encoder_set_config(struct drm_encoder *encoder, void *params) 210 { 211 struct sil164_priv *priv = to_sil164_priv(encoder); 212 213 priv->config = *(struct sil164_encoder_params *)params; 214 } 215 216 static void 217 sil164_encoder_dpms(struct drm_encoder *encoder, int mode) 218 { 219 struct sil164_priv *priv = to_sil164_priv(encoder); 220 bool on = (mode == DRM_MODE_DPMS_ON); 221 bool duallink = (on && encoder->crtc->mode.clock > 165000); 222 223 sil164_set_power_state(drm_i2c_encoder_get_client(encoder), on); 224 225 if (priv->duallink_slave) 226 sil164_set_power_state(priv->duallink_slave, duallink); 227 } 228 229 static void 230 sil164_encoder_save(struct drm_encoder *encoder) 231 { 232 struct sil164_priv *priv = to_sil164_priv(encoder); 233 234 sil164_save_state(drm_i2c_encoder_get_client(encoder), 235 priv->saved_state); 236 237 if (priv->duallink_slave) 238 sil164_save_state(priv->duallink_slave, 239 priv->saved_slave_state); 240 } 241 242 static void 243 sil164_encoder_restore(struct drm_encoder *encoder) 244 { 245 struct sil164_priv *priv = to_sil164_priv(encoder); 246 247 sil164_restore_state(drm_i2c_encoder_get_client(encoder), 248 priv->saved_state); 249 250 if (priv->duallink_slave) 251 sil164_restore_state(priv->duallink_slave, 252 priv->saved_slave_state); 253 } 254 255 static int 256 sil164_encoder_mode_valid(struct drm_encoder *encoder, 257 struct drm_display_mode *mode) 258 { 259 struct sil164_priv *priv = to_sil164_priv(encoder); 260 261 if (mode->clock < 32000) 262 return MODE_CLOCK_LOW; 263 264 if (mode->clock > 330000 || 265 (mode->clock > 165000 && !priv->duallink_slave)) 266 return MODE_CLOCK_HIGH; 267 268 return MODE_OK; 269 } 270 271 static void 272 sil164_encoder_mode_set(struct drm_encoder *encoder, 273 struct drm_display_mode *mode, 274 struct drm_display_mode *adjusted_mode) 275 { 276 struct sil164_priv *priv = to_sil164_priv(encoder); 277 bool duallink = adjusted_mode->clock > 165000; 278 279 sil164_init_state(drm_i2c_encoder_get_client(encoder), 280 &priv->config, duallink); 281 282 if (priv->duallink_slave) 283 sil164_init_state(priv->duallink_slave, 284 &priv->config, duallink); 285 286 sil164_encoder_dpms(encoder, DRM_MODE_DPMS_ON); 287 } 288 289 static enum drm_connector_status 290 sil164_encoder_detect(struct drm_encoder *encoder, 291 struct drm_connector *connector) 292 { 293 struct i2c_client *client = drm_i2c_encoder_get_client(encoder); 294 295 if (sil164_read(client, SIL164_DETECT) & SIL164_DETECT_HOTPLUG_STAT) 296 return connector_status_connected; 297 else 298 return connector_status_disconnected; 299 } 300 301 static int 302 sil164_encoder_get_modes(struct drm_encoder *encoder, 303 struct drm_connector *connector) 304 { 305 return 0; 306 } 307 308 static int 309 sil164_encoder_create_resources(struct drm_encoder *encoder, 310 struct drm_connector *connector) 311 { 312 return 0; 313 } 314 315 static int 316 sil164_encoder_set_property(struct drm_encoder *encoder, 317 struct drm_connector *connector, 318 struct drm_property *property, 319 uint64_t val) 320 { 321 return 0; 322 } 323 324 static void 325 sil164_encoder_destroy(struct drm_encoder *encoder) 326 { 327 struct sil164_priv *priv = to_sil164_priv(encoder); 328 329 i2c_unregister_device(priv->duallink_slave); 330 331 kfree(priv); 332 drm_i2c_encoder_destroy(encoder); 333 } 334 335 static const struct drm_encoder_slave_funcs sil164_encoder_funcs = { 336 .set_config = sil164_encoder_set_config, 337 .destroy = sil164_encoder_destroy, 338 .dpms = sil164_encoder_dpms, 339 .save = sil164_encoder_save, 340 .restore = sil164_encoder_restore, 341 .mode_valid = sil164_encoder_mode_valid, 342 .mode_set = sil164_encoder_mode_set, 343 .detect = sil164_encoder_detect, 344 .get_modes = sil164_encoder_get_modes, 345 .create_resources = sil164_encoder_create_resources, 346 .set_property = sil164_encoder_set_property, 347 }; 348 349 /* I2C driver functions */ 350 351 static int 352 sil164_probe(struct i2c_client *client, const struct i2c_device_id *id) 353 { 354 int vendor = sil164_read(client, SIL164_VENDOR_HI) << 8 | 355 sil164_read(client, SIL164_VENDOR_LO); 356 int device = sil164_read(client, SIL164_DEVICE_HI) << 8 | 357 sil164_read(client, SIL164_DEVICE_LO); 358 int rev = sil164_read(client, SIL164_REVISION); 359 360 if (vendor != 0x1 || device != 0x6) { 361 sil164_dbg(client, "Unknown device %x:%x.%x\n", 362 vendor, device, rev); 363 return -ENODEV; 364 } 365 366 sil164_info(client, "Detected device %x:%x.%x\n", 367 vendor, device, rev); 368 369 return 0; 370 } 371 372 static int 373 sil164_remove(struct i2c_client *client) 374 { 375 return 0; 376 } 377 378 static struct i2c_client * 379 sil164_detect_slave(struct i2c_client *client) 380 { 381 struct i2c_adapter *adap = client->adapter; 382 struct i2c_msg msg = { 383 .addr = SIL164_I2C_ADDR_SLAVE, 384 .len = 0, 385 }; 386 const struct i2c_board_info info = { 387 I2C_BOARD_INFO("sil164", SIL164_I2C_ADDR_SLAVE) 388 }; 389 390 if (i2c_transfer(adap, &msg, 1) != 1) { 391 sil164_dbg(adap, "No dual-link slave found."); 392 return NULL; 393 } 394 395 return i2c_new_device(adap, &info); 396 } 397 398 static int 399 sil164_encoder_init(struct i2c_client *client, 400 struct drm_device *dev, 401 struct drm_encoder_slave *encoder) 402 { 403 struct sil164_priv *priv; 404 405 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 406 if (!priv) 407 return -ENOMEM; 408 409 encoder->slave_priv = priv; 410 encoder->slave_funcs = &sil164_encoder_funcs; 411 412 priv->duallink_slave = sil164_detect_slave(client); 413 414 return 0; 415 } 416 417 static const struct i2c_device_id sil164_ids[] = { 418 { "sil164", 0 }, 419 { } 420 }; 421 MODULE_DEVICE_TABLE(i2c, sil164_ids); 422 423 static struct drm_i2c_encoder_driver sil164_driver = { 424 .i2c_driver = { 425 .probe = sil164_probe, 426 .remove = sil164_remove, 427 .driver = { 428 .name = "sil164", 429 }, 430 .id_table = sil164_ids, 431 }, 432 .encoder_init = sil164_encoder_init, 433 }; 434 435 /* Module initialization */ 436 437 static int __init 438 sil164_init(void) 439 { 440 return drm_i2c_encoder_register(THIS_MODULE, &sil164_driver); 441 } 442 443 static void __exit 444 sil164_exit(void) 445 { 446 drm_i2c_encoder_unregister(&sil164_driver); 447 } 448 449 MODULE_AUTHOR("Francisco Jerez <currojerez@riseup.net>"); 450 MODULE_DESCRIPTION("Silicon Image sil164 TMDS transmitter driver"); 451 MODULE_LICENSE("GPL and additional rights"); 452 453 module_init(sil164_init); 454 module_exit(sil164_exit); 455