Merge branch 'upstream' of git://git.kernel.org/pub/scm/linux/kernel/git/linville...
[linux-2.6] / drivers / video / backlight / cr_bllcd.c
1 /*
2  * Copyright (c) Intel Corp. 2007.
3  * All Rights Reserved.
4  *
5  * Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
6  * develop this driver.
7  *
8  * This file is part of the Carillo Ranch video subsystem driver.
9  * The Carillo Ranch video subsystem driver is free software;
10  * you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * The Carillo Ranch video subsystem driver is distributed
16  * in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this driver; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
24  *
25  * Authors:
26  *   Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
27  *   Alan Hourihane <alanh-at-tungstengraphics-dot-com>
28  */
29
30 #include <linux/module.h>
31 #include <linux/kernel.h>
32 #include <linux/init.h>
33 #include <linux/platform_device.h>
34 #include <linux/mutex.h>
35 #include <linux/fb.h>
36 #include <linux/backlight.h>
37 #include <linux/lcd.h>
38 #include <linux/pci.h>
39 #include <asm/uaccess.h>
40
41 /* The LVDS- and panel power controls sits on the
42  * GPIO port of the ISA bridge.
43  */
44
45 #define CRVML_DEVICE_LPC    0x27B8
46 #define CRVML_REG_GPIOBAR   0x48
47 #define CRVML_REG_GPIOEN    0x4C
48 #define CRVML_GPIOEN_BIT    (1 << 4)
49 #define CRVML_PANEL_PORT    0x38
50 #define CRVML_LVDS_ON       0x00000001
51 #define CRVML_PANEL_ON      0x00000002
52 #define CRVML_BACKLIGHT_OFF 0x00000004
53
54 /* The PLL Clock register sits on Host bridge */
55 #define CRVML_DEVICE_MCH   0x5001
56 #define CRVML_REG_MCHBAR   0x44
57 #define CRVML_REG_MCHEN    0x54
58 #define CRVML_MCHEN_BIT    (1 << 28)
59 #define CRVML_MCHMAP_SIZE  4096
60 #define CRVML_REG_CLOCK    0xc3c
61 #define CRVML_CLOCK_SHIFT  8
62 #define CRVML_CLOCK_MASK   0x00000f00
63
64 static struct pci_dev *lpc_dev;
65 static u32 gpio_bar;
66
67 struct cr_panel {
68         struct backlight_device *cr_backlight_device;
69         struct lcd_device *cr_lcd_device;
70 };
71
72 static int cr_backlight_set_intensity(struct backlight_device *bd)
73 {
74         int intensity = bd->props.brightness;
75         u32 addr = gpio_bar + CRVML_PANEL_PORT;
76         u32 cur = inl(addr);
77
78         if (bd->props.power == FB_BLANK_UNBLANK)
79                 intensity = FB_BLANK_UNBLANK;
80         if (bd->props.fb_blank == FB_BLANK_UNBLANK)
81                 intensity = FB_BLANK_UNBLANK;
82         if (bd->props.power == FB_BLANK_POWERDOWN)
83                 intensity = FB_BLANK_POWERDOWN;
84         if (bd->props.fb_blank == FB_BLANK_POWERDOWN)
85                 intensity = FB_BLANK_POWERDOWN;
86
87         if (intensity == FB_BLANK_UNBLANK) { /* FULL ON */
88                 cur &= ~CRVML_BACKLIGHT_OFF;
89                 outl(cur, addr);
90         } else if (intensity == FB_BLANK_POWERDOWN) { /* OFF */
91                 cur |= CRVML_BACKLIGHT_OFF;
92                 outl(cur, addr);
93         } /* anything else, don't bother */
94
95         return 0;
96 }
97
98 static int cr_backlight_get_intensity(struct backlight_device *bd)
99 {
100         u32 addr = gpio_bar + CRVML_PANEL_PORT;
101         u32 cur = inl(addr);
102         u8 intensity;
103
104         if (cur & CRVML_BACKLIGHT_OFF)
105                 intensity = FB_BLANK_POWERDOWN;
106         else
107                 intensity = FB_BLANK_UNBLANK;
108
109         return intensity;
110 }
111
112 static struct backlight_ops cr_backlight_ops = {
113         .get_brightness = cr_backlight_get_intensity,
114         .update_status = cr_backlight_set_intensity,
115 };
116
117 static void cr_panel_on(void)
118 {
119         u32 addr = gpio_bar + CRVML_PANEL_PORT;
120         u32 cur = inl(addr);
121
122         if (!(cur & CRVML_PANEL_ON)) {
123                 /* Make sure LVDS controller is down. */
124                 if (cur & 0x00000001) {
125                         cur &= ~CRVML_LVDS_ON;
126                         outl(cur, addr);
127                 }
128                 /* Power up Panel */
129                 schedule_timeout(HZ / 10);
130                 cur |= CRVML_PANEL_ON;
131                 outl(cur, addr);
132         }
133
134         /* Power up LVDS controller */
135
136         if (!(cur & CRVML_LVDS_ON)) {
137                 schedule_timeout(HZ / 10);
138                 outl(cur | CRVML_LVDS_ON, addr);
139         }
140 }
141
142 static void cr_panel_off(void)
143 {
144         u32 addr = gpio_bar + CRVML_PANEL_PORT;
145         u32 cur = inl(addr);
146
147         /* Power down LVDS controller first to avoid high currents */
148         if (cur & CRVML_LVDS_ON) {
149                 cur &= ~CRVML_LVDS_ON;
150                 outl(cur, addr);
151         }
152         if (cur & CRVML_PANEL_ON) {
153                 schedule_timeout(HZ / 10);
154                 outl(cur & ~CRVML_PANEL_ON, addr);
155         }
156 }
157
158 static int cr_lcd_set_power(struct lcd_device *ld, int power)
159 {
160         if (power == FB_BLANK_UNBLANK)
161                 cr_panel_on();
162         if (power == FB_BLANK_POWERDOWN)
163                 cr_panel_off();
164
165         return 0;
166 }
167
168 static struct lcd_ops cr_lcd_ops = {
169         .set_power = cr_lcd_set_power,
170 };
171
172 static int cr_backlight_probe(struct platform_device *pdev)
173 {
174         struct cr_panel *crp;
175         u8 dev_en;
176
177         crp = kzalloc(sizeof(crp), GFP_KERNEL);
178         if (crp == NULL)
179                 return -ENOMEM;
180
181         lpc_dev = pci_get_device(PCI_VENDOR_ID_INTEL,
182                                         CRVML_DEVICE_LPC, NULL);
183         if (!lpc_dev) {
184                 printk("INTEL CARILLO RANCH LPC not found.\n");
185                 return -ENODEV;
186         }
187
188         pci_read_config_byte(lpc_dev, CRVML_REG_GPIOEN, &dev_en);
189         if (!(dev_en & CRVML_GPIOEN_BIT)) {
190                 printk(KERN_ERR
191                        "Carillo Ranch GPIO device was not enabled.\n");
192                 pci_dev_put(lpc_dev);
193                 return -ENODEV;
194         }
195
196         crp->cr_backlight_device = backlight_device_register("cr-backlight",
197                                                              &pdev->dev, NULL,
198                                                              &cr_backlight_ops);
199         if (IS_ERR(crp->cr_backlight_device)) {
200                 pci_dev_put(lpc_dev);
201                 return PTR_ERR(crp->cr_backlight_device);
202         }
203
204         crp->cr_lcd_device = lcd_device_register("cr-lcd",
205                                                         &pdev->dev,
206                                                         &cr_lcd_ops);
207
208         if (IS_ERR(crp->cr_lcd_device)) {
209                 pci_dev_put(lpc_dev);
210                 return PTR_ERR(crp->cr_backlight_device);
211         }
212
213         pci_read_config_dword(lpc_dev, CRVML_REG_GPIOBAR,
214                               &gpio_bar);
215         gpio_bar &= ~0x3F;
216
217         crp->cr_backlight_device->props.power = FB_BLANK_UNBLANK;
218         crp->cr_backlight_device->props.brightness = 0;
219         crp->cr_backlight_device->props.max_brightness = 0;
220         cr_backlight_set_intensity(crp->cr_backlight_device);
221
222         cr_lcd_set_power(crp->cr_lcd_device, FB_BLANK_UNBLANK);
223
224         platform_set_drvdata(pdev, crp);
225
226         return 0;
227 }
228
229 static int cr_backlight_remove(struct platform_device *pdev)
230 {
231         struct cr_panel *crp = platform_get_drvdata(pdev);
232         crp->cr_backlight_device->props.power = FB_BLANK_POWERDOWN;
233         crp->cr_backlight_device->props.brightness = 0;
234         crp->cr_backlight_device->props.max_brightness = 0;
235         cr_backlight_set_intensity(crp->cr_backlight_device);
236         cr_lcd_set_power(crp->cr_lcd_device, FB_BLANK_POWERDOWN);
237         backlight_device_unregister(crp->cr_backlight_device);
238         lcd_device_unregister(crp->cr_lcd_device);
239         pci_dev_put(lpc_dev);
240
241         return 0;
242 }
243
244 static struct platform_driver cr_backlight_driver = {
245         .probe = cr_backlight_probe,
246         .remove = cr_backlight_remove,
247         .driver = {
248                    .name = "cr_backlight",
249                    },
250 };
251
252 static struct platform_device *crp;
253
254 static int __init cr_backlight_init(void)
255 {
256         int ret = platform_driver_register(&cr_backlight_driver);
257
258         if (!ret) {
259                 crp = platform_device_alloc("cr_backlight", -1);
260                 if (!crp)
261                         return -ENOMEM;
262
263                 ret = platform_device_add(crp);
264
265                 if (ret) {
266                         platform_device_put(crp);
267                         platform_driver_unregister(&cr_backlight_driver);
268                 }
269         }
270
271         printk("Carillo Ranch Backlight Driver Initialized.\n");
272
273         return ret;
274 }
275
276 static void __exit cr_backlight_exit(void)
277 {
278         platform_device_unregister(crp);
279         platform_driver_unregister(&cr_backlight_driver);
280 }
281
282 module_init(cr_backlight_init);
283 module_exit(cr_backlight_exit);
284
285 MODULE_AUTHOR("Tungsten Graphics Inc.");
286 MODULE_DESCRIPTION("Carillo Ranch Backlight Driver");
287 MODULE_LICENSE("GPL");