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 | 2d278f5 | 2015-03-05 21:31:37 +0200 | [diff] [blame] | 18 | #include <linux/list.h> |
| 19 | |
| 20 | #include <drm/drm_crtc.h> |
Daniel Vetter | fcd70cd | 2019-01-17 22:03:34 +0100 | [diff] [blame] | 21 | #include <drm/drm_modeset_helper_vtables.h> |
Tomi Valkeinen | 4f930c0 | 2014-06-18 14:19:48 +0300 | [diff] [blame] | 22 | #include <drm/drm_edid.h> |
Laurent Pinchart | 30b7176 | 2018-12-07 23:08:35 +0200 | [diff] [blame^] | 23 | #include <drm/drm_panel.h> |
Tomi Valkeinen | 4f930c0 | 2014-06-18 14:19:48 +0300 | [diff] [blame] | 24 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 25 | #include "omap_drv.h" |
| 26 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 27 | /* |
| 28 | * encoder funcs |
| 29 | */ |
| 30 | |
| 31 | #define to_omap_encoder(x) container_of(x, struct omap_encoder, base) |
| 32 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 33 | /* The encoder and connector both map to same dssdev.. the encoder |
| 34 | * handles the 'active' parts, ie. anything the modifies the state |
| 35 | * of the hw, and the connector handles the 'read-only' parts, like |
| 36 | * detecting connection and reading edid. |
| 37 | */ |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 38 | struct omap_encoder { |
| 39 | struct drm_encoder base; |
Laurent Pinchart | d96aaad | 2018-05-31 23:14:43 +0300 | [diff] [blame] | 40 | struct omap_dss_device *output; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 41 | }; |
| 42 | |
| 43 | static void omap_encoder_destroy(struct drm_encoder *encoder) |
| 44 | { |
| 45 | struct omap_encoder *omap_encoder = to_omap_encoder(encoder); |
Archit Taneja | ec72a81 | 2014-01-02 14:49:53 +0530 | [diff] [blame] | 46 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 47 | drm_encoder_cleanup(encoder); |
| 48 | kfree(omap_encoder); |
| 49 | } |
| 50 | |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 51 | static const struct drm_encoder_funcs omap_encoder_funcs = { |
| 52 | .destroy = omap_encoder_destroy, |
| 53 | }; |
| 54 | |
Laurent Pinchart | 79107f2 | 2018-09-23 12:58:15 +0300 | [diff] [blame] | 55 | static void omap_encoder_update_videomode_flags(struct videomode *vm, |
| 56 | u32 bus_flags) |
| 57 | { |
| 58 | if (!(vm->flags & (DISPLAY_FLAGS_DE_LOW | |
| 59 | DISPLAY_FLAGS_DE_HIGH))) { |
| 60 | if (bus_flags & DRM_BUS_FLAG_DE_LOW) |
| 61 | vm->flags |= DISPLAY_FLAGS_DE_LOW; |
| 62 | else if (bus_flags & DRM_BUS_FLAG_DE_HIGH) |
| 63 | vm->flags |= DISPLAY_FLAGS_DE_HIGH; |
| 64 | } |
| 65 | |
| 66 | if (!(vm->flags & (DISPLAY_FLAGS_PIXDATA_POSEDGE | |
| 67 | DISPLAY_FLAGS_PIXDATA_NEGEDGE))) { |
| 68 | if (bus_flags & DRM_BUS_FLAG_PIXDATA_DRIVE_POSEDGE) |
| 69 | vm->flags |= DISPLAY_FLAGS_PIXDATA_POSEDGE; |
| 70 | else if (bus_flags & DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE) |
| 71 | vm->flags |= DISPLAY_FLAGS_PIXDATA_NEGEDGE; |
| 72 | } |
| 73 | |
| 74 | if (!(vm->flags & (DISPLAY_FLAGS_SYNC_POSEDGE | |
| 75 | DISPLAY_FLAGS_SYNC_NEGEDGE))) { |
| 76 | if (bus_flags & DRM_BUS_FLAG_SYNC_DRIVE_POSEDGE) |
| 77 | vm->flags |= DISPLAY_FLAGS_SYNC_POSEDGE; |
| 78 | else if (bus_flags & DRM_BUS_FLAG_SYNC_DRIVE_NEGEDGE) |
| 79 | vm->flags |= DISPLAY_FLAGS_SYNC_NEGEDGE; |
| 80 | } |
| 81 | } |
| 82 | |
Laurent Pinchart | 30b7176 | 2018-12-07 23:08:35 +0200 | [diff] [blame^] | 83 | static void omap_encoder_hdmi_mode_set(struct drm_connector *connector, |
| 84 | struct drm_encoder *encoder, |
Sebastian Reichel | 3c613a3 | 2018-11-21 17:09:14 +0100 | [diff] [blame] | 85 | struct drm_display_mode *adjusted_mode) |
| 86 | { |
Sebastian Reichel | 3c613a3 | 2018-11-21 17:09:14 +0100 | [diff] [blame] | 87 | struct omap_encoder *omap_encoder = to_omap_encoder(encoder); |
| 88 | struct omap_dss_device *dssdev = omap_encoder->output; |
Sebastian Reichel | 3c613a3 | 2018-11-21 17:09:14 +0100 | [diff] [blame] | 89 | bool hdmi_mode; |
| 90 | |
Laurent Pinchart | 30b7176 | 2018-12-07 23:08:35 +0200 | [diff] [blame^] | 91 | hdmi_mode = omap_connector_get_hdmi_mode(connector); |
Sebastian Reichel | 3c613a3 | 2018-11-21 17:09:14 +0100 | [diff] [blame] | 92 | |
| 93 | if (dssdev->ops->hdmi.set_hdmi_mode) |
| 94 | dssdev->ops->hdmi.set_hdmi_mode(dssdev, hdmi_mode); |
| 95 | |
| 96 | if (hdmi_mode && dssdev->ops->hdmi.set_infoframe) { |
| 97 | struct hdmi_avi_infoframe avi; |
| 98 | int r; |
| 99 | |
Maxime Ripard | 23d19ba | 2019-01-11 16:32:10 +0100 | [diff] [blame] | 100 | r = drm_hdmi_avi_infoframe_from_display_mode(&avi, connector, |
| 101 | adjusted_mode); |
Sebastian Reichel | 3c613a3 | 2018-11-21 17:09:14 +0100 | [diff] [blame] | 102 | if (r == 0) |
| 103 | dssdev->ops->hdmi.set_infoframe(dssdev, &avi); |
| 104 | } |
| 105 | } |
| 106 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 107 | static void omap_encoder_mode_set(struct drm_encoder *encoder, |
Laurent Pinchart | 3fbda31 | 2018-06-07 17:58:57 +0300 | [diff] [blame] | 108 | struct drm_display_mode *mode, |
| 109 | struct drm_display_mode *adjusted_mode) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 110 | { |
Tomi Valkeinen | 4f930c0 | 2014-06-18 14:19:48 +0300 | [diff] [blame] | 111 | struct omap_encoder *omap_encoder = to_omap_encoder(encoder); |
Laurent Pinchart | 79107f2 | 2018-09-23 12:58:15 +0300 | [diff] [blame] | 112 | struct omap_dss_device *output = omap_encoder->output; |
Laurent Pinchart | 3fbda31 | 2018-06-07 17:58:57 +0300 | [diff] [blame] | 113 | struct omap_dss_device *dssdev; |
Laurent Pinchart | 30b7176 | 2018-12-07 23:08:35 +0200 | [diff] [blame^] | 114 | struct drm_device *dev = encoder->dev; |
| 115 | struct drm_connector *connector; |
Laurent Pinchart | 79107f2 | 2018-09-23 12:58:15 +0300 | [diff] [blame] | 116 | struct drm_bridge *bridge; |
Laurent Pinchart | 3fbda31 | 2018-06-07 17:58:57 +0300 | [diff] [blame] | 117 | struct videomode vm = { 0 }; |
Laurent Pinchart | 30b7176 | 2018-12-07 23:08:35 +0200 | [diff] [blame^] | 118 | u32 bus_flags; |
| 119 | |
| 120 | list_for_each_entry(connector, &dev->mode_config.connector_list, head) { |
| 121 | if (connector->encoder == encoder) |
| 122 | break; |
| 123 | } |
Tomi Valkeinen | 4f930c0 | 2014-06-18 14:19:48 +0300 | [diff] [blame] | 124 | |
Laurent Pinchart | 3fbda31 | 2018-06-07 17:58:57 +0300 | [diff] [blame] | 125 | drm_display_mode_to_videomode(adjusted_mode, &vm); |
| 126 | |
| 127 | /* |
| 128 | * HACK: This fixes the vm flags. |
| 129 | * struct drm_display_mode does not contain the VSYNC/HSYNC/DE flags and |
| 130 | * they get lost when converting back and forth between struct |
| 131 | * drm_display_mode and struct videomode. The hack below goes and |
| 132 | * fetches the missing flags. |
| 133 | * |
| 134 | * A better solution is to use DRM's bus-flags through the whole driver. |
| 135 | */ |
Laurent Pinchart | 79107f2 | 2018-09-23 12:58:15 +0300 | [diff] [blame] | 136 | for (dssdev = output; dssdev; dssdev = dssdev->next) |
| 137 | omap_encoder_update_videomode_flags(&vm, dssdev->bus_flags); |
Laurent Pinchart | 3fbda31 | 2018-06-07 17:58:57 +0300 | [diff] [blame] | 138 | |
Laurent Pinchart | 79107f2 | 2018-09-23 12:58:15 +0300 | [diff] [blame] | 139 | for (bridge = output->bridge; bridge; bridge = bridge->next) { |
Laurent Pinchart | 79107f2 | 2018-09-23 12:58:15 +0300 | [diff] [blame] | 140 | if (!bridge->timings) |
| 141 | continue; |
Laurent Pinchart | 3fbda31 | 2018-06-07 17:58:57 +0300 | [diff] [blame] | 142 | |
Laurent Pinchart | 79107f2 | 2018-09-23 12:58:15 +0300 | [diff] [blame] | 143 | bus_flags = bridge->timings->input_bus_flags; |
| 144 | omap_encoder_update_videomode_flags(&vm, bus_flags); |
Laurent Pinchart | 3fbda31 | 2018-06-07 17:58:57 +0300 | [diff] [blame] | 145 | } |
| 146 | |
Laurent Pinchart | 30b7176 | 2018-12-07 23:08:35 +0200 | [diff] [blame^] | 147 | bus_flags = connector->display_info.bus_flags; |
| 148 | omap_encoder_update_videomode_flags(&vm, bus_flags); |
| 149 | |
Laurent Pinchart | 6ea48430 | 2018-06-07 19:55:04 +0300 | [diff] [blame] | 150 | /* Set timings for all devices in the display pipeline. */ |
Laurent Pinchart | 79107f2 | 2018-09-23 12:58:15 +0300 | [diff] [blame] | 151 | dss_mgr_set_timings(output, &vm); |
Laurent Pinchart | 3fbda31 | 2018-06-07 17:58:57 +0300 | [diff] [blame] | 152 | |
Laurent Pinchart | 79107f2 | 2018-09-23 12:58:15 +0300 | [diff] [blame] | 153 | for (dssdev = output; dssdev; dssdev = dssdev->next) { |
Laurent Pinchart | 6ea48430 | 2018-06-07 19:55:04 +0300 | [diff] [blame] | 154 | if (dssdev->ops->set_timings) |
Laurent Pinchart | 41322aa | 2018-09-21 17:00:29 +0300 | [diff] [blame] | 155 | dssdev->ops->set_timings(dssdev, adjusted_mode); |
Laurent Pinchart | 6ea48430 | 2018-06-07 19:55:04 +0300 | [diff] [blame] | 156 | } |
| 157 | |
| 158 | /* Set the HDMI mode and HDMI infoframe if applicable. */ |
Laurent Pinchart | 79107f2 | 2018-09-23 12:58:15 +0300 | [diff] [blame] | 159 | if (output->type == OMAP_DISPLAY_TYPE_HDMI) |
Laurent Pinchart | 30b7176 | 2018-12-07 23:08:35 +0200 | [diff] [blame^] | 160 | omap_encoder_hdmi_mode_set(connector, encoder, adjusted_mode); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 161 | } |
| 162 | |
Laurent Pinchart | 68dc039 | 2015-03-07 00:22:39 +0200 | [diff] [blame] | 163 | static void omap_encoder_disable(struct drm_encoder *encoder) |
| 164 | { |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 165 | struct omap_encoder *omap_encoder = to_omap_encoder(encoder); |
Laurent Pinchart | 19b4200 | 2018-08-24 19:38:07 +0300 | [diff] [blame] | 166 | struct omap_dss_device *dssdev = omap_encoder->output; |
Laurent Pinchart | b80bfc6 | 2018-09-04 17:22:27 +0300 | [diff] [blame] | 167 | struct drm_device *dev = encoder->dev; |
| 168 | |
| 169 | dev_dbg(dev->dev, "disable(%s)\n", dssdev->name); |
| 170 | |
Laurent Pinchart | 30b7176 | 2018-12-07 23:08:35 +0200 | [diff] [blame^] | 171 | /* Disable the panel if present. */ |
| 172 | if (dssdev->panel) { |
| 173 | drm_panel_disable(dssdev->panel); |
| 174 | drm_panel_unprepare(dssdev->panel); |
| 175 | } |
| 176 | |
Laurent Pinchart | 19b4200 | 2018-08-24 19:38:07 +0300 | [diff] [blame] | 177 | /* |
| 178 | * Disable the chain of external devices, starting at the one at the |
| 179 | * internal encoder's output. |
| 180 | */ |
| 181 | omapdss_device_disable(dssdev->next); |
Laurent Pinchart | b80bfc6 | 2018-09-04 17:22:27 +0300 | [diff] [blame] | 182 | |
Laurent Pinchart | 19b4200 | 2018-08-24 19:38:07 +0300 | [diff] [blame] | 183 | /* |
| 184 | * Disable the internal encoder. This will disable the DSS output. The |
| 185 | * DSI is treated as an exception as DSI pipelines still use the legacy |
| 186 | * flow where the pipeline output controls the encoder. |
| 187 | */ |
Laurent Pinchart | 0dbfc39 | 2018-12-10 14:00:38 +0200 | [diff] [blame] | 188 | if (dssdev->type != OMAP_DISPLAY_TYPE_DSI) { |
Laurent Pinchart | 19b4200 | 2018-08-24 19:38:07 +0300 | [diff] [blame] | 189 | dssdev->ops->disable(dssdev); |
| 190 | dssdev->state = OMAP_DSS_DISPLAY_DISABLED; |
| 191 | } |
| 192 | |
| 193 | /* |
| 194 | * Perform the post-disable operations on the chain of external devices |
| 195 | * to complete the display pipeline disable. |
| 196 | */ |
| 197 | omapdss_device_post_disable(dssdev->next); |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 198 | } |
| 199 | |
Laurent Pinchart | 4029755e | 2015-05-28 02:34:05 +0300 | [diff] [blame] | 200 | static void omap_encoder_enable(struct drm_encoder *encoder) |
| 201 | { |
| 202 | struct omap_encoder *omap_encoder = to_omap_encoder(encoder); |
Laurent Pinchart | 19b4200 | 2018-08-24 19:38:07 +0300 | [diff] [blame] | 203 | struct omap_dss_device *dssdev = omap_encoder->output; |
Laurent Pinchart | b80bfc6 | 2018-09-04 17:22:27 +0300 | [diff] [blame] | 204 | struct drm_device *dev = encoder->dev; |
Laurent Pinchart | 4029755e | 2015-05-28 02:34:05 +0300 | [diff] [blame] | 205 | |
Laurent Pinchart | b80bfc6 | 2018-09-04 17:22:27 +0300 | [diff] [blame] | 206 | dev_dbg(dev->dev, "enable(%s)\n", dssdev->name); |
| 207 | |
Laurent Pinchart | 19b4200 | 2018-08-24 19:38:07 +0300 | [diff] [blame] | 208 | /* Prepare the chain of external devices for pipeline enable. */ |
| 209 | omapdss_device_pre_enable(dssdev->next); |
| 210 | |
| 211 | /* |
| 212 | * Enable the internal encoder. This will enable the DSS output. The |
| 213 | * DSI is treated as an exception as DSI pipelines still use the legacy |
| 214 | * flow where the pipeline output controls the encoder. |
| 215 | */ |
Laurent Pinchart | 0dbfc39 | 2018-12-10 14:00:38 +0200 | [diff] [blame] | 216 | if (dssdev->type != OMAP_DISPLAY_TYPE_DSI) { |
Laurent Pinchart | 19b4200 | 2018-08-24 19:38:07 +0300 | [diff] [blame] | 217 | dssdev->ops->enable(dssdev); |
| 218 | dssdev->state = OMAP_DSS_DISPLAY_ACTIVE; |
Laurent Pinchart | b49a213 | 2018-09-04 23:53:34 +0300 | [diff] [blame] | 219 | } |
Laurent Pinchart | b80bfc6 | 2018-09-04 17:22:27 +0300 | [diff] [blame] | 220 | |
Laurent Pinchart | 19b4200 | 2018-08-24 19:38:07 +0300 | [diff] [blame] | 221 | /* |
| 222 | * Enable the chain of external devices, starting at the one at the |
| 223 | * internal encoder's output. |
| 224 | */ |
| 225 | omapdss_device_enable(dssdev->next); |
Laurent Pinchart | 30b7176 | 2018-12-07 23:08:35 +0200 | [diff] [blame^] | 226 | |
| 227 | /* Enable the panel if present. */ |
| 228 | if (dssdev->panel) { |
| 229 | drm_panel_prepare(dssdev->panel); |
| 230 | drm_panel_enable(dssdev->panel); |
| 231 | } |
Laurent Pinchart | 4029755e | 2015-05-28 02:34:05 +0300 | [diff] [blame] | 232 | } |
| 233 | |
| 234 | static int omap_encoder_atomic_check(struct drm_encoder *encoder, |
| 235 | struct drm_crtc_state *crtc_state, |
| 236 | struct drm_connector_state *conn_state) |
| 237 | { |
Laurent Pinchart | 3fbda31 | 2018-06-07 17:58:57 +0300 | [diff] [blame] | 238 | struct omap_encoder *omap_encoder = to_omap_encoder(encoder); |
Laurent Pinchart | d68164f | 2018-09-21 16:13:00 +0300 | [diff] [blame] | 239 | enum drm_mode_status status; |
Laurent Pinchart | 3fbda31 | 2018-06-07 17:58:57 +0300 | [diff] [blame] | 240 | |
Laurent Pinchart | d68164f | 2018-09-21 16:13:00 +0300 | [diff] [blame] | 241 | status = omap_connector_mode_fixup(omap_encoder->output, |
| 242 | &crtc_state->mode, |
| 243 | &crtc_state->adjusted_mode); |
| 244 | if (status != MODE_OK) { |
| 245 | dev_err(encoder->dev->dev, "invalid timings: %d\n", status); |
| 246 | return -EINVAL; |
Laurent Pinchart | 3fbda31 | 2018-06-07 17:58:57 +0300 | [diff] [blame] | 247 | } |
| 248 | |
Laurent Pinchart | d68164f | 2018-09-21 16:13:00 +0300 | [diff] [blame] | 249 | return 0; |
Laurent Pinchart | 4029755e | 2015-05-28 02:34:05 +0300 | [diff] [blame] | 250 | } |
| 251 | |
| 252 | static const struct drm_encoder_helper_funcs omap_encoder_helper_funcs = { |
| 253 | .mode_set = omap_encoder_mode_set, |
| 254 | .disable = omap_encoder_disable, |
| 255 | .enable = omap_encoder_enable, |
| 256 | .atomic_check = omap_encoder_atomic_check, |
| 257 | }; |
| 258 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 259 | /* initialize encoder */ |
| 260 | struct drm_encoder *omap_encoder_init(struct drm_device *dev, |
Laurent Pinchart | 79d11e9 | 2018-09-13 02:23:26 +0300 | [diff] [blame] | 261 | struct omap_dss_device *output) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 262 | { |
| 263 | struct drm_encoder *encoder = NULL; |
| 264 | struct omap_encoder *omap_encoder; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 265 | |
| 266 | omap_encoder = kzalloc(sizeof(*omap_encoder), GFP_KERNEL); |
Joe Perches | 78110bb | 2013-02-11 09:41:29 -0800 | [diff] [blame] | 267 | if (!omap_encoder) |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 268 | goto fail; |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 269 | |
Laurent Pinchart | d96aaad | 2018-05-31 23:14:43 +0300 | [diff] [blame] | 270 | omap_encoder->output = output; |
Rob Clark | f5f9454 | 2012-12-04 13:59:12 -0600 | [diff] [blame] | 271 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 272 | encoder = &omap_encoder->base; |
| 273 | |
| 274 | drm_encoder_init(dev, encoder, &omap_encoder_funcs, |
Ville Syrjälä | 13a3d91 | 2015-12-09 16:20:18 +0200 | [diff] [blame] | 275 | DRM_MODE_ENCODER_TMDS, NULL); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 276 | drm_encoder_helper_add(encoder, &omap_encoder_helper_funcs); |
| 277 | |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 278 | return encoder; |
| 279 | |
| 280 | fail: |
YAMANE Toshiaki | 582bc28 | 2012-11-14 19:31:27 +0900 | [diff] [blame] | 281 | if (encoder) |
Rob Clark | 65b0bd0 | 2011-12-09 23:26:07 -0600 | [diff] [blame] | 282 | omap_encoder_destroy(encoder); |
Rob Clark | cd5351f | 2011-11-12 12:09:40 -0600 | [diff] [blame] | 283 | |
| 284 | return NULL; |
| 285 | } |