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.h" 13 14 static int tegra_connector_get_modes(struct drm_connector *connector) 15 { 16 struct tegra_output *output = connector_to_output(connector); 17 struct edid *edid = NULL; 18 int err = 0; 19 20 if (output->edid) 21 edid = kmemdup(output->edid, sizeof(*edid), GFP_KERNEL); 22 else if (output->ddc) 23 edid = drm_get_edid(connector, output->ddc); 24 25 drm_mode_connector_update_edid_property(connector, edid); 26 27 if (edid) { 28 err = drm_add_edid_modes(connector, edid); 29 kfree(edid); 30 } 31 32 return err; 33 } 34 35 static int tegra_connector_mode_valid(struct drm_connector *connector, 36 struct drm_display_mode *mode) 37 { 38 struct tegra_output *output = connector_to_output(connector); 39 enum drm_mode_status status = MODE_OK; 40 int err; 41 42 err = tegra_output_check_mode(output, mode, &status); 43 if (err < 0) 44 return MODE_ERROR; 45 46 return status; 47 } 48 49 static struct drm_encoder * 50 tegra_connector_best_encoder(struct drm_connector *connector) 51 { 52 struct tegra_output *output = connector_to_output(connector); 53 54 return &output->encoder; 55 } 56 57 static const struct drm_connector_helper_funcs connector_helper_funcs = { 58 .get_modes = tegra_connector_get_modes, 59 .mode_valid = tegra_connector_mode_valid, 60 .best_encoder = tegra_connector_best_encoder, 61 }; 62 63 static enum drm_connector_status 64 tegra_connector_detect(struct drm_connector *connector, bool force) 65 { 66 struct tegra_output *output = connector_to_output(connector); 67 enum drm_connector_status status = connector_status_unknown; 68 69 if (gpio_is_valid(output->hpd_gpio)) { 70 if (gpio_get_value(output->hpd_gpio) == 0) 71 status = connector_status_disconnected; 72 else 73 status = connector_status_connected; 74 } else { 75 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS) 76 status = connector_status_connected; 77 } 78 79 return status; 80 } 81 82 static void drm_connector_clear(struct drm_connector *connector) 83 { 84 memset(connector, 0, sizeof(*connector)); 85 } 86 87 static void tegra_connector_destroy(struct drm_connector *connector) 88 { 89 drm_sysfs_connector_remove(connector); 90 drm_connector_cleanup(connector); 91 drm_connector_clear(connector); 92 } 93 94 static const struct drm_connector_funcs connector_funcs = { 95 .dpms = drm_helper_connector_dpms, 96 .detect = tegra_connector_detect, 97 .fill_modes = drm_helper_probe_single_connector_modes, 98 .destroy = tegra_connector_destroy, 99 }; 100 101 static void drm_encoder_clear(struct drm_encoder *encoder) 102 { 103 memset(encoder, 0, sizeof(*encoder)); 104 } 105 106 static void tegra_encoder_destroy(struct drm_encoder *encoder) 107 { 108 drm_encoder_cleanup(encoder); 109 drm_encoder_clear(encoder); 110 } 111 112 static const struct drm_encoder_funcs encoder_funcs = { 113 .destroy = tegra_encoder_destroy, 114 }; 115 116 static void tegra_encoder_dpms(struct drm_encoder *encoder, int mode) 117 { 118 } 119 120 static bool tegra_encoder_mode_fixup(struct drm_encoder *encoder, 121 const struct drm_display_mode *mode, 122 struct drm_display_mode *adjusted) 123 { 124 return true; 125 } 126 127 static void tegra_encoder_prepare(struct drm_encoder *encoder) 128 { 129 } 130 131 static void tegra_encoder_commit(struct drm_encoder *encoder) 132 { 133 } 134 135 static void tegra_encoder_mode_set(struct drm_encoder *encoder, 136 struct drm_display_mode *mode, 137 struct drm_display_mode *adjusted) 138 { 139 struct tegra_output *output = encoder_to_output(encoder); 140 int err; 141 142 err = tegra_output_enable(output); 143 if (err < 0) 144 dev_err(encoder->dev->dev, "tegra_output_enable(): %d\n", err); 145 } 146 147 static const struct drm_encoder_helper_funcs encoder_helper_funcs = { 148 .dpms = tegra_encoder_dpms, 149 .mode_fixup = tegra_encoder_mode_fixup, 150 .prepare = tegra_encoder_prepare, 151 .commit = tegra_encoder_commit, 152 .mode_set = tegra_encoder_mode_set, 153 }; 154 155 static irqreturn_t hpd_irq(int irq, void *data) 156 { 157 struct tegra_output *output = data; 158 159 drm_helper_hpd_irq_event(output->connector.dev); 160 161 return IRQ_HANDLED; 162 } 163 164 int tegra_output_probe(struct tegra_output *output) 165 { 166 enum of_gpio_flags flags; 167 struct device_node *ddc; 168 size_t size; 169 int err; 170 171 if (!output->of_node) 172 output->of_node = output->dev->of_node; 173 174 output->edid = of_get_property(output->of_node, "nvidia,edid", &size); 175 176 ddc = of_parse_phandle(output->of_node, "nvidia,ddc-i2c-bus", 0); 177 if (ddc) { 178 output->ddc = of_find_i2c_adapter_by_node(ddc); 179 if (!output->ddc) { 180 err = -EPROBE_DEFER; 181 of_node_put(ddc); 182 return err; 183 } 184 185 of_node_put(ddc); 186 } 187 188 if (!output->edid && !output->ddc) 189 return -ENODEV; 190 191 output->hpd_gpio = of_get_named_gpio_flags(output->of_node, 192 "nvidia,hpd-gpio", 0, 193 &flags); 194 if (gpio_is_valid(output->hpd_gpio)) { 195 unsigned long flags; 196 197 err = gpio_request_one(output->hpd_gpio, GPIOF_DIR_IN, 198 "HDMI hotplug detect"); 199 if (err < 0) { 200 dev_err(output->dev, "gpio_request_one(): %d\n", err); 201 return err; 202 } 203 204 err = gpio_to_irq(output->hpd_gpio); 205 if (err < 0) { 206 dev_err(output->dev, "gpio_to_irq(): %d\n", err); 207 gpio_free(output->hpd_gpio); 208 return err; 209 } 210 211 output->hpd_irq = err; 212 213 flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | 214 IRQF_ONESHOT; 215 216 err = request_threaded_irq(output->hpd_irq, NULL, hpd_irq, 217 flags, "hpd", output); 218 if (err < 0) { 219 dev_err(output->dev, "failed to request IRQ#%u: %d\n", 220 output->hpd_irq, err); 221 gpio_free(output->hpd_gpio); 222 return err; 223 } 224 225 output->connector.polled = DRM_CONNECTOR_POLL_HPD; 226 } 227 228 return 0; 229 } 230 231 int tegra_output_remove(struct tegra_output *output) 232 { 233 if (gpio_is_valid(output->hpd_gpio)) { 234 free_irq(output->hpd_irq, output); 235 gpio_free(output->hpd_gpio); 236 } 237 238 if (output->ddc) 239 put_device(&output->ddc->dev); 240 241 return 0; 242 } 243 244 int tegra_output_init(struct drm_device *drm, struct tegra_output *output) 245 { 246 int connector, encoder; 247 248 switch (output->type) { 249 case TEGRA_OUTPUT_RGB: 250 connector = DRM_MODE_CONNECTOR_LVDS; 251 encoder = DRM_MODE_ENCODER_LVDS; 252 break; 253 254 case TEGRA_OUTPUT_HDMI: 255 connector = DRM_MODE_CONNECTOR_HDMIA; 256 encoder = DRM_MODE_ENCODER_TMDS; 257 break; 258 259 default: 260 connector = DRM_MODE_CONNECTOR_Unknown; 261 encoder = DRM_MODE_ENCODER_NONE; 262 break; 263 } 264 265 drm_connector_init(drm, &output->connector, &connector_funcs, 266 connector); 267 drm_connector_helper_add(&output->connector, &connector_helper_funcs); 268 output->connector.dpms = DRM_MODE_DPMS_OFF; 269 270 drm_encoder_init(drm, &output->encoder, &encoder_funcs, encoder); 271 drm_encoder_helper_add(&output->encoder, &encoder_helper_funcs); 272 273 drm_mode_connector_attach_encoder(&output->connector, &output->encoder); 274 drm_sysfs_connector_add(&output->connector); 275 276 output->encoder.possible_crtcs = 0x3; 277 278 return 0; 279 } 280 281 int tegra_output_exit(struct tegra_output *output) 282 { 283 return 0; 284 } 285