1 /*
2  * Backlight driver for Marvell Semiconductor 88PM8606
3  *
4  * Copyright (C) 2009 Marvell International Ltd.
5  *	Haojian Zhuang <haojian.zhuang@marvell.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11 
12 #include <linux/init.h>
13 #include <linux/kernel.h>
14 #include <linux/of.h>
15 #include <linux/platform_device.h>
16 #include <linux/slab.h>
17 #include <linux/fb.h>
18 #include <linux/i2c.h>
19 #include <linux/backlight.h>
20 #include <linux/mfd/88pm860x.h>
21 #include <linux/module.h>
22 
23 #define MAX_BRIGHTNESS		(0xFF)
24 #define MIN_BRIGHTNESS		(0)
25 
26 #define CURRENT_BITMASK		(0x1F << 1)
27 
28 struct pm860x_backlight_data {
29 	struct pm860x_chip *chip;
30 	struct i2c_client *i2c;
31 	int	current_brightness;
32 	int	port;
33 	int	pwm;
34 	int	iset;
35 	int	reg_duty_cycle;
36 	int	reg_always_on;
37 	int	reg_current;
38 };
39 
40 static int backlight_power_set(struct pm860x_chip *chip, int port,
41 		int on)
42 {
43 	int ret = -EINVAL;
44 
45 	switch (port) {
46 	case 0:
47 		ret = on ? pm8606_osc_enable(chip, WLED1_DUTY) :
48 			pm8606_osc_disable(chip, WLED1_DUTY);
49 		break;
50 	case 1:
51 		ret = on ? pm8606_osc_enable(chip, WLED2_DUTY) :
52 			pm8606_osc_disable(chip, WLED2_DUTY);
53 		break;
54 	case 2:
55 		ret = on ? pm8606_osc_enable(chip, WLED3_DUTY) :
56 			pm8606_osc_disable(chip, WLED3_DUTY);
57 		break;
58 	}
59 	return ret;
60 }
61 
62 static int pm860x_backlight_set(struct backlight_device *bl, int brightness)
63 {
64 	struct pm860x_backlight_data *data = bl_get_data(bl);
65 	struct pm860x_chip *chip = data->chip;
66 	unsigned char value;
67 	int ret;
68 
69 	if (brightness > MAX_BRIGHTNESS)
70 		value = MAX_BRIGHTNESS;
71 	else
72 		value = brightness;
73 
74 	if (brightness)
75 		backlight_power_set(chip, data->port, 1);
76 
77 	ret = pm860x_reg_write(data->i2c, data->reg_duty_cycle, value);
78 	if (ret < 0)
79 		goto out;
80 
81 	if ((data->current_brightness == 0) && brightness) {
82 		if (data->iset) {
83 			ret = pm860x_set_bits(data->i2c, data->reg_current,
84 					      CURRENT_BITMASK, data->iset);
85 			if (ret < 0)
86 				goto out;
87 		}
88 		if (data->pwm) {
89 			ret = pm860x_set_bits(data->i2c, PM8606_PWM,
90 					      PM8606_PWM_FREQ_MASK, data->pwm);
91 			if (ret < 0)
92 				goto out;
93 		}
94 		if (brightness == MAX_BRIGHTNESS) {
95 			/* set WLED_ON bit as 100% */
96 			ret = pm860x_set_bits(data->i2c, data->reg_always_on,
97 					      PM8606_WLED_ON, PM8606_WLED_ON);
98 		}
99 	} else {
100 		if (brightness == MAX_BRIGHTNESS) {
101 			/* set WLED_ON bit as 100% */
102 			ret = pm860x_set_bits(data->i2c, data->reg_always_on,
103 					      PM8606_WLED_ON, PM8606_WLED_ON);
104 		} else {
105 			/* clear WLED_ON bit since it's not 100% */
106 			ret = pm860x_set_bits(data->i2c, data->reg_always_on,
107 					      PM8606_WLED_ON, 0);
108 		}
109 	}
110 	if (ret < 0)
111 		goto out;
112 
113 	if (brightness == 0)
114 		backlight_power_set(chip, data->port, 0);
115 
116 	dev_dbg(chip->dev, "set brightness %d\n", value);
117 	data->current_brightness = value;
118 	return 0;
119 out:
120 	dev_dbg(chip->dev, "set brightness %d failure with return value: %d\n",
121 		value, ret);
122 	return ret;
123 }
124 
125 static int pm860x_backlight_update_status(struct backlight_device *bl)
126 {
127 	int brightness = bl->props.brightness;
128 
129 	if (bl->props.power != FB_BLANK_UNBLANK)
130 		brightness = 0;
131 
132 	if (bl->props.fb_blank != FB_BLANK_UNBLANK)
133 		brightness = 0;
134 
135 	if (bl->props.state & BL_CORE_SUSPENDED)
136 		brightness = 0;
137 
138 	return pm860x_backlight_set(bl, brightness);
139 }
140 
141 static int pm860x_backlight_get_brightness(struct backlight_device *bl)
142 {
143 	struct pm860x_backlight_data *data = bl_get_data(bl);
144 	struct pm860x_chip *chip = data->chip;
145 	int ret;
146 
147 	ret = pm860x_reg_read(data->i2c, data->reg_duty_cycle);
148 	if (ret < 0)
149 		goto out;
150 	data->current_brightness = ret;
151 	dev_dbg(chip->dev, "get brightness %d\n", data->current_brightness);
152 	return data->current_brightness;
153 out:
154 	return -EINVAL;
155 }
156 
157 static const struct backlight_ops pm860x_backlight_ops = {
158 	.options	= BL_CORE_SUSPENDRESUME,
159 	.update_status	= pm860x_backlight_update_status,
160 	.get_brightness	= pm860x_backlight_get_brightness,
161 };
162 
163 #ifdef CONFIG_OF
164 static int pm860x_backlight_dt_init(struct platform_device *pdev,
165 				    struct pm860x_backlight_data *data,
166 				    char *name)
167 {
168 	struct device_node *nproot, *np;
169 	int iset = 0;
170 
171 	nproot = of_get_child_by_name(pdev->dev.parent->of_node, "backlights");
172 	if (!nproot) {
173 		dev_err(&pdev->dev, "failed to find backlights node\n");
174 		return -ENODEV;
175 	}
176 	for_each_child_of_node(nproot, np) {
177 		if (!of_node_cmp(np->name, name)) {
178 			of_property_read_u32(np, "marvell,88pm860x-iset",
179 					     &iset);
180 			data->iset = PM8606_WLED_CURRENT(iset);
181 			of_property_read_u32(np, "marvell,88pm860x-pwm",
182 					     &data->pwm);
183 			of_node_put(np);
184 			break;
185 		}
186 	}
187 	of_node_put(nproot);
188 	return 0;
189 }
190 #else
191 #define pm860x_backlight_dt_init(x, y, z)	(-1)
192 #endif
193 
194 static int pm860x_backlight_probe(struct platform_device *pdev)
195 {
196 	struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
197 	struct pm860x_backlight_pdata *pdata = dev_get_platdata(&pdev->dev);
198 	struct pm860x_backlight_data *data;
199 	struct backlight_device *bl;
200 	struct resource *res;
201 	struct backlight_properties props;
202 	char name[MFD_NAME_SIZE];
203 	int ret = 0;
204 
205 	data = devm_kzalloc(&pdev->dev, sizeof(struct pm860x_backlight_data),
206 			    GFP_KERNEL);
207 	if (data == NULL)
208 		return -ENOMEM;
209 	res = platform_get_resource_byname(pdev, IORESOURCE_REG, "duty cycle");
210 	if (!res) {
211 		dev_err(&pdev->dev, "No REG resource for duty cycle\n");
212 		return -ENXIO;
213 	}
214 	data->reg_duty_cycle = res->start;
215 	res = platform_get_resource_byname(pdev, IORESOURCE_REG, "always on");
216 	if (!res) {
217 		dev_err(&pdev->dev, "No REG resource for always on\n");
218 		return -ENXIO;
219 	}
220 	data->reg_always_on = res->start;
221 	res = platform_get_resource_byname(pdev, IORESOURCE_REG, "current");
222 	if (!res) {
223 		dev_err(&pdev->dev, "No REG resource for current\n");
224 		return -ENXIO;
225 	}
226 	data->reg_current = res->start;
227 
228 	memset(name, 0, MFD_NAME_SIZE);
229 	sprintf(name, "backlight-%d", pdev->id);
230 	data->port = pdev->id;
231 	data->chip = chip;
232 	data->i2c = (chip->id == CHIP_PM8606) ? chip->client : chip->companion;
233 	data->current_brightness = MAX_BRIGHTNESS;
234 	if (pm860x_backlight_dt_init(pdev, data, name)) {
235 		if (pdata) {
236 			data->pwm = pdata->pwm;
237 			data->iset = pdata->iset;
238 		}
239 	}
240 
241 	memset(&props, 0, sizeof(struct backlight_properties));
242 	props.type = BACKLIGHT_RAW;
243 	props.max_brightness = MAX_BRIGHTNESS;
244 	bl = devm_backlight_device_register(&pdev->dev, name, &pdev->dev, data,
245 					&pm860x_backlight_ops, &props);
246 	if (IS_ERR(bl)) {
247 		dev_err(&pdev->dev, "failed to register backlight\n");
248 		return PTR_ERR(bl);
249 	}
250 	bl->props.brightness = MAX_BRIGHTNESS;
251 
252 	platform_set_drvdata(pdev, bl);
253 
254 	/* read current backlight */
255 	ret = pm860x_backlight_get_brightness(bl);
256 	if (ret < 0)
257 		return ret;
258 
259 	backlight_update_status(bl);
260 	return 0;
261 }
262 
263 static struct platform_driver pm860x_backlight_driver = {
264 	.driver		= {
265 		.name	= "88pm860x-backlight",
266 	},
267 	.probe		= pm860x_backlight_probe,
268 };
269 
270 module_platform_driver(pm860x_backlight_driver);
271 
272 MODULE_DESCRIPTION("Backlight Driver for Marvell Semiconductor 88PM8606");
273 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
274 MODULE_LICENSE("GPL");
275 MODULE_ALIAS("platform:88pm860x-backlight");
276