Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 1 | /* |
Andrew F. Davis | bb5cdf8 | 2017-12-05 14:29:31 -0600 | [diff] [blame] | 2 | * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/ |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 3 | * Author: Rob Clark <rob@ti.com> |
| 4 | * |
| 5 | * This program is free software; you can redistribute it and/or modify it |
| 6 | * under the terms of the GNU General Public License version 2 as published by |
| 7 | * the Free Software Foundation. |
| 8 | * |
| 9 | * This program is distributed in the hope that it will be useful, but WITHOUT |
| 10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| 12 | * more details. |
| 13 | * |
| 14 | * You should have received a copy of the GNU General Public License along with |
| 15 | * this program. If not, see <http://www.gnu.org/licenses/>. |
| 16 | */ |
| 17 | |
Laurent Pinchart | 69a1226 | 2015-03-05 21:38:16 +0200 | [diff] [blame] | 18 | #include <drm/drm_atomic_helper.h> |
Laurent Pinchart | 2d278f5 | 2015-03-05 21:31:37 +0200 | [diff] [blame] | 19 | #include <drm/drm_crtc.h> |
| 20 | #include <drm/drm_crtc_helper.h> |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 21 | |
Laurent Pinchart | 2d278f5 | 2015-03-05 21:31:37 +0200 | [diff] [blame] | 22 | #include "omap_drv.h" |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 23 | |
| 24 | /* |
| 25 | * connector funcs |
| 26 | */ |
| 27 | |
| 28 | #define to_omap_connector(x) container_of(x, struct omap_connector, base) |
| 29 | |
| 30 | struct omap_connector { |
| 31 | struct drm_connector base; |
| 32 | struct omap_dss_device *dssdev; |
Tomi Valkeinen | 4f930c0 | 2014-06-18 14:19:48 +0300 | [diff] [blame] | 33 | bool hdmi_mode; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 34 | }; |
| 35 | |
Peter Ujfalusi | 3c59680 | 2017-06-02 15:26:35 +0300 | [diff] [blame] | 36 | static void omap_connector_hpd_cb(void *cb_data, |
| 37 | enum drm_connector_status status) |
| 38 | { |
| 39 | struct omap_connector *omap_connector = cb_data; |
| 40 | struct drm_connector *connector = &omap_connector->base; |
| 41 | struct drm_device *dev = connector->dev; |
| 42 | enum drm_connector_status old_status; |
| 43 | |
| 44 | mutex_lock(&dev->mode_config.mutex); |
| 45 | old_status = connector->status; |
| 46 | connector->status = status; |
| 47 | mutex_unlock(&dev->mode_config.mutex); |
| 48 | |
| 49 | if (old_status != status) |
| 50 | drm_kms_helper_hotplug_event(dev); |
| 51 | } |
| 52 | |
Tomi Valkeinen | 4f930c0 | 2014-06-18 14:19:48 +0300 | [diff] [blame] | 53 | bool omap_connector_get_hdmi_mode(struct drm_connector *connector) |
| 54 | { |
| 55 | struct omap_connector *omap_connector = to_omap_connector(connector); |
| 56 | |
| 57 | return omap_connector->hdmi_mode; |
| 58 | } |
| 59 | |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 60 | static struct omap_dss_device * |
| 61 | omap_connector_find_device(struct drm_connector *connector, |
| 62 | enum omap_dss_device_ops_flag op) |
| 63 | { |
| 64 | struct omap_connector *omap_connector = to_omap_connector(connector); |
| 65 | struct omap_dss_device *dssdev; |
| 66 | |
| 67 | for (dssdev = omap_connector->dssdev; dssdev; dssdev = dssdev->src) { |
| 68 | if (dssdev->ops_flags & op) |
| 69 | return dssdev; |
| 70 | } |
| 71 | |
| 72 | return NULL; |
| 73 | } |
| 74 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 75 | static enum drm_connector_status omap_connector_detect( |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 76 | struct drm_connector *connector, bool force) |
| 77 | { |
| 78 | struct omap_connector *omap_connector = to_omap_connector(connector); |
Laurent Pinchart | f2ea557 | 2018-05-28 16:49:36 +0300 | [diff] [blame] | 79 | struct omap_dss_device *dssdev; |
| 80 | enum drm_connector_status status; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 81 | |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 82 | dssdev = omap_connector_find_device(connector, |
| 83 | OMAP_DSS_DEVICE_OP_DETECT); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 84 | |
Laurent Pinchart | f2ea557 | 2018-05-28 16:49:36 +0300 | [diff] [blame] | 85 | if (dssdev) { |
| 86 | if (dssdev->ops->detect(dssdev)) |
| 87 | status = connector_status_connected; |
| 88 | else |
| 89 | status = connector_status_disconnected; |
| 90 | } else { |
| 91 | switch (omap_connector->dssdev->type) { |
| 92 | case OMAP_DISPLAY_TYPE_DPI: |
| 93 | case OMAP_DISPLAY_TYPE_DBI: |
| 94 | case OMAP_DISPLAY_TYPE_SDI: |
| 95 | case OMAP_DISPLAY_TYPE_DSI: |
| 96 | status = connector_status_connected; |
| 97 | break; |
| 98 | default: |
| 99 | status = connector_status_unknown; |
| 100 | break; |
| 101 | } |
| 102 | } |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 103 | |
Laurent Pinchart | f2ea557 | 2018-05-28 16:49:36 +0300 | [diff] [blame] | 104 | VERB("%s: %d (force=%d)", omap_connector->dssdev->name, status, force); |
| 105 | |
| 106 | return status; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | static void omap_connector_destroy(struct drm_connector *connector) |
| 110 | { |
| 111 | struct omap_connector *omap_connector = to_omap_connector(connector); |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 112 | struct omap_dss_device *dssdev; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 113 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 114 | DBG("%s", omap_connector->dssdev->name); |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 115 | |
| 116 | if (connector->polled == DRM_CONNECTOR_POLL_HPD) { |
| 117 | dssdev = omap_connector_find_device(connector, |
| 118 | OMAP_DSS_DEVICE_OP_HPD); |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 119 | dssdev->ops->unregister_hpd_cb(dssdev); |
Peter Ujfalusi | 3c59680 | 2017-06-02 15:26:35 +0300 | [diff] [blame] | 120 | } |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 121 | |
Thomas Wood | 34ea3d3 | 2014-05-29 16:57:41 +0100 | [diff] [blame] | 122 | drm_connector_unregister(connector); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 123 | drm_connector_cleanup(connector); |
| 124 | kfree(omap_connector); |
| 125 | |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 126 | omapdss_device_put(omap_connector->dssdev); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 127 | } |
| 128 | |
| 129 | #define MAX_EDID 512 |
| 130 | |
| 131 | static int omap_connector_get_modes(struct drm_connector *connector) |
| 132 | { |
| 133 | struct omap_connector *omap_connector = to_omap_connector(connector); |
| 134 | struct omap_dss_device *dssdev = omap_connector->dssdev; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 135 | struct drm_device *dev = connector->dev; |
| 136 | int n = 0; |
| 137 | |
| 138 | DBG("%s", omap_connector->dssdev->name); |
| 139 | |
| 140 | /* if display exposes EDID, then we parse that in the normal way to |
| 141 | * build table of supported modes.. otherwise (ie. fixed resolution |
| 142 | * LCD panels) we just return a single mode corresponding to the |
| 143 | * currently configured timings: |
| 144 | */ |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 145 | if (dssdev->ops->read_edid) { |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 146 | void *edid = kzalloc(MAX_EDID, GFP_KERNEL); |
| 147 | |
Tomi Valkeinen | 47aaaec | 2018-05-02 12:11:59 +0300 | [diff] [blame] | 148 | if (!edid) |
| 149 | return 0; |
| 150 | |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 151 | if ((dssdev->ops->read_edid(dssdev, edid, MAX_EDID) > 0) && |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 152 | drm_edid_is_valid(edid)) { |
Daniel Vetter | c555f02 | 2018-07-09 10:40:06 +0200 | [diff] [blame] | 153 | drm_connector_update_edid_property( |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 154 | connector, edid); |
| 155 | n = drm_add_edid_modes(connector, edid); |
Tomi Valkeinen | 4f930c0 | 2014-06-18 14:19:48 +0300 | [diff] [blame] | 156 | |
| 157 | omap_connector->hdmi_mode = |
| 158 | drm_detect_hdmi_monitor(edid); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 159 | } else { |
Daniel Vetter | c555f02 | 2018-07-09 10:40:06 +0200 | [diff] [blame] | 160 | drm_connector_update_edid_property( |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 161 | connector, NULL); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 162 | } |
Tomi Valkeinen | 4f930c0 | 2014-06-18 14:19:48 +0300 | [diff] [blame] | 163 | |
Jani Nikula | 451023d | 2012-08-15 09:32:39 +0000 | [diff] [blame] | 164 | kfree(edid); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 165 | } else { |
| 166 | struct drm_display_mode *mode = drm_mode_create(dev); |
Peter Ujfalusi | da11bbbb | 2016-09-22 14:07:04 +0300 | [diff] [blame] | 167 | struct videomode vm = {0}; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 168 | |
Tomi Valkeinen | 47aaaec | 2018-05-02 12:11:59 +0300 | [diff] [blame] | 169 | if (!mode) |
| 170 | return 0; |
| 171 | |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 172 | dssdev->ops->get_timings(dssdev, &vm); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 173 | |
Peter Ujfalusi | da11bbbb | 2016-09-22 14:07:04 +0300 | [diff] [blame] | 174 | drm_display_mode_from_videomode(&vm, mode); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 175 | |
| 176 | mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; |
| 177 | drm_mode_set_name(mode); |
| 178 | drm_mode_probed_add(connector, mode); |
| 179 | |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 180 | if (dssdev->driver && dssdev->driver->get_size) { |
| 181 | dssdev->driver->get_size(dssdev, |
Sebastian Reichel | b070d6e | 2017-07-24 19:33:04 +0200 | [diff] [blame] | 182 | &connector->display_info.width_mm, |
| 183 | &connector->display_info.height_mm); |
| 184 | } |
| 185 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 186 | n = 1; |
| 187 | } |
| 188 | |
| 189 | return n; |
| 190 | } |
| 191 | |
| 192 | static int omap_connector_mode_valid(struct drm_connector *connector, |
| 193 | struct drm_display_mode *mode) |
| 194 | { |
| 195 | struct omap_connector *omap_connector = to_omap_connector(connector); |
| 196 | struct omap_dss_device *dssdev = omap_connector->dssdev; |
Peter Ujfalusi | da11bbbb | 2016-09-22 14:07:04 +0300 | [diff] [blame] | 197 | struct videomode vm = {0}; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 198 | struct drm_device *dev = connector->dev; |
| 199 | struct drm_display_mode *new_mode; |
Archit Taneja | bddabbe | 2013-03-26 19:15:20 +0530 | [diff] [blame] | 200 | int r, ret = MODE_BAD; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 201 | |
Peter Ujfalusi | da11bbbb | 2016-09-22 14:07:04 +0300 | [diff] [blame] | 202 | drm_display_mode_to_videomode(mode, &vm); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 203 | mode->vrefresh = drm_mode_vrefresh(mode); |
| 204 | |
Archit Taneja | bddabbe | 2013-03-26 19:15:20 +0530 | [diff] [blame] | 205 | /* |
| 206 | * if the panel driver doesn't have a check_timings, it's most likely |
| 207 | * a fixed resolution panel, check if the timings match with the |
| 208 | * panel's timings |
| 209 | */ |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 210 | if (dssdev->ops->check_timings) { |
| 211 | r = dssdev->ops->check_timings(dssdev, &vm); |
Archit Taneja | bddabbe | 2013-03-26 19:15:20 +0530 | [diff] [blame] | 212 | } else { |
Peter Ujfalusi | 4520ff2 | 2016-09-22 14:07:03 +0300 | [diff] [blame] | 213 | struct videomode t = {0}; |
Archit Taneja | bddabbe | 2013-03-26 19:15:20 +0530 | [diff] [blame] | 214 | |
Laurent Pinchart | 83910ad | 2018-06-01 19:45:01 +0300 | [diff] [blame] | 215 | dssdev->ops->get_timings(dssdev, &t); |
Archit Taneja | bddabbe | 2013-03-26 19:15:20 +0530 | [diff] [blame] | 216 | |
Tomi Valkeinen | 50fa9f0 | 2016-11-23 13:24:00 +0200 | [diff] [blame] | 217 | /* |
| 218 | * Ignore the flags, as we don't get them from |
| 219 | * drm_display_mode_to_videomode. |
| 220 | */ |
| 221 | t.flags = 0; |
| 222 | |
Laurent Pinchart | d501b12 | 2016-12-12 11:57:24 +0200 | [diff] [blame] | 223 | if (memcmp(&vm, &t, sizeof(vm))) |
Archit Taneja | bddabbe | 2013-03-26 19:15:20 +0530 | [diff] [blame] | 224 | r = -EINVAL; |
| 225 | else |
| 226 | r = 0; |
| 227 | } |
| 228 | |
| 229 | if (!r) { |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 230 | /* check if vrefresh is still valid */ |
| 231 | new_mode = drm_mode_duplicate(dev, mode); |
Tomi Valkeinen | 47aaaec | 2018-05-02 12:11:59 +0300 | [diff] [blame] | 232 | |
| 233 | if (!new_mode) |
| 234 | return MODE_BAD; |
| 235 | |
Peter Ujfalusi | da11bbbb | 2016-09-22 14:07:04 +0300 | [diff] [blame] | 236 | new_mode->clock = vm.pixelclock / 1000; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 237 | new_mode->vrefresh = 0; |
| 238 | if (mode->vrefresh == drm_mode_vrefresh(new_mode)) |
| 239 | ret = MODE_OK; |
| 240 | drm_mode_destroy(dev, new_mode); |
| 241 | } |
| 242 | |
| 243 | DBG("connector: mode %s: " |
| 244 | "%d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x", |
| 245 | (ret == MODE_OK) ? "valid" : "invalid", |
| 246 | mode->base.id, mode->name, mode->vrefresh, mode->clock, |
| 247 | mode->hdisplay, mode->hsync_start, |
| 248 | mode->hsync_end, mode->htotal, |
| 249 | mode->vdisplay, mode->vsync_start, |
| 250 | mode->vsync_end, mode->vtotal, mode->type, mode->flags); |
| 251 | |
| 252 | return ret; |
| 253 | } |
| 254 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 255 | static const struct drm_connector_funcs omap_connector_funcs = { |
Laurent Pinchart | 69a1226 | 2015-03-05 21:38:16 +0200 | [diff] [blame] | 256 | .reset = drm_atomic_helper_connector_reset, |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 257 | .detect = omap_connector_detect, |
| 258 | .fill_modes = drm_helper_probe_single_connector_modes, |
| 259 | .destroy = omap_connector_destroy, |
Laurent Pinchart | 69a1226 | 2015-03-05 21:38:16 +0200 | [diff] [blame] | 260 | .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, |
| 261 | .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 262 | }; |
| 263 | |
| 264 | static const struct drm_connector_helper_funcs omap_connector_helper_funcs = { |
| 265 | .get_modes = omap_connector_get_modes, |
| 266 | .mode_valid = omap_connector_mode_valid, |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 267 | }; |
| 268 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 269 | /* initialize connector */ |
| 270 | struct drm_connector *omap_connector_init(struct drm_device *dev, |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 271 | int connector_type, struct omap_dss_device *dssdev, |
| 272 | struct drm_encoder *encoder) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 273 | { |
| 274 | struct drm_connector *connector = NULL; |
| 275 | struct omap_connector *omap_connector; |
| 276 | |
| 277 | DBG("%s", dssdev->name); |
| 278 | |
Laurent Pinchart | d501b12 | 2016-12-12 11:57:24 +0200 | [diff] [blame] | 279 | omap_connector = kzalloc(sizeof(*omap_connector), GFP_KERNEL); |
Joe Perches | 78110bb | 2013-02-11 09:41:29 -0800 | [diff] [blame] | 280 | if (!omap_connector) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 281 | goto fail; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 282 | |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 283 | omap_connector->dssdev = omapdss_device_get(dssdev); |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 284 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 285 | connector = &omap_connector->base; |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 286 | connector->interlace_allowed = 1; |
| 287 | connector->doublescan_allowed = 0; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 288 | |
| 289 | drm_connector_init(dev, connector, &omap_connector_funcs, |
| 290 | connector_type); |
| 291 | drm_connector_helper_add(connector, &omap_connector_helper_funcs); |
| 292 | |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 293 | /* |
| 294 | * Initialize connector status handling. First try to find a device that |
| 295 | * supports hot-plug reporting. If it fails, fall back to a device that |
| 296 | * support polling. If that fails too, we don't support hot-plug |
| 297 | * detection at all. |
| 298 | */ |
| 299 | dssdev = omap_connector_find_device(connector, OMAP_DSS_DEVICE_OP_HPD); |
| 300 | if (dssdev) { |
Laurent Pinchart | a21a8f3 | 2018-05-30 18:51:59 +0300 | [diff] [blame^] | 301 | dssdev->ops->register_hpd_cb(dssdev, omap_connector_hpd_cb, |
| 302 | omap_connector); |
| 303 | connector->polled = DRM_CONNECTOR_POLL_HPD; |
| 304 | } else { |
Laurent Pinchart | 949ea2e | 2018-05-30 18:49:48 +0300 | [diff] [blame] | 305 | dssdev = omap_connector_find_device(connector, |
| 306 | OMAP_DSS_DEVICE_OP_DETECT); |
| 307 | if (dssdev) |
| 308 | connector->polled = DRM_CONNECTOR_POLL_CONNECT | |
| 309 | DRM_CONNECTOR_POLL_DISCONNECT; |
| 310 | } |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 311 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 312 | return connector; |
| 313 | |
| 314 | fail: |
YAMANE Toshiaki | fdbf20b | 2012-11-14 19:28:54 +0900 | [diff] [blame] | 315 | if (connector) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 316 | omap_connector_destroy(connector); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 317 | |
| 318 | return NULL; |
| 319 | } |