c3a89414ddc099d1baf91fe28234fe87b75b02b5
[linux-3.10.git] / arch / powerpc / platforms / powermac / backlight.c
1 /*
2  * Miscellaneous procedures for dealing with the PowerMac hardware.
3  * Contains support for the backlight.
4  *
5  *   Copyright (C) 2000 Benjamin Herrenschmidt
6  *   Copyright (C) 2006 Michael Hanselmann <linux-kernel@hansmi.ch>
7  *
8  */
9
10 #include <linux/kernel.h>
11 #include <linux/fb.h>
12 #include <linux/backlight.h>
13 #include <linux/adb.h>
14 #include <linux/pmu.h>
15 #include <asm/atomic.h>
16 #include <asm/prom.h>
17 #include <asm/backlight.h>
18
19 #define OLD_BACKLIGHT_MAX 15
20
21 static void pmac_backlight_key_worker(struct work_struct *work);
22 static void pmac_backlight_set_legacy_worker(struct work_struct *work);
23
24 static DECLARE_WORK(pmac_backlight_key_work, pmac_backlight_key_worker);
25 static DECLARE_WORK(pmac_backlight_set_legacy_work, pmac_backlight_set_legacy_worker);
26
27 /* Although these variables are used in interrupt context, it makes no sense to
28  * protect them. No user is able to produce enough key events per second and
29  * notice the errors that might happen.
30  */
31 static int pmac_backlight_key_queued;
32 static int pmac_backlight_set_legacy_queued;
33
34 /* The via-pmu code allows the backlight to be grabbed, in which case the
35  * in-kernel control of the brightness needs to be disabled. This should
36  * only be used by really old PowerBooks.
37  */
38 static atomic_t kernel_backlight_disabled = ATOMIC_INIT(0);
39
40 /* Protect the pmac_backlight variable */
41 DEFINE_MUTEX(pmac_backlight_mutex);
42
43 /* Main backlight storage
44  *
45  * Backlight drivers in this variable are required to have the "props"
46  * attribute set and to have an update_status function.
47  *
48  * We can only store one backlight here, but since Apple laptops have only one
49  * internal display, it doesn't matter. Other backlight drivers can be used
50  * independently.
51  *
52  * Lock ordering:
53  * pmac_backlight_mutex (global, main backlight)
54  *   pmac_backlight->sem (backlight class)
55  */
56 struct backlight_device *pmac_backlight;
57
58 int pmac_has_backlight_type(const char *type)
59 {
60         struct device_node* bk_node = find_devices("backlight");
61
62         if (bk_node) {
63                 const char *prop = get_property(bk_node,
64                                 "backlight-control", NULL);
65                 if (prop && strncmp(prop, type, strlen(type)) == 0)
66                         return 1;
67         }
68
69         return 0;
70 }
71
72 int pmac_backlight_curve_lookup(struct fb_info *info, int value)
73 {
74         int level = (FB_BACKLIGHT_LEVELS - 1);
75
76         if (info && info->bl_dev) {
77                 int i, max = 0;
78
79                 /* Look for biggest value */
80                 for (i = 0; i < FB_BACKLIGHT_LEVELS; i++)
81                         max = max((int)info->bl_curve[i], max);
82
83                 /* Look for nearest value */
84                 for (i = 0; i < FB_BACKLIGHT_LEVELS; i++) {
85                         int diff = abs(info->bl_curve[i] - value);
86                         if (diff < max) {
87                                 max = diff;
88                                 level = i;
89                         }
90                 }
91
92         }
93
94         return level;
95 }
96
97 static void pmac_backlight_key_worker(struct work_struct *work)
98 {
99         if (atomic_read(&kernel_backlight_disabled))
100                 return;
101
102         mutex_lock(&pmac_backlight_mutex);
103         if (pmac_backlight) {
104                 struct backlight_properties *props;
105                 int brightness;
106
107                 down(&pmac_backlight->sem);
108                 props = pmac_backlight->props;
109
110                 brightness = props->brightness +
111                         ((pmac_backlight_key_queued?-1:1) *
112                          (props->max_brightness / 15));
113
114                 if (brightness < 0)
115                         brightness = 0;
116                 else if (brightness > props->max_brightness)
117                         brightness = props->max_brightness;
118
119                 props->brightness = brightness;
120                 props->update_status(pmac_backlight);
121
122                 up(&pmac_backlight->sem);
123         }
124         mutex_unlock(&pmac_backlight_mutex);
125 }
126
127 /* This function is called in interrupt context */
128 void pmac_backlight_key(int direction)
129 {
130         if (atomic_read(&kernel_backlight_disabled))
131                 return;
132
133         /* we can receive multiple interrupts here, but the scheduled work
134          * will run only once, with the last value
135          */
136         pmac_backlight_key_queued = direction;
137         schedule_work(&pmac_backlight_key_work);
138 }
139
140 static int __pmac_backlight_set_legacy_brightness(int brightness)
141 {
142         int error = -ENXIO;
143
144         mutex_lock(&pmac_backlight_mutex);
145         if (pmac_backlight) {
146                 struct backlight_properties *props;
147
148                 down(&pmac_backlight->sem);
149                 props = pmac_backlight->props;
150                 props->brightness = brightness *
151                         (props->max_brightness + 1) /
152                         (OLD_BACKLIGHT_MAX + 1);
153
154                 if (props->brightness > props->max_brightness)
155                         props->brightness = props->max_brightness;
156                 else if (props->brightness < 0)
157                         props->brightness = 0;
158
159                 props->update_status(pmac_backlight);
160                 up(&pmac_backlight->sem);
161
162                 error = 0;
163         }
164         mutex_unlock(&pmac_backlight_mutex);
165
166         return error;
167 }
168
169 static void pmac_backlight_set_legacy_worker(struct work_struct *work)
170 {
171         if (atomic_read(&kernel_backlight_disabled))
172                 return;
173
174         __pmac_backlight_set_legacy_brightness(pmac_backlight_set_legacy_queued);
175 }
176
177 /* This function is called in interrupt context */
178 void pmac_backlight_set_legacy_brightness_pmu(int brightness) {
179         if (atomic_read(&kernel_backlight_disabled))
180                 return;
181
182         pmac_backlight_set_legacy_queued = brightness;
183         schedule_work(&pmac_backlight_set_legacy_work);
184 }
185
186 int pmac_backlight_set_legacy_brightness(int brightness)
187 {
188         return __pmac_backlight_set_legacy_brightness(brightness);
189 }
190
191 int pmac_backlight_get_legacy_brightness()
192 {
193         int result = -ENXIO;
194
195         mutex_lock(&pmac_backlight_mutex);
196         if (pmac_backlight) {
197                 struct backlight_properties *props;
198
199                 down(&pmac_backlight->sem);
200                 props = pmac_backlight->props;
201
202                 result = props->brightness *
203                         (OLD_BACKLIGHT_MAX + 1) /
204                         (props->max_brightness + 1);
205
206                 up(&pmac_backlight->sem);
207         }
208         mutex_unlock(&pmac_backlight_mutex);
209
210         return result;
211 }
212
213 void pmac_backlight_disable()
214 {
215         atomic_inc(&kernel_backlight_disabled);
216 }
217
218 void pmac_backlight_enable()
219 {
220         atomic_dec(&kernel_backlight_disabled);
221 }
222
223 EXPORT_SYMBOL_GPL(pmac_backlight);
224 EXPORT_SYMBOL_GPL(pmac_backlight_mutex);
225 EXPORT_SYMBOL_GPL(pmac_has_backlight_type);