1 /* 2 * Copyright (C) 2012 Avionic Design GmbH 3 * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved. 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 as 7 * published by the Free Software Foundation. 8 */ 9 10 #include <linux/of_gpio.h> 11 12 #include <drm/drm_panel.h> 13 #include "drm.h" 14 15 static int tegra_connector_get_modes(struct drm_connector *connector) 16 { 17 struct tegra_output *output = connector_to_output(connector); 18 struct edid *edid = NULL; 19 int err = 0; 20 21 /* 22 * If the panel provides one or more modes, use them exclusively and 23 * ignore any other means of obtaining a mode. 24 */ 25 if (output->panel) { 26 err = output->panel->funcs->get_modes(output->panel); 27 if (err > 0) 28 return err; 29 } 30 31 if (output->edid) 32 edid = kmemdup(output->edid, sizeof(*edid), GFP_KERNEL); 33 else if (output->ddc) 34 edid = drm_get_edid(connector, output->ddc); 35 36 drm_mode_connector_update_edid_property(connector, edid); 37 38 if (edid) { 39 err = drm_add_edid_modes(connector, edid); 40 kfree(edid); 41 } 42 43 return err; 44 } 45 46 static int tegra_connector_mode_valid(struct drm_connector *connector, 47 struct drm_display_mode *mode) 48 { 49 struct tegra_output *output = connector_to_output(connector); 50 enum drm_mode_status status = MODE_OK; 51 int err; 52 53 err = tegra_output_check_mode(output, mode, &status); 54 if (err < 0) 55 return MODE_ERROR; 56 57 return status; 58 } 59 60 static struct drm_encoder * 61 tegra_connector_best_encoder(struct drm_connector *connector) 62 { 63 struct tegra_output *output = connector_to_output(connector); 64 65 return &output->encoder; 66 } 67 68 static const struct drm_connector_helper_funcs connector_helper_funcs = { 69 .get_modes = tegra_connector_get_modes, 70 .mode_valid = tegra_connector_mode_valid, 71 .best_encoder = tegra_connector_best_encoder, 72 }; 73 74 static enum drm_connector_status 75 tegra_connector_detect(struct drm_connector *connector, bool force) 76 { 77 struct tegra_output *output = connector_to_output(connector); 78 enum drm_connector_status status = connector_status_unknown; 79 80 if (output->ops->detect) 81 return output->ops->detect(output); 82 83 if (gpio_is_valid(output->hpd_gpio)) { 84 if (gpio_get_value(output->hpd_gpio) == 0) 85 status = connector_status_disconnected; 86 else 87 status = connector_status_connected; 88 } else { 89 if (!output->panel) 90 status = connector_status_disconnected; 91 else 92 status = connector_status_connected; 93 94 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS) 95 status = connector_status_connected; 96 } 97 98 return status; 99 } 100 101 static void drm_connector_clear(struct drm_connector *connector) 102 { 103 memset(connector, 0, sizeof(*connector)); 104 } 105 106 static void tegra_connector_destroy(struct drm_connector *connector) 107 { 108 drm_connector_unregister(connector); 109 drm_connector_cleanup(connector); 110 drm_connector_clear(connector); 111 } 112 113 static const struct drm_connector_funcs connector_funcs = { 114 .dpms = drm_helper_connector_dpms, 115 .detect = tegra_connector_detect, 116 .fill_modes = drm_helper_probe_single_connector_modes, 117 .destroy = tegra_connector_destroy, 118 }; 119 120 static void drm_encoder_clear(struct drm_encoder *encoder) 121 { 122 memset(encoder, 0, sizeof(*encoder)); 123 } 124 125 static void tegra_encoder_destroy(struct drm_encoder *encoder) 126 { 127 drm_encoder_cleanup(encoder); 128 drm_encoder_clear(encoder); 129 } 130 131 static const struct drm_encoder_funcs encoder_funcs = { 132 .destroy = tegra_encoder_destroy, 133 }; 134 135 static void tegra_encoder_dpms(struct drm_encoder *encoder, int mode) 136 { 137 struct tegra_output *output = encoder_to_output(encoder); 138 struct drm_panel *panel = output->panel; 139 140 if (mode != DRM_MODE_DPMS_ON) { 141 drm_panel_disable(panel); 142 tegra_output_disable(output); 143 drm_panel_unprepare(panel); 144 } else { 145 drm_panel_prepare(panel); 146 tegra_output_enable(output); 147 drm_panel_enable(panel); 148 } 149 } 150 151 static bool tegra_encoder_mode_fixup(struct drm_encoder *encoder, 152 const struct drm_display_mode *mode, 153 struct drm_display_mode *adjusted) 154 { 155 return true; 156 } 157 158 static void tegra_encoder_prepare(struct drm_encoder *encoder) 159 { 160 } 161 162 static void tegra_encoder_commit(struct drm_encoder *encoder) 163 { 164 } 165 166 static void tegra_encoder_mode_set(struct drm_encoder *encoder, 167 struct drm_display_mode *mode, 168 struct drm_display_mode *adjusted) 169 { 170 struct tegra_output *output = encoder_to_output(encoder); 171 int err; 172 173 err = tegra_output_enable(output); 174 if (err < 0) 175 dev_err(encoder->dev->dev, "tegra_output_enable(): %d\n", err); 176 } 177 178 static const struct drm_encoder_helper_funcs encoder_helper_funcs = { 179 .dpms = tegra_encoder_dpms, 180 .mode_fixup = tegra_encoder_mode_fixup, 181 .prepare = tegra_encoder_prepare, 182 .commit = tegra_encoder_commit, 183 .mode_set = tegra_encoder_mode_set, 184 }; 185 186 static irqreturn_t hpd_irq(int irq, void *data) 187 { 188 struct tegra_output *output = data; 189 190 drm_helper_hpd_irq_event(output->connector.dev); 191 192 return IRQ_HANDLED; 193 } 194 195 int tegra_output_probe(struct tegra_output *output) 196 { 197 struct device_node *ddc, *panel; 198 enum of_gpio_flags flags; 199 int err, size; 200 201 if (!output->of_node) 202 output->of_node = output->dev->of_node; 203 204 panel = of_parse_phandle(output->of_node, "nvidia,panel", 0); 205 if (panel) { 206 output->panel = of_drm_find_panel(panel); 207 if (!output->panel) 208 return -EPROBE_DEFER; 209 210 of_node_put(panel); 211 } 212 213 output->edid = of_get_property(output->of_node, "nvidia,edid", &size); 214 215 ddc = of_parse_phandle(output->of_node, "nvidia,ddc-i2c-bus", 0); 216 if (ddc) { 217 output->ddc = of_find_i2c_adapter_by_node(ddc); 218 if (!output->ddc) { 219 err = -EPROBE_DEFER; 220 of_node_put(ddc); 221 return err; 222 } 223 224 of_node_put(ddc); 225 } 226 227 output->hpd_gpio = of_get_named_gpio_flags(output->of_node, 228 "nvidia,hpd-gpio", 0, 229 &flags); 230 if (gpio_is_valid(output->hpd_gpio)) { 231 unsigned long flags; 232 233 err = gpio_request_one(output->hpd_gpio, GPIOF_DIR_IN, 234 "HDMI hotplug detect"); 235 if (err < 0) { 236 dev_err(output->dev, "gpio_request_one(): %d\n", err); 237 return err; 238 } 239 240 err = gpio_to_irq(output->hpd_gpio); 241 if (err < 0) { 242 dev_err(output->dev, "gpio_to_irq(): %d\n", err); 243 gpio_free(output->hpd_gpio); 244 return err; 245 } 246 247 output->hpd_irq = err; 248 249 flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | 250 IRQF_ONESHOT; 251 252 err = request_threaded_irq(output->hpd_irq, NULL, hpd_irq, 253 flags, "hpd", output); 254 if (err < 0) { 255 dev_err(output->dev, "failed to request IRQ#%u: %d\n", 256 output->hpd_irq, err); 257 gpio_free(output->hpd_gpio); 258 return err; 259 } 260 261 output->connector.polled = DRM_CONNECTOR_POLL_HPD; 262 } 263 264 return 0; 265 } 266 267 int tegra_output_remove(struct tegra_output *output) 268 { 269 if (gpio_is_valid(output->hpd_gpio)) { 270 free_irq(output->hpd_irq, output); 271 gpio_free(output->hpd_gpio); 272 } 273 274 if (output->ddc) 275 put_device(&output->ddc->dev); 276 277 return 0; 278 } 279 280 int tegra_output_init(struct drm_device *drm, struct tegra_output *output) 281 { 282 int connector, encoder; 283 284 switch (output->type) { 285 case TEGRA_OUTPUT_RGB: 286 connector = DRM_MODE_CONNECTOR_LVDS; 287 encoder = DRM_MODE_ENCODER_LVDS; 288 break; 289 290 case TEGRA_OUTPUT_HDMI: 291 connector = DRM_MODE_CONNECTOR_HDMIA; 292 encoder = DRM_MODE_ENCODER_TMDS; 293 break; 294 295 case TEGRA_OUTPUT_DSI: 296 connector = DRM_MODE_CONNECTOR_DSI; 297 encoder = DRM_MODE_ENCODER_DSI; 298 break; 299 300 case TEGRA_OUTPUT_EDP: 301 connector = DRM_MODE_CONNECTOR_eDP; 302 encoder = DRM_MODE_ENCODER_TMDS; 303 break; 304 305 default: 306 connector = DRM_MODE_CONNECTOR_Unknown; 307 encoder = DRM_MODE_ENCODER_NONE; 308 break; 309 } 310 311 drm_connector_init(drm, &output->connector, &connector_funcs, 312 connector); 313 drm_connector_helper_add(&output->connector, &connector_helper_funcs); 314 output->connector.dpms = DRM_MODE_DPMS_OFF; 315 316 if (output->panel) 317 drm_panel_attach(output->panel, &output->connector); 318 319 drm_encoder_init(drm, &output->encoder, &encoder_funcs, encoder); 320 drm_encoder_helper_add(&output->encoder, &encoder_helper_funcs); 321 322 drm_mode_connector_attach_encoder(&output->connector, &output->encoder); 323 drm_connector_register(&output->connector); 324 325 output->encoder.possible_crtcs = 0x3; 326 327 return 0; 328 } 329 330 int tegra_output_exit(struct tegra_output *output) 331 { 332 return 0; 333 } 334