1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Mainly by David Woodhouse, somewhat modified by Jordan Crouse
4  *
5  * Copyright © 2006-2007  Red Hat, Inc.
6  * Copyright © 2006-2007  Advanced Micro Devices, Inc.
7  * Copyright © 2009       VIA Technology, Inc.
8  * Copyright (c) 2010-2011  Andres Salomon <dilinger@queued.net>
9  */
10 
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 
13 #include <linux/kernel.h>
14 #include <linux/fb.h>
15 #include <linux/console.h>
16 #include <linux/i2c.h>
17 #include <linux/platform_device.h>
18 #include <linux/interrupt.h>
19 #include <linux/delay.h>
20 #include <linux/module.h>
21 #include <linux/backlight.h>
22 #include <linux/device.h>
23 #include <linux/uaccess.h>
24 #include <linux/ctype.h>
25 #include <linux/panic_notifier.h>
26 #include <linux/reboot.h>
27 #include <linux/olpc-ec.h>
28 #include <asm/tsc.h>
29 #include <asm/olpc.h>
30 
31 #include "olpc_dcon.h"
32 
33 /* Module definitions */
34 
35 static ushort resumeline = 898;
36 module_param(resumeline, ushort, 0444);
37 
38 static struct dcon_platform_data *pdata;
39 
40 /* I2C structures */
41 
42 /* Platform devices */
43 static struct platform_device *dcon_device;
44 
45 static unsigned short normal_i2c[] = { 0x0d, I2C_CLIENT_END };
46 
dcon_write(struct dcon_priv * dcon,u8 reg,u16 val)47 static s32 dcon_write(struct dcon_priv *dcon, u8 reg, u16 val)
48 {
49 	return i2c_smbus_write_word_data(dcon->client, reg, val);
50 }
51 
dcon_read(struct dcon_priv * dcon,u8 reg)52 static s32 dcon_read(struct dcon_priv *dcon, u8 reg)
53 {
54 	return i2c_smbus_read_word_data(dcon->client, reg);
55 }
56 
57 /* ===== API functions - these are called by a variety of users ==== */
58 
dcon_hw_init(struct dcon_priv * dcon,int is_init)59 static int dcon_hw_init(struct dcon_priv *dcon, int is_init)
60 {
61 	u16 ver;
62 	int rc = 0;
63 
64 	ver = dcon_read(dcon, DCON_REG_ID);
65 	if ((ver >> 8) != 0xDC) {
66 		pr_err("DCON ID not 0xDCxx: 0x%04x instead.\n", ver);
67 		rc = -ENXIO;
68 		goto err;
69 	}
70 
71 	if (is_init) {
72 		pr_info("Discovered DCON version %x\n", ver & 0xFF);
73 		rc = pdata->init(dcon);
74 		if (rc != 0) {
75 			pr_err("Unable to init.\n");
76 			goto err;
77 		}
78 	}
79 
80 	if (ver < 0xdc02) {
81 		dev_err(&dcon->client->dev,
82 			"DCON v1 is unsupported, giving up..\n");
83 		rc = -ENODEV;
84 		goto err;
85 	}
86 
87 	/* SDRAM setup/hold time */
88 	dcon_write(dcon, 0x3a, 0xc040);
89 	dcon_write(dcon, DCON_REG_MEM_OPT_A, 0x0000);  /* clear option bits */
90 	dcon_write(dcon, DCON_REG_MEM_OPT_A,
91 		   MEM_DLL_CLOCK_DELAY | MEM_POWER_DOWN);
92 	dcon_write(dcon, DCON_REG_MEM_OPT_B, MEM_SOFT_RESET);
93 
94 	/* Colour swizzle, AA, no passthrough, backlight */
95 	if (is_init) {
96 		dcon->disp_mode = MODE_PASSTHRU | MODE_BL_ENABLE |
97 				MODE_CSWIZZLE | MODE_COL_AA;
98 	}
99 	dcon_write(dcon, DCON_REG_MODE, dcon->disp_mode);
100 
101 	/* Set the scanline to interrupt on during resume */
102 	dcon_write(dcon, DCON_REG_SCAN_INT, resumeline);
103 
104 err:
105 	return rc;
106 }
107 
108 /*
109  * The smbus doesn't always come back due to what is believed to be
110  * hardware (power rail) bugs.  For older models where this is known to
111  * occur, our solution is to attempt to wait for the bus to stabilize;
112  * if it doesn't happen, cut power to the dcon, repower it, and wait
113  * for the bus to stabilize.  Rinse, repeat until we have a working
114  * smbus.  For newer models, we simply BUG(); we want to know if this
115  * still happens despite the power fixes that have been made!
116  */
dcon_bus_stabilize(struct dcon_priv * dcon,int is_powered_down)117 static int dcon_bus_stabilize(struct dcon_priv *dcon, int is_powered_down)
118 {
119 	unsigned long timeout;
120 	u8 pm;
121 	int x;
122 
123 power_up:
124 	if (is_powered_down) {
125 		pm = 1;
126 		x = olpc_ec_cmd(EC_DCON_POWER_MODE, &pm, 1, NULL, 0);
127 		if (x) {
128 			pr_warn("unable to force dcon to power up: %d!\n", x);
129 			return x;
130 		}
131 		usleep_range(10000, 11000);  /* we'll be conservative */
132 	}
133 
134 	pdata->bus_stabilize_wiggle();
135 
136 	for (x = -1, timeout = 50; timeout && x < 0; timeout--) {
137 		usleep_range(1000, 1100);
138 		x = dcon_read(dcon, DCON_REG_ID);
139 	}
140 	if (x < 0) {
141 		pr_err("unable to stabilize dcon's smbus, reasserting power and praying.\n");
142 		BUG_ON(olpc_board_at_least(olpc_board(0xc2)));
143 		pm = 0;
144 		olpc_ec_cmd(EC_DCON_POWER_MODE, &pm, 1, NULL, 0);
145 		msleep(100);
146 		is_powered_down = 1;
147 		goto power_up;	/* argh, stupid hardware.. */
148 	}
149 
150 	if (is_powered_down)
151 		return dcon_hw_init(dcon, 0);
152 	return 0;
153 }
154 
dcon_set_backlight(struct dcon_priv * dcon,u8 level)155 static void dcon_set_backlight(struct dcon_priv *dcon, u8 level)
156 {
157 	dcon->bl_val = level;
158 	dcon_write(dcon, DCON_REG_BRIGHT, dcon->bl_val);
159 
160 	/* Purposely turn off the backlight when we go to level 0 */
161 	if (dcon->bl_val == 0) {
162 		dcon->disp_mode &= ~MODE_BL_ENABLE;
163 		dcon_write(dcon, DCON_REG_MODE, dcon->disp_mode);
164 	} else if (!(dcon->disp_mode & MODE_BL_ENABLE)) {
165 		dcon->disp_mode |= MODE_BL_ENABLE;
166 		dcon_write(dcon, DCON_REG_MODE, dcon->disp_mode);
167 	}
168 }
169 
170 /* Set the output type to either color or mono */
dcon_set_mono_mode(struct dcon_priv * dcon,bool enable_mono)171 static int dcon_set_mono_mode(struct dcon_priv *dcon, bool enable_mono)
172 {
173 	if (dcon->mono == enable_mono)
174 		return 0;
175 
176 	dcon->mono = enable_mono;
177 
178 	if (enable_mono) {
179 		dcon->disp_mode &= ~(MODE_CSWIZZLE | MODE_COL_AA);
180 		dcon->disp_mode |= MODE_MONO_LUMA;
181 	} else {
182 		dcon->disp_mode &= ~(MODE_MONO_LUMA);
183 		dcon->disp_mode |= MODE_CSWIZZLE | MODE_COL_AA;
184 	}
185 
186 	dcon_write(dcon, DCON_REG_MODE, dcon->disp_mode);
187 	return 0;
188 }
189 
190 /* For now, this will be really stupid - we need to address how
191  * DCONLOAD works in a sleep and account for it accordingly
192  */
193 
dcon_sleep(struct dcon_priv * dcon,bool sleep)194 static void dcon_sleep(struct dcon_priv *dcon, bool sleep)
195 {
196 	int x;
197 
198 	/* Turn off the backlight and put the DCON to sleep */
199 
200 	if (dcon->asleep == sleep)
201 		return;
202 
203 	if (!olpc_board_at_least(olpc_board(0xc2)))
204 		return;
205 
206 	if (sleep) {
207 		u8 pm = 0;
208 
209 		x = olpc_ec_cmd(EC_DCON_POWER_MODE, &pm, 1, NULL, 0);
210 		if (x)
211 			pr_warn("unable to force dcon to power down: %d!\n", x);
212 		else
213 			dcon->asleep = sleep;
214 	} else {
215 		/* Only re-enable the backlight if the backlight value is set */
216 		if (dcon->bl_val != 0)
217 			dcon->disp_mode |= MODE_BL_ENABLE;
218 		x = dcon_bus_stabilize(dcon, 1);
219 		if (x)
220 			pr_warn("unable to reinit dcon hardware: %d!\n", x);
221 		else
222 			dcon->asleep = sleep;
223 
224 		/* Restore backlight */
225 		dcon_set_backlight(dcon, dcon->bl_val);
226 	}
227 
228 	/* We should turn off some stuff in the framebuffer - but what? */
229 }
230 
231 /* the DCON seems to get confused if we change DCONLOAD too
232  * frequently -- i.e., approximately faster than frame time.
233  * normally we don't change it this fast, so in general we won't
234  * delay here.
235  */
dcon_load_holdoff(struct dcon_priv * dcon)236 static void dcon_load_holdoff(struct dcon_priv *dcon)
237 {
238 	ktime_t delta_t, now;
239 
240 	while (1) {
241 		now = ktime_get();
242 		delta_t = ktime_sub(now, dcon->load_time);
243 		if (ktime_to_ns(delta_t) > NSEC_PER_MSEC * 20)
244 			break;
245 		mdelay(4);
246 	}
247 }
248 
dcon_blank_fb(struct dcon_priv * dcon,bool blank)249 static bool dcon_blank_fb(struct dcon_priv *dcon, bool blank)
250 {
251 	int err;
252 
253 	console_lock();
254 	lock_fb_info(dcon->fbinfo);
255 
256 	dcon->ignore_fb_events = true;
257 	err = fb_blank(dcon->fbinfo,
258 		       blank ? FB_BLANK_POWERDOWN : FB_BLANK_UNBLANK);
259 	dcon->ignore_fb_events = false;
260 	unlock_fb_info(dcon->fbinfo);
261 	console_unlock();
262 
263 	if (err) {
264 		dev_err(&dcon->client->dev, "couldn't %sblank framebuffer\n",
265 			blank ? "" : "un");
266 		return false;
267 	}
268 	return true;
269 }
270 
271 /* Set the source of the display (CPU or DCON) */
dcon_source_switch(struct work_struct * work)272 static void dcon_source_switch(struct work_struct *work)
273 {
274 	struct dcon_priv *dcon = container_of(work, struct dcon_priv,
275 			switch_source);
276 	int source = dcon->pending_src;
277 
278 	if (dcon->curr_src == source)
279 		return;
280 
281 	dcon_load_holdoff(dcon);
282 
283 	dcon->switched = false;
284 
285 	switch (source) {
286 	case DCON_SOURCE_CPU:
287 		pr_info("%s to CPU\n", __func__);
288 		/* Enable the scanline interrupt bit */
289 		if (dcon_write(dcon, DCON_REG_MODE,
290 			       dcon->disp_mode | MODE_SCAN_INT))
291 			pr_err("couldn't enable scanline interrupt!\n");
292 		else
293 			/* Wait up to one second for the scanline interrupt */
294 			wait_event_timeout(dcon->waitq, dcon->switched, HZ);
295 
296 		if (!dcon->switched)
297 			pr_err("Timeout entering CPU mode; expect a screen glitch.\n");
298 
299 		/* Turn off the scanline interrupt */
300 		if (dcon_write(dcon, DCON_REG_MODE, dcon->disp_mode))
301 			pr_err("couldn't disable scanline interrupt!\n");
302 
303 		/*
304 		 * Ideally we'd like to disable interrupts here so that the
305 		 * fb unblanking and DCON turn on happen at a known time value;
306 		 * however, we can't do that right now with fb_blank
307 		 * messing with semaphores.
308 		 *
309 		 * For now, we just hope..
310 		 */
311 		if (!dcon_blank_fb(dcon, false)) {
312 			pr_err("Failed to enter CPU mode\n");
313 			dcon->pending_src = DCON_SOURCE_DCON;
314 			return;
315 		}
316 
317 		/* And turn off the DCON */
318 		pdata->set_dconload(1);
319 		dcon->load_time = ktime_get();
320 
321 		pr_info("The CPU has control\n");
322 		break;
323 	case DCON_SOURCE_DCON:
324 	{
325 		ktime_t delta_t;
326 
327 		pr_info("%s to DCON\n", __func__);
328 
329 		/* Clear DCONLOAD - this implies that the DCON is in control */
330 		pdata->set_dconload(0);
331 		dcon->load_time = ktime_get();
332 
333 		wait_event_timeout(dcon->waitq, dcon->switched, HZ / 2);
334 
335 		if (!dcon->switched) {
336 			pr_err("Timeout entering DCON mode; expect a screen glitch.\n");
337 		} else {
338 			/* sometimes the DCON doesn't follow its own rules,
339 			 * and doesn't wait for two vsync pulses before
340 			 * ack'ing the frame load with an IRQ.  the result
341 			 * is that the display shows the *previously*
342 			 * loaded frame.  we can detect this by looking at
343 			 * the time between asserting DCONLOAD and the IRQ --
344 			 * if it's less than 20msec, then the DCON couldn't
345 			 * have seen two VSYNC pulses.  in that case we
346 			 * deassert and reassert, and hope for the best.
347 			 * see http://dev.laptop.org/ticket/9664
348 			 */
349 			delta_t = ktime_sub(dcon->irq_time, dcon->load_time);
350 			if (dcon->switched && ktime_to_ns(delta_t)
351 			    < NSEC_PER_MSEC * 20) {
352 				pr_err("missed loading, retrying\n");
353 				pdata->set_dconload(1);
354 				mdelay(41);
355 				pdata->set_dconload(0);
356 				dcon->load_time = ktime_get();
357 				mdelay(41);
358 			}
359 		}
360 
361 		dcon_blank_fb(dcon, true);
362 		pr_info("The DCON has control\n");
363 		break;
364 	}
365 	default:
366 		BUG();
367 	}
368 
369 	dcon->curr_src = source;
370 }
371 
dcon_set_source(struct dcon_priv * dcon,int arg)372 static void dcon_set_source(struct dcon_priv *dcon, int arg)
373 {
374 	if (dcon->pending_src == arg)
375 		return;
376 
377 	dcon->pending_src = arg;
378 
379 	if (dcon->curr_src != arg)
380 		schedule_work(&dcon->switch_source);
381 }
382 
dcon_set_source_sync(struct dcon_priv * dcon,int arg)383 static void dcon_set_source_sync(struct dcon_priv *dcon, int arg)
384 {
385 	dcon_set_source(dcon, arg);
386 	flush_work(&dcon->switch_source);
387 }
388 
dcon_mode_show(struct device * dev,struct device_attribute * attr,char * buf)389 static ssize_t dcon_mode_show(struct device *dev,
390 			      struct device_attribute *attr,
391 			      char *buf)
392 {
393 	struct dcon_priv *dcon = dev_get_drvdata(dev);
394 
395 	return sprintf(buf, "%4.4X\n", dcon->disp_mode);
396 }
397 
dcon_sleep_show(struct device * dev,struct device_attribute * attr,char * buf)398 static ssize_t dcon_sleep_show(struct device *dev,
399 			       struct device_attribute *attr,
400 			       char *buf)
401 {
402 	struct dcon_priv *dcon = dev_get_drvdata(dev);
403 
404 	return sprintf(buf, "%d\n", dcon->asleep);
405 }
406 
dcon_freeze_show(struct device * dev,struct device_attribute * attr,char * buf)407 static ssize_t dcon_freeze_show(struct device *dev,
408 				struct device_attribute *attr,
409 				char *buf)
410 {
411 	struct dcon_priv *dcon = dev_get_drvdata(dev);
412 
413 	return sprintf(buf, "%d\n", dcon->curr_src == DCON_SOURCE_DCON ? 1 : 0);
414 }
415 
dcon_mono_show(struct device * dev,struct device_attribute * attr,char * buf)416 static ssize_t dcon_mono_show(struct device *dev,
417 			      struct device_attribute *attr,
418 			      char *buf)
419 {
420 	struct dcon_priv *dcon = dev_get_drvdata(dev);
421 
422 	return sprintf(buf, "%d\n", dcon->mono);
423 }
424 
dcon_resumeline_show(struct device * dev,struct device_attribute * attr,char * buf)425 static ssize_t dcon_resumeline_show(struct device *dev,
426 				    struct device_attribute *attr,
427 				    char *buf)
428 {
429 	return sprintf(buf, "%d\n", resumeline);
430 }
431 
dcon_mono_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)432 static ssize_t dcon_mono_store(struct device *dev,
433 			       struct device_attribute *attr,
434 			       const char *buf, size_t count)
435 {
436 	unsigned long enable_mono;
437 	int rc;
438 
439 	rc = kstrtoul(buf, 10, &enable_mono);
440 	if (rc)
441 		return rc;
442 
443 	dcon_set_mono_mode(dev_get_drvdata(dev), enable_mono ? true : false);
444 
445 	return count;
446 }
447 
dcon_freeze_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)448 static ssize_t dcon_freeze_store(struct device *dev,
449 				 struct device_attribute *attr,
450 				 const char *buf, size_t count)
451 {
452 	struct dcon_priv *dcon = dev_get_drvdata(dev);
453 	unsigned long output;
454 	int ret;
455 
456 	ret = kstrtoul(buf, 10, &output);
457 	if (ret)
458 		return ret;
459 
460 	switch (output) {
461 	case 0:
462 		dcon_set_source(dcon, DCON_SOURCE_CPU);
463 		break;
464 	case 1:
465 		dcon_set_source_sync(dcon, DCON_SOURCE_DCON);
466 		break;
467 	case 2:  /* normally unused */
468 		dcon_set_source(dcon, DCON_SOURCE_DCON);
469 		break;
470 	default:
471 		return -EINVAL;
472 	}
473 
474 	return count;
475 }
476 
dcon_resumeline_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)477 static ssize_t dcon_resumeline_store(struct device *dev,
478 				     struct device_attribute *attr,
479 				     const char *buf, size_t count)
480 {
481 	unsigned short rl;
482 	int rc;
483 
484 	rc = kstrtou16(buf, 10, &rl);
485 	if (rc)
486 		return rc;
487 
488 	resumeline = rl;
489 	dcon_write(dev_get_drvdata(dev), DCON_REG_SCAN_INT, resumeline);
490 
491 	return count;
492 }
493 
dcon_sleep_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)494 static ssize_t dcon_sleep_store(struct device *dev,
495 				struct device_attribute *attr,
496 				const char *buf, size_t count)
497 {
498 	unsigned long output;
499 	int ret;
500 
501 	ret = kstrtoul(buf, 10, &output);
502 	if (ret)
503 		return ret;
504 
505 	dcon_sleep(dev_get_drvdata(dev), output ? true : false);
506 	return count;
507 }
508 
509 static struct device_attribute dcon_device_files[] = {
510 	__ATTR(mode, 0444, dcon_mode_show, NULL),
511 	__ATTR(sleep, 0644, dcon_sleep_show, dcon_sleep_store),
512 	__ATTR(freeze, 0644, dcon_freeze_show, dcon_freeze_store),
513 	__ATTR(monochrome, 0644, dcon_mono_show, dcon_mono_store),
514 	__ATTR(resumeline, 0644, dcon_resumeline_show, dcon_resumeline_store),
515 };
516 
dcon_bl_update(struct backlight_device * dev)517 static int dcon_bl_update(struct backlight_device *dev)
518 {
519 	struct dcon_priv *dcon = bl_get_data(dev);
520 	u8 level = backlight_get_brightness(dev) & 0x0F;
521 
522 	if (level != dcon->bl_val)
523 		dcon_set_backlight(dcon, level);
524 
525 	/* power down the DCON when the screen is blanked */
526 	if (!dcon->ignore_fb_events)
527 		dcon_sleep(dcon, !!(dev->props.state & BL_CORE_FBBLANK));
528 
529 	return 0;
530 }
531 
dcon_bl_get(struct backlight_device * dev)532 static int dcon_bl_get(struct backlight_device *dev)
533 {
534 	struct dcon_priv *dcon = bl_get_data(dev);
535 
536 	return dcon->bl_val;
537 }
538 
539 static const struct backlight_ops dcon_bl_ops = {
540 	.update_status = dcon_bl_update,
541 	.get_brightness = dcon_bl_get,
542 };
543 
544 static struct backlight_properties dcon_bl_props = {
545 	.max_brightness = 15,
546 	.type = BACKLIGHT_RAW,
547 	.power = FB_BLANK_UNBLANK,
548 };
549 
dcon_reboot_notify(struct notifier_block * nb,unsigned long foo,void * bar)550 static int dcon_reboot_notify(struct notifier_block *nb,
551 			      unsigned long foo, void *bar)
552 {
553 	struct dcon_priv *dcon = container_of(nb, struct dcon_priv, reboot_nb);
554 
555 	if (!dcon || !dcon->client)
556 		return NOTIFY_DONE;
557 
558 	/* Turn off the DCON. Entirely. */
559 	dcon_write(dcon, DCON_REG_MODE, 0x39);
560 	dcon_write(dcon, DCON_REG_MODE, 0x32);
561 	return NOTIFY_DONE;
562 }
563 
unfreeze_on_panic(struct notifier_block * nb,unsigned long e,void * p)564 static int unfreeze_on_panic(struct notifier_block *nb,
565 			     unsigned long e, void *p)
566 {
567 	pdata->set_dconload(1);
568 	return NOTIFY_DONE;
569 }
570 
571 static struct notifier_block dcon_panic_nb = {
572 	.notifier_call = unfreeze_on_panic,
573 };
574 
dcon_detect(struct i2c_client * client,struct i2c_board_info * info)575 static int dcon_detect(struct i2c_client *client, struct i2c_board_info *info)
576 {
577 	strscpy(info->type, "olpc_dcon", I2C_NAME_SIZE);
578 
579 	return 0;
580 }
581 
dcon_probe(struct i2c_client * client)582 static int dcon_probe(struct i2c_client *client)
583 {
584 	struct dcon_priv *dcon;
585 	int rc, i, j;
586 
587 	if (!pdata)
588 		return -ENXIO;
589 
590 	dcon = kzalloc(sizeof(*dcon), GFP_KERNEL);
591 	if (!dcon)
592 		return -ENOMEM;
593 
594 	dcon->client = client;
595 	init_waitqueue_head(&dcon->waitq);
596 	INIT_WORK(&dcon->switch_source, dcon_source_switch);
597 	dcon->reboot_nb.notifier_call = dcon_reboot_notify;
598 	dcon->reboot_nb.priority = -1;
599 
600 	i2c_set_clientdata(client, dcon);
601 
602 	if (num_registered_fb < 1) {
603 		dev_err(&client->dev, "DCON driver requires a registered fb\n");
604 		rc = -EIO;
605 		goto einit;
606 	}
607 	dcon->fbinfo = registered_fb[0];
608 
609 	rc = dcon_hw_init(dcon, 1);
610 	if (rc)
611 		goto einit;
612 
613 	/* Add the DCON device */
614 
615 	dcon_device = platform_device_alloc("dcon", -1);
616 
617 	if (!dcon_device) {
618 		pr_err("Unable to create the DCON device\n");
619 		rc = -ENOMEM;
620 		goto eirq;
621 	}
622 	rc = platform_device_add(dcon_device);
623 	platform_set_drvdata(dcon_device, dcon);
624 
625 	if (rc) {
626 		pr_err("Unable to add the DCON device\n");
627 		goto edev;
628 	}
629 
630 	for (i = 0; i < ARRAY_SIZE(dcon_device_files); i++) {
631 		rc = device_create_file(&dcon_device->dev,
632 					&dcon_device_files[i]);
633 		if (rc) {
634 			dev_err(&dcon_device->dev, "Cannot create sysfs file\n");
635 			goto ecreate;
636 		}
637 	}
638 
639 	dcon->bl_val = dcon_read(dcon, DCON_REG_BRIGHT) & 0x0F;
640 
641 	/* Add the backlight device for the DCON */
642 	dcon_bl_props.brightness = dcon->bl_val;
643 	dcon->bl_dev = backlight_device_register("dcon-bl", &dcon_device->dev,
644 						 dcon, &dcon_bl_ops,
645 						 &dcon_bl_props);
646 	if (IS_ERR(dcon->bl_dev)) {
647 		dev_err(&client->dev, "cannot register backlight dev (%ld)\n",
648 			PTR_ERR(dcon->bl_dev));
649 		dcon->bl_dev = NULL;
650 	}
651 
652 	register_reboot_notifier(&dcon->reboot_nb);
653 	atomic_notifier_chain_register(&panic_notifier_list, &dcon_panic_nb);
654 
655 	return 0;
656 
657  ecreate:
658 	for (j = 0; j < i; j++)
659 		device_remove_file(&dcon_device->dev, &dcon_device_files[j]);
660 	platform_device_del(dcon_device);
661  edev:
662 	platform_device_put(dcon_device);
663 	dcon_device = NULL;
664  eirq:
665 	free_irq(DCON_IRQ, dcon);
666  einit:
667 	kfree(dcon);
668 	return rc;
669 }
670 
dcon_remove(struct i2c_client * client)671 static void dcon_remove(struct i2c_client *client)
672 {
673 	struct dcon_priv *dcon = i2c_get_clientdata(client);
674 
675 	unregister_reboot_notifier(&dcon->reboot_nb);
676 	atomic_notifier_chain_unregister(&panic_notifier_list, &dcon_panic_nb);
677 
678 	free_irq(DCON_IRQ, dcon);
679 
680 	backlight_device_unregister(dcon->bl_dev);
681 
682 	if (dcon_device)
683 		platform_device_unregister(dcon_device);
684 	cancel_work_sync(&dcon->switch_source);
685 
686 	kfree(dcon);
687 }
688 
689 #ifdef CONFIG_PM
dcon_suspend(struct device * dev)690 static int dcon_suspend(struct device *dev)
691 {
692 	struct i2c_client *client = to_i2c_client(dev);
693 	struct dcon_priv *dcon = i2c_get_clientdata(client);
694 
695 	if (!dcon->asleep) {
696 		/* Set up the DCON to have the source */
697 		dcon_set_source_sync(dcon, DCON_SOURCE_DCON);
698 	}
699 
700 	return 0;
701 }
702 
dcon_resume(struct device * dev)703 static int dcon_resume(struct device *dev)
704 {
705 	struct i2c_client *client = to_i2c_client(dev);
706 	struct dcon_priv *dcon = i2c_get_clientdata(client);
707 
708 	if (!dcon->asleep) {
709 		dcon_bus_stabilize(dcon, 0);
710 		dcon_set_source(dcon, DCON_SOURCE_CPU);
711 	}
712 
713 	return 0;
714 }
715 
716 #else
717 
718 #define dcon_suspend NULL
719 #define dcon_resume NULL
720 
721 #endif /* CONFIG_PM */
722 
dcon_interrupt(int irq,void * id)723 irqreturn_t dcon_interrupt(int irq, void *id)
724 {
725 	struct dcon_priv *dcon = id;
726 	u8 status;
727 
728 	if (pdata->read_status(&status))
729 		return IRQ_NONE;
730 
731 	switch (status & 3) {
732 	case 3:
733 		pr_debug("DCONLOAD_MISSED interrupt\n");
734 		break;
735 
736 	case 2:	/* switch to DCON mode */
737 	case 1: /* switch to CPU mode */
738 		dcon->switched = true;
739 		dcon->irq_time = ktime_get();
740 		wake_up(&dcon->waitq);
741 		break;
742 
743 	case 0:
744 		/* workaround resume case:  the DCON (on 1.5) doesn't
745 		 * ever assert status 0x01 when switching to CPU mode
746 		 * during resume.  this is because DCONLOAD is de-asserted
747 		 * _immediately_ upon exiting S3, so the actual release
748 		 * of the DCON happened long before this point.
749 		 * see http://dev.laptop.org/ticket/9869
750 		 */
751 		if (dcon->curr_src != dcon->pending_src && !dcon->switched) {
752 			dcon->switched = true;
753 			dcon->irq_time = ktime_get();
754 			wake_up(&dcon->waitq);
755 			pr_debug("switching w/ status 0/0\n");
756 		} else {
757 			pr_debug("scanline interrupt w/CPU\n");
758 		}
759 	}
760 
761 	return IRQ_HANDLED;
762 }
763 
764 static const struct dev_pm_ops dcon_pm_ops = {
765 	.suspend = dcon_suspend,
766 	.resume = dcon_resume,
767 };
768 
769 static const struct i2c_device_id dcon_idtable[] = {
770 	{ "olpc_dcon",  0 },
771 	{ }
772 };
773 MODULE_DEVICE_TABLE(i2c, dcon_idtable);
774 
775 static struct i2c_driver dcon_driver = {
776 	.driver = {
777 		.name	= "olpc_dcon",
778 		.pm = &dcon_pm_ops,
779 	},
780 	.class = I2C_CLASS_DDC | I2C_CLASS_HWMON,
781 	.id_table = dcon_idtable,
782 	.probe = dcon_probe,
783 	.remove = dcon_remove,
784 	.detect = dcon_detect,
785 	.address_list = normal_i2c,
786 };
787 
olpc_dcon_init(void)788 static int __init olpc_dcon_init(void)
789 {
790 	/* XO-1.5 */
791 	if (olpc_board_at_least(olpc_board(0xd0)))
792 		pdata = &dcon_pdata_xo_1_5;
793 	else
794 		pdata = &dcon_pdata_xo_1;
795 
796 	return i2c_add_driver(&dcon_driver);
797 }
798 
olpc_dcon_exit(void)799 static void __exit olpc_dcon_exit(void)
800 {
801 	i2c_del_driver(&dcon_driver);
802 }
803 
804 module_init(olpc_dcon_init);
805 module_exit(olpc_dcon_exit);
806 
807 MODULE_LICENSE("GPL");
808