Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2014 NVIDIA Corporation
4 */
5
6#include <linux/delay.h>
7#include <linux/gpio/consumer.h>
8#include <linux/module.h>
9#include <linux/of.h>
10#include <linux/regulator/consumer.h>
11
12#include <video/mipi_display.h>
13
14#include <drm/drm_crtc.h>
15#include <drm/drm_device.h>
16#include <drm/drm_mipi_dsi.h>
17#include <drm/drm_panel.h>
18
19struct sharp_panel {
20 struct drm_panel base;
21 /* the datasheet refers to them as DSI-LINK1 and DSI-LINK2 */
22 struct mipi_dsi_device *link1;
23 struct mipi_dsi_device *link2;
24
25 struct regulator *supply;
26
27 const struct drm_display_mode *mode;
28};
29
30static inline struct sharp_panel *to_sharp_panel(struct drm_panel *panel)
31{
32 return container_of(panel, struct sharp_panel, base);
33}
34
35static void sharp_wait_frames(struct sharp_panel *sharp, unsigned int frames)
36{
37 unsigned int refresh = drm_mode_vrefresh(sharp->mode);
38
39 if (WARN_ON(frames > refresh))
40 return;
41
42 msleep(1000 / (refresh / frames));
43}
44
45static int sharp_panel_write(struct sharp_panel *sharp, u16 offset, u8 value)
46{
47 u8 payload[3] = { offset >> 8, offset & 0xff, value };
48 struct mipi_dsi_device *dsi = sharp->link1;
49 ssize_t err;
50
51 err = mipi_dsi_generic_write(dsi, payload, sizeof(payload));
52 if (err < 0) {
53 dev_err(&dsi->dev, "failed to write %02x to %04x: %zd\n",
54 value, offset, err);
55 return err;
56 }
57
58 err = mipi_dsi_dcs_nop(dsi);
59 if (err < 0) {
60 dev_err(&dsi->dev, "failed to send DCS nop: %zd\n", err);
61 return err;
62 }
63
64 usleep_range(10, 20);
65
66 return 0;
67}
68
69static __maybe_unused int sharp_panel_read(struct sharp_panel *sharp,
70 u16 offset, u8 *value)
71{
72 ssize_t err;
73
74 cpu_to_be16s(&offset);
75
76 err = mipi_dsi_generic_read(sharp->link1, &offset, sizeof(offset),
77 value, sizeof(*value));
78 if (err < 0)
79 dev_err(&sharp->link1->dev, "failed to read from %04x: %zd\n",
80 offset, err);
81
82 return err;
83}
84
85static int sharp_panel_unprepare(struct drm_panel *panel)
86{
87 struct sharp_panel *sharp = to_sharp_panel(panel);
88 int err;
89
90 sharp_wait_frames(sharp, 4);
91
92 err = mipi_dsi_dcs_set_display_off(sharp->link1);
93 if (err < 0)
94 dev_err(panel->dev, "failed to set display off: %d\n", err);
95
96 err = mipi_dsi_dcs_enter_sleep_mode(sharp->link1);
97 if (err < 0)
98 dev_err(panel->dev, "failed to enter sleep mode: %d\n", err);
99
100 msleep(120);
101
102 regulator_disable(sharp->supply);
103
104 return 0;
105}
106
107static int sharp_setup_symmetrical_split(struct mipi_dsi_device *left,
108 struct mipi_dsi_device *right,
109 const struct drm_display_mode *mode)
110{
111 int err;
112
113 err = mipi_dsi_dcs_set_column_address(left, 0, mode->hdisplay / 2 - 1);
114 if (err < 0) {
115 dev_err(&left->dev, "failed to set column address: %d\n", err);
116 return err;
117 }
118
119 err = mipi_dsi_dcs_set_page_address(left, 0, mode->vdisplay - 1);
120 if (err < 0) {
121 dev_err(&left->dev, "failed to set page address: %d\n", err);
122 return err;
123 }
124
125 err = mipi_dsi_dcs_set_column_address(right, mode->hdisplay / 2,
126 mode->hdisplay - 1);
127 if (err < 0) {
128 dev_err(&right->dev, "failed to set column address: %d\n", err);
129 return err;
130 }
131
132 err = mipi_dsi_dcs_set_page_address(right, 0, mode->vdisplay - 1);
133 if (err < 0) {
134 dev_err(&right->dev, "failed to set page address: %d\n", err);
135 return err;
136 }
137
138 return 0;
139}
140
141static int sharp_panel_prepare(struct drm_panel *panel)
142{
143 struct sharp_panel *sharp = to_sharp_panel(panel);
144 u8 format = MIPI_DCS_PIXEL_FMT_24BIT;
145 int err;
146
147 err = regulator_enable(sharp->supply);
148 if (err < 0)
149 return err;
150
151 /*
152 * According to the datasheet, the panel needs around 10 ms to fully
153 * power up. At least another 120 ms is required before exiting sleep
154 * mode to make sure the panel is ready. Throw in another 20 ms for
155 * good measure.
156 */
157 msleep(150);
158
159 err = mipi_dsi_dcs_exit_sleep_mode(sharp->link1);
160 if (err < 0) {
161 dev_err(panel->dev, "failed to exit sleep mode: %d\n", err);
162 goto poweroff;
163 }
164
165 /*
166 * The MIPI DCS specification mandates this delay only between the
167 * exit_sleep_mode and enter_sleep_mode commands, so it isn't strictly
168 * necessary here.
169 */
170 /*
171 msleep(120);
172 */
173
174 /* set left-right mode */
175 err = sharp_panel_write(sharp, 0x1000, 0x2a);
176 if (err < 0) {
177 dev_err(panel->dev, "failed to set left-right mode: %d\n", err);
178 goto poweroff;
179 }
180
181 /* enable command mode */
182 err = sharp_panel_write(sharp, 0x1001, 0x01);
183 if (err < 0) {
184 dev_err(panel->dev, "failed to enable command mode: %d\n", err);
185 goto poweroff;
186 }
187
188 err = mipi_dsi_dcs_set_pixel_format(sharp->link1, format);
189 if (err < 0) {
190 dev_err(panel->dev, "failed to set pixel format: %d\n", err);
191 goto poweroff;
192 }
193
194 /*
195 * TODO: The device supports both left-right and even-odd split
196 * configurations, but this driver currently supports only the left-
197 * right split. To support a different mode a mechanism needs to be
198 * put in place to communicate the configuration back to the DSI host
199 * controller.
200 */
201 err = sharp_setup_symmetrical_split(sharp->link1, sharp->link2,
202 sharp->mode);
203 if (err < 0) {
204 dev_err(panel->dev, "failed to set up symmetrical split: %d\n",
205 err);
206 goto poweroff;
207 }
208
209 err = mipi_dsi_dcs_set_display_on(sharp->link1);
210 if (err < 0) {
211 dev_err(panel->dev, "failed to set display on: %d\n", err);
212 goto poweroff;
213 }
214
215 /* wait for 6 frames before continuing */
216 sharp_wait_frames(sharp, 6);
217
218 return 0;
219
220poweroff:
221 regulator_disable(sharp->supply);
222 return err;
223}
224
225static const struct drm_display_mode default_mode = {
226 .clock = 278000,
227 .hdisplay = 2560,
228 .hsync_start = 2560 + 128,
229 .hsync_end = 2560 + 128 + 64,
230 .htotal = 2560 + 128 + 64 + 64,
231 .vdisplay = 1600,
232 .vsync_start = 1600 + 4,
233 .vsync_end = 1600 + 4 + 8,
234 .vtotal = 1600 + 4 + 8 + 32,
235};
236
237static int sharp_panel_get_modes(struct drm_panel *panel,
238 struct drm_connector *connector)
239{
240 struct drm_display_mode *mode;
241
242 mode = drm_mode_duplicate(connector->dev, &default_mode);
243 if (!mode) {
244 dev_err(panel->dev, "failed to add mode %ux%ux@%u\n",
245 default_mode.hdisplay, default_mode.vdisplay,
246 drm_mode_vrefresh(&default_mode));
247 return -ENOMEM;
248 }
249
250 drm_mode_set_name(mode);
251
252 drm_mode_probed_add(connector, mode);
253
254 connector->display_info.width_mm = 217;
255 connector->display_info.height_mm = 136;
256
257 return 1;
258}
259
260static const struct drm_panel_funcs sharp_panel_funcs = {
261 .unprepare = sharp_panel_unprepare,
262 .prepare = sharp_panel_prepare,
263 .get_modes = sharp_panel_get_modes,
264};
265
266static const struct of_device_id sharp_of_match[] = {
267 { .compatible = "sharp,lq101r1sx01", },
268 { }
269};
270MODULE_DEVICE_TABLE(of, sharp_of_match);
271
272static int sharp_panel_add(struct sharp_panel *sharp)
273{
274 int ret;
275
276 sharp->mode = &default_mode;
277
278 sharp->supply = devm_regulator_get(&sharp->link1->dev, "power");
279 if (IS_ERR(sharp->supply))
280 return PTR_ERR(sharp->supply);
281
282 drm_panel_init(&sharp->base, &sharp->link1->dev, &sharp_panel_funcs,
283 DRM_MODE_CONNECTOR_DSI);
284
285 ret = drm_panel_of_backlight(&sharp->base);
286 if (ret)
287 return ret;
288
289 drm_panel_add(&sharp->base);
290
291 return 0;
292}
293
294static void sharp_panel_del(struct sharp_panel *sharp)
295{
296 if (sharp->base.dev)
297 drm_panel_remove(&sharp->base);
298
299 if (sharp->link2)
300 put_device(&sharp->link2->dev);
301}
302
303static int sharp_panel_probe(struct mipi_dsi_device *dsi)
304{
305 struct mipi_dsi_device *secondary = NULL;
306 struct sharp_panel *sharp;
307 struct device_node *np;
308 int err;
309
310 dsi->lanes = 4;
311 dsi->format = MIPI_DSI_FMT_RGB888;
312 dsi->mode_flags = MIPI_DSI_MODE_LPM;
313
314 /* Find DSI-LINK1 */
315 np = of_parse_phandle(dsi->dev.of_node, "link2", 0);
316 if (np) {
317 secondary = of_find_mipi_dsi_device_by_node(np);
318 of_node_put(np);
319
320 if (!secondary)
321 return -EPROBE_DEFER;
322 }
323
324 /* register a panel for only the DSI-LINK1 interface */
325 if (secondary) {
326 sharp = devm_kzalloc(&dsi->dev, sizeof(*sharp), GFP_KERNEL);
327 if (!sharp) {
328 put_device(&secondary->dev);
329 return -ENOMEM;
330 }
331
332 mipi_dsi_set_drvdata(dsi, sharp);
333
334 sharp->link2 = secondary;
335 sharp->link1 = dsi;
336
337 err = sharp_panel_add(sharp);
338 if (err < 0) {
339 put_device(&secondary->dev);
340 return err;
341 }
342 }
343
344 err = mipi_dsi_attach(dsi);
345 if (err < 0) {
346 if (secondary)
347 sharp_panel_del(sharp);
348
349 return err;
350 }
351
352 return 0;
353}
354
355static void sharp_panel_remove(struct mipi_dsi_device *dsi)
356{
357 struct sharp_panel *sharp = mipi_dsi_get_drvdata(dsi);
358 int err;
359
360 err = mipi_dsi_detach(dsi);
361 if (err < 0)
362 dev_err(&dsi->dev, "failed to detach from DSI host: %d\n", err);
363
364 /* only detach from host for the DSI-LINK2 interface */
365 if (sharp)
366 sharp_panel_del(sharp);
367}
368
369static struct mipi_dsi_driver sharp_panel_driver = {
370 .driver = {
371 .name = "panel-sharp-lq101r1sx01",
372 .of_match_table = sharp_of_match,
373 },
374 .probe = sharp_panel_probe,
375 .remove = sharp_panel_remove,
376};
377module_mipi_dsi_driver(sharp_panel_driver);
378
379MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>");
380MODULE_DESCRIPTION("Sharp LQ101R1SX01 panel driver");
381MODULE_LICENSE("GPL v2");
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2014 NVIDIA Corporation
4 */
5
6#include <linux/backlight.h>
7#include <linux/delay.h>
8#include <linux/gpio/consumer.h>
9#include <linux/module.h>
10#include <linux/of.h>
11#include <linux/regulator/consumer.h>
12
13#include <video/mipi_display.h>
14
15#include <drm/drm_crtc.h>
16#include <drm/drm_device.h>
17#include <drm/drm_mipi_dsi.h>
18#include <drm/drm_panel.h>
19
20struct sharp_panel {
21 struct drm_panel base;
22 /* the datasheet refers to them as DSI-LINK1 and DSI-LINK2 */
23 struct mipi_dsi_device *link1;
24 struct mipi_dsi_device *link2;
25
26 struct backlight_device *backlight;
27 struct regulator *supply;
28
29 bool prepared;
30 bool enabled;
31
32 const struct drm_display_mode *mode;
33};
34
35static inline struct sharp_panel *to_sharp_panel(struct drm_panel *panel)
36{
37 return container_of(panel, struct sharp_panel, base);
38}
39
40static void sharp_wait_frames(struct sharp_panel *sharp, unsigned int frames)
41{
42 unsigned int refresh = drm_mode_vrefresh(sharp->mode);
43
44 if (WARN_ON(frames > refresh))
45 return;
46
47 msleep(1000 / (refresh / frames));
48}
49
50static int sharp_panel_write(struct sharp_panel *sharp, u16 offset, u8 value)
51{
52 u8 payload[3] = { offset >> 8, offset & 0xff, value };
53 struct mipi_dsi_device *dsi = sharp->link1;
54 ssize_t err;
55
56 err = mipi_dsi_generic_write(dsi, payload, sizeof(payload));
57 if (err < 0) {
58 dev_err(&dsi->dev, "failed to write %02x to %04x: %zd\n",
59 value, offset, err);
60 return err;
61 }
62
63 err = mipi_dsi_dcs_nop(dsi);
64 if (err < 0) {
65 dev_err(&dsi->dev, "failed to send DCS nop: %zd\n", err);
66 return err;
67 }
68
69 usleep_range(10, 20);
70
71 return 0;
72}
73
74static __maybe_unused int sharp_panel_read(struct sharp_panel *sharp,
75 u16 offset, u8 *value)
76{
77 ssize_t err;
78
79 cpu_to_be16s(&offset);
80
81 err = mipi_dsi_generic_read(sharp->link1, &offset, sizeof(offset),
82 value, sizeof(*value));
83 if (err < 0)
84 dev_err(&sharp->link1->dev, "failed to read from %04x: %zd\n",
85 offset, err);
86
87 return err;
88}
89
90static int sharp_panel_disable(struct drm_panel *panel)
91{
92 struct sharp_panel *sharp = to_sharp_panel(panel);
93
94 if (!sharp->enabled)
95 return 0;
96
97 backlight_disable(sharp->backlight);
98
99 sharp->enabled = false;
100
101 return 0;
102}
103
104static int sharp_panel_unprepare(struct drm_panel *panel)
105{
106 struct sharp_panel *sharp = to_sharp_panel(panel);
107 int err;
108
109 if (!sharp->prepared)
110 return 0;
111
112 sharp_wait_frames(sharp, 4);
113
114 err = mipi_dsi_dcs_set_display_off(sharp->link1);
115 if (err < 0)
116 dev_err(panel->dev, "failed to set display off: %d\n", err);
117
118 err = mipi_dsi_dcs_enter_sleep_mode(sharp->link1);
119 if (err < 0)
120 dev_err(panel->dev, "failed to enter sleep mode: %d\n", err);
121
122 msleep(120);
123
124 regulator_disable(sharp->supply);
125
126 sharp->prepared = false;
127
128 return 0;
129}
130
131static int sharp_setup_symmetrical_split(struct mipi_dsi_device *left,
132 struct mipi_dsi_device *right,
133 const struct drm_display_mode *mode)
134{
135 int err;
136
137 err = mipi_dsi_dcs_set_column_address(left, 0, mode->hdisplay / 2 - 1);
138 if (err < 0) {
139 dev_err(&left->dev, "failed to set column address: %d\n", err);
140 return err;
141 }
142
143 err = mipi_dsi_dcs_set_page_address(left, 0, mode->vdisplay - 1);
144 if (err < 0) {
145 dev_err(&left->dev, "failed to set page address: %d\n", err);
146 return err;
147 }
148
149 err = mipi_dsi_dcs_set_column_address(right, mode->hdisplay / 2,
150 mode->hdisplay - 1);
151 if (err < 0) {
152 dev_err(&right->dev, "failed to set column address: %d\n", err);
153 return err;
154 }
155
156 err = mipi_dsi_dcs_set_page_address(right, 0, mode->vdisplay - 1);
157 if (err < 0) {
158 dev_err(&right->dev, "failed to set page address: %d\n", err);
159 return err;
160 }
161
162 return 0;
163}
164
165static int sharp_panel_prepare(struct drm_panel *panel)
166{
167 struct sharp_panel *sharp = to_sharp_panel(panel);
168 u8 format = MIPI_DCS_PIXEL_FMT_24BIT;
169 int err;
170
171 if (sharp->prepared)
172 return 0;
173
174 err = regulator_enable(sharp->supply);
175 if (err < 0)
176 return err;
177
178 /*
179 * According to the datasheet, the panel needs around 10 ms to fully
180 * power up. At least another 120 ms is required before exiting sleep
181 * mode to make sure the panel is ready. Throw in another 20 ms for
182 * good measure.
183 */
184 msleep(150);
185
186 err = mipi_dsi_dcs_exit_sleep_mode(sharp->link1);
187 if (err < 0) {
188 dev_err(panel->dev, "failed to exit sleep mode: %d\n", err);
189 goto poweroff;
190 }
191
192 /*
193 * The MIPI DCS specification mandates this delay only between the
194 * exit_sleep_mode and enter_sleep_mode commands, so it isn't strictly
195 * necessary here.
196 */
197 /*
198 msleep(120);
199 */
200
201 /* set left-right mode */
202 err = sharp_panel_write(sharp, 0x1000, 0x2a);
203 if (err < 0) {
204 dev_err(panel->dev, "failed to set left-right mode: %d\n", err);
205 goto poweroff;
206 }
207
208 /* enable command mode */
209 err = sharp_panel_write(sharp, 0x1001, 0x01);
210 if (err < 0) {
211 dev_err(panel->dev, "failed to enable command mode: %d\n", err);
212 goto poweroff;
213 }
214
215 err = mipi_dsi_dcs_set_pixel_format(sharp->link1, format);
216 if (err < 0) {
217 dev_err(panel->dev, "failed to set pixel format: %d\n", err);
218 goto poweroff;
219 }
220
221 /*
222 * TODO: The device supports both left-right and even-odd split
223 * configurations, but this driver currently supports only the left-
224 * right split. To support a different mode a mechanism needs to be
225 * put in place to communicate the configuration back to the DSI host
226 * controller.
227 */
228 err = sharp_setup_symmetrical_split(sharp->link1, sharp->link2,
229 sharp->mode);
230 if (err < 0) {
231 dev_err(panel->dev, "failed to set up symmetrical split: %d\n",
232 err);
233 goto poweroff;
234 }
235
236 err = mipi_dsi_dcs_set_display_on(sharp->link1);
237 if (err < 0) {
238 dev_err(panel->dev, "failed to set display on: %d\n", err);
239 goto poweroff;
240 }
241
242 sharp->prepared = true;
243
244 /* wait for 6 frames before continuing */
245 sharp_wait_frames(sharp, 6);
246
247 return 0;
248
249poweroff:
250 regulator_disable(sharp->supply);
251 return err;
252}
253
254static int sharp_panel_enable(struct drm_panel *panel)
255{
256 struct sharp_panel *sharp = to_sharp_panel(panel);
257
258 if (sharp->enabled)
259 return 0;
260
261 backlight_enable(sharp->backlight);
262
263 sharp->enabled = true;
264
265 return 0;
266}
267
268static const struct drm_display_mode default_mode = {
269 .clock = 278000,
270 .hdisplay = 2560,
271 .hsync_start = 2560 + 128,
272 .hsync_end = 2560 + 128 + 64,
273 .htotal = 2560 + 128 + 64 + 64,
274 .vdisplay = 1600,
275 .vsync_start = 1600 + 4,
276 .vsync_end = 1600 + 4 + 8,
277 .vtotal = 1600 + 4 + 8 + 32,
278 .vrefresh = 60,
279};
280
281static int sharp_panel_get_modes(struct drm_panel *panel)
282{
283 struct drm_display_mode *mode;
284
285 mode = drm_mode_duplicate(panel->drm, &default_mode);
286 if (!mode) {
287 dev_err(panel->drm->dev, "failed to add mode %ux%ux@%u\n",
288 default_mode.hdisplay, default_mode.vdisplay,
289 default_mode.vrefresh);
290 return -ENOMEM;
291 }
292
293 drm_mode_set_name(mode);
294
295 drm_mode_probed_add(panel->connector, mode);
296
297 panel->connector->display_info.width_mm = 217;
298 panel->connector->display_info.height_mm = 136;
299
300 return 1;
301}
302
303static const struct drm_panel_funcs sharp_panel_funcs = {
304 .disable = sharp_panel_disable,
305 .unprepare = sharp_panel_unprepare,
306 .prepare = sharp_panel_prepare,
307 .enable = sharp_panel_enable,
308 .get_modes = sharp_panel_get_modes,
309};
310
311static const struct of_device_id sharp_of_match[] = {
312 { .compatible = "sharp,lq101r1sx01", },
313 { }
314};
315MODULE_DEVICE_TABLE(of, sharp_of_match);
316
317static int sharp_panel_add(struct sharp_panel *sharp)
318{
319 struct device *dev = &sharp->link1->dev;
320
321 sharp->mode = &default_mode;
322
323 sharp->supply = devm_regulator_get(&sharp->link1->dev, "power");
324 if (IS_ERR(sharp->supply))
325 return PTR_ERR(sharp->supply);
326
327 sharp->backlight = devm_of_find_backlight(dev);
328
329 if (IS_ERR(sharp->backlight))
330 return PTR_ERR(sharp->backlight);
331
332 drm_panel_init(&sharp->base);
333 sharp->base.funcs = &sharp_panel_funcs;
334 sharp->base.dev = &sharp->link1->dev;
335
336 return drm_panel_add(&sharp->base);
337}
338
339static void sharp_panel_del(struct sharp_panel *sharp)
340{
341 if (sharp->base.dev)
342 drm_panel_remove(&sharp->base);
343
344 if (sharp->link2)
345 put_device(&sharp->link2->dev);
346}
347
348static int sharp_panel_probe(struct mipi_dsi_device *dsi)
349{
350 struct mipi_dsi_device *secondary = NULL;
351 struct sharp_panel *sharp;
352 struct device_node *np;
353 int err;
354
355 dsi->lanes = 4;
356 dsi->format = MIPI_DSI_FMT_RGB888;
357 dsi->mode_flags = MIPI_DSI_MODE_LPM;
358
359 /* Find DSI-LINK1 */
360 np = of_parse_phandle(dsi->dev.of_node, "link2", 0);
361 if (np) {
362 secondary = of_find_mipi_dsi_device_by_node(np);
363 of_node_put(np);
364
365 if (!secondary)
366 return -EPROBE_DEFER;
367 }
368
369 /* register a panel for only the DSI-LINK1 interface */
370 if (secondary) {
371 sharp = devm_kzalloc(&dsi->dev, sizeof(*sharp), GFP_KERNEL);
372 if (!sharp) {
373 put_device(&secondary->dev);
374 return -ENOMEM;
375 }
376
377 mipi_dsi_set_drvdata(dsi, sharp);
378
379 sharp->link2 = secondary;
380 sharp->link1 = dsi;
381
382 err = sharp_panel_add(sharp);
383 if (err < 0) {
384 put_device(&secondary->dev);
385 return err;
386 }
387 }
388
389 err = mipi_dsi_attach(dsi);
390 if (err < 0) {
391 if (secondary)
392 sharp_panel_del(sharp);
393
394 return err;
395 }
396
397 return 0;
398}
399
400static int sharp_panel_remove(struct mipi_dsi_device *dsi)
401{
402 struct sharp_panel *sharp = mipi_dsi_get_drvdata(dsi);
403 int err;
404
405 /* only detach from host for the DSI-LINK2 interface */
406 if (!sharp) {
407 mipi_dsi_detach(dsi);
408 return 0;
409 }
410
411 err = sharp_panel_disable(&sharp->base);
412 if (err < 0)
413 dev_err(&dsi->dev, "failed to disable panel: %d\n", err);
414
415 err = mipi_dsi_detach(dsi);
416 if (err < 0)
417 dev_err(&dsi->dev, "failed to detach from DSI host: %d\n", err);
418
419 sharp_panel_del(sharp);
420
421 return 0;
422}
423
424static void sharp_panel_shutdown(struct mipi_dsi_device *dsi)
425{
426 struct sharp_panel *sharp = mipi_dsi_get_drvdata(dsi);
427
428 /* nothing to do for DSI-LINK2 */
429 if (!sharp)
430 return;
431
432 sharp_panel_disable(&sharp->base);
433}
434
435static struct mipi_dsi_driver sharp_panel_driver = {
436 .driver = {
437 .name = "panel-sharp-lq101r1sx01",
438 .of_match_table = sharp_of_match,
439 },
440 .probe = sharp_panel_probe,
441 .remove = sharp_panel_remove,
442 .shutdown = sharp_panel_shutdown,
443};
444module_mipi_dsi_driver(sharp_panel_driver);
445
446MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>");
447MODULE_DESCRIPTION("Sharp LQ101R1SX01 panel driver");
448MODULE_LICENSE("GPL v2");