viafb: suspend/resume for GPIOs
[linux-2.6.git] / drivers / video / via / via-gpio.c
1 /*
2  * Support for viafb GPIO ports.
3  *
4  * Copyright 2009 Jonathan Corbet <corbet@lwn.net>
5  * Distributable under version 2 of the GNU General Public License.
6  */
7
8 #include <linux/spinlock.h>
9 #include <linux/gpio.h>
10 #include <linux/platform_device.h>
11 #include <linux/via-core.h>
12 #include <linux/via-gpio.h>
13
14 /*
15  * The ports we know about.  Note that the port-25 gpios are not
16  * mentioned in the datasheet.
17  */
18
19 struct viafb_gpio {
20         char *vg_name;  /* Data sheet name */
21         u16 vg_io_port;
22         u8  vg_port_index;
23         int  vg_mask_shift;
24 };
25
26 static struct viafb_gpio viafb_all_gpios[] = {
27         {
28                 .vg_name = "VGPIO0",  /* Guess - not in datasheet */
29                 .vg_io_port = VIASR,
30                 .vg_port_index = 0x25,
31                 .vg_mask_shift = 1
32         },
33         {
34                 .vg_name = "VGPIO1",
35                 .vg_io_port = VIASR,
36                 .vg_port_index = 0x25,
37                 .vg_mask_shift = 0
38         },
39         {
40                 .vg_name = "VGPIO2",  /* aka DISPCLKI0 */
41                 .vg_io_port = VIASR,
42                 .vg_port_index = 0x2c,
43                 .vg_mask_shift = 1
44         },
45         {
46                 .vg_name = "VGPIO3",  /* aka DISPCLKO0 */
47                 .vg_io_port = VIASR,
48                 .vg_port_index = 0x2c,
49                 .vg_mask_shift = 0
50         },
51         {
52                 .vg_name = "VGPIO4",  /* DISPCLKI1 */
53                 .vg_io_port = VIASR,
54                 .vg_port_index = 0x3d,
55                 .vg_mask_shift = 1
56         },
57         {
58                 .vg_name = "VGPIO5",  /* DISPCLKO1 */
59                 .vg_io_port = VIASR,
60                 .vg_port_index = 0x3d,
61                 .vg_mask_shift = 0
62         },
63 };
64
65 #define VIAFB_NUM_GPIOS ARRAY_SIZE(viafb_all_gpios)
66
67 /*
68  * This structure controls the active GPIOs, which may be a subset
69  * of those which are known.
70  */
71
72 struct viafb_gpio_cfg {
73         struct gpio_chip gpio_chip;
74         struct viafb_dev *vdev;
75         struct viafb_gpio *active_gpios[VIAFB_NUM_GPIOS];
76         const char *gpio_names[VIAFB_NUM_GPIOS];
77 };
78
79 /*
80  * GPIO access functions
81  */
82 static void via_gpio_set(struct gpio_chip *chip, unsigned int nr,
83                          int value)
84 {
85         struct viafb_gpio_cfg *cfg = container_of(chip,
86                                                   struct viafb_gpio_cfg,
87                                                   gpio_chip);
88         u8 reg;
89         struct viafb_gpio *gpio;
90         unsigned long flags;
91
92         spin_lock_irqsave(&cfg->vdev->reg_lock, flags);
93         gpio = cfg->active_gpios[nr];
94         reg = via_read_reg(VIASR, gpio->vg_port_index);
95         reg |= 0x40 << gpio->vg_mask_shift;  /* output enable */
96         if (value)
97                 reg |= 0x10 << gpio->vg_mask_shift;
98         else
99                 reg &= ~(0x10 << gpio->vg_mask_shift);
100         via_write_reg(VIASR, gpio->vg_port_index, reg);
101         spin_unlock_irqrestore(&cfg->vdev->reg_lock, flags);
102 }
103
104 static int via_gpio_dir_out(struct gpio_chip *chip, unsigned int nr,
105                             int value)
106 {
107         via_gpio_set(chip, nr, value);
108         return 0;
109 }
110
111 /*
112  * Set the input direction.  I'm not sure this is right; we should
113  * be able to do input without disabling output.
114  */
115 static int via_gpio_dir_input(struct gpio_chip *chip, unsigned int nr)
116 {
117         struct viafb_gpio_cfg *cfg = container_of(chip,
118                                                   struct viafb_gpio_cfg,
119                                                   gpio_chip);
120         struct viafb_gpio *gpio;
121         unsigned long flags;
122
123         spin_lock_irqsave(&cfg->vdev->reg_lock, flags);
124         gpio = cfg->active_gpios[nr];
125         via_write_reg_mask(VIASR, gpio->vg_port_index, 0,
126                         0x40 << gpio->vg_mask_shift);
127         spin_unlock_irqrestore(&cfg->vdev->reg_lock, flags);
128         return 0;
129 }
130
131 static int via_gpio_get(struct gpio_chip *chip, unsigned int nr)
132 {
133         struct viafb_gpio_cfg *cfg = container_of(chip,
134                                                   struct viafb_gpio_cfg,
135                                                   gpio_chip);
136         u8 reg;
137         struct viafb_gpio *gpio;
138         unsigned long flags;
139
140         spin_lock_irqsave(&cfg->vdev->reg_lock, flags);
141         gpio = cfg->active_gpios[nr];
142         reg = via_read_reg(VIASR, gpio->vg_port_index);
143         spin_unlock_irqrestore(&cfg->vdev->reg_lock, flags);
144         return reg & (0x04 << gpio->vg_mask_shift);
145 }
146
147
148 static struct viafb_gpio_cfg gpio_config = {
149         .gpio_chip = {
150                 .label = "VIAFB onboard GPIO",
151                 .owner = THIS_MODULE,
152                 .direction_output = via_gpio_dir_out,
153                 .set = via_gpio_set,
154                 .direction_input = via_gpio_dir_input,
155                 .get = via_gpio_get,
156                 .base = -1,
157                 .ngpio = 0,
158                 .can_sleep = 0
159         }
160 };
161
162 /*
163  * Manage the software enable bit.
164  */
165 static void viafb_gpio_enable(struct viafb_gpio *gpio)
166 {
167         via_write_reg_mask(VIASR, gpio->vg_port_index, 0x02, 0x02);
168 }
169
170 static void viafb_gpio_disable(struct viafb_gpio *gpio)
171 {
172         via_write_reg_mask(VIASR, gpio->vg_port_index, 0, 0x02);
173 }
174
175 #ifdef CONFIG_PM
176
177 static int viafb_gpio_suspend(void *private)
178 {
179         return 0;
180 }
181
182 static int viafb_gpio_resume(void *private)
183 {
184         int i;
185
186         for (i = 0; i < gpio_config.gpio_chip.ngpio; i += 2)
187                 viafb_gpio_enable(gpio_config.active_gpios[i]);
188         return 0;
189 }
190
191 static struct viafb_pm_hooks viafb_gpio_pm_hooks = {
192         .suspend = viafb_gpio_suspend,
193         .resume = viafb_gpio_resume
194 };
195 #endif /* CONFIG_PM */
196
197 /*
198  * Look up a specific gpio and return the number it was assigned.
199  */
200 int viafb_gpio_lookup(const char *name)
201 {
202         int i;
203
204         for (i = 0; i < gpio_config.gpio_chip.ngpio; i++)
205                 if (!strcmp(name, gpio_config.active_gpios[i]->vg_name))
206                         return gpio_config.gpio_chip.base + i;
207         return -1;
208 }
209 EXPORT_SYMBOL_GPL(viafb_gpio_lookup);
210
211 /*
212  * Platform device stuff.
213  */
214 static __devinit int viafb_gpio_probe(struct platform_device *platdev)
215 {
216         struct viafb_dev *vdev = platdev->dev.platform_data;
217         struct via_port_cfg *port_cfg = vdev->port_cfg;
218         int i, ngpio = 0, ret;
219         struct viafb_gpio *gpio;
220         unsigned long flags;
221
222         /*
223          * Set up entries for all GPIOs which have been configured to
224          * operate as such (as opposed to as i2c ports).
225          */
226         for (i = 0; i < VIAFB_NUM_PORTS; i++) {
227                 if (port_cfg[i].mode != VIA_MODE_GPIO)
228                         continue;
229                 for (gpio = viafb_all_gpios;
230                      gpio < viafb_all_gpios + VIAFB_NUM_GPIOS; gpio++)
231                         if (gpio->vg_port_index == port_cfg[i].ioport_index) {
232                                 gpio_config.active_gpios[ngpio] = gpio;
233                                 gpio_config.gpio_names[ngpio] = gpio->vg_name;
234                                 ngpio++;
235                         }
236         }
237         gpio_config.gpio_chip.ngpio = ngpio;
238         gpio_config.gpio_chip.names = gpio_config.gpio_names;
239         gpio_config.vdev = vdev;
240         if (ngpio == 0) {
241                 printk(KERN_INFO "viafb: no GPIOs configured\n");
242                 return 0;
243         }
244         /*
245          * Enable the ports.  They come in pairs, with a single
246          * enable bit for both.
247          */
248         spin_lock_irqsave(&gpio_config.vdev->reg_lock, flags);
249         for (i = 0; i < ngpio; i += 2)
250                 viafb_gpio_enable(gpio_config.active_gpios[i]);
251         spin_unlock_irqrestore(&gpio_config.vdev->reg_lock, flags);
252         /*
253          * Get registered.
254          */
255         gpio_config.gpio_chip.base = -1;  /* Dynamic */
256         ret = gpiochip_add(&gpio_config.gpio_chip);
257         if (ret) {
258                 printk(KERN_ERR "viafb: failed to add gpios (%d)\n", ret);
259                 gpio_config.gpio_chip.ngpio = 0;
260         }
261 #ifdef CONFIG_PM
262         viafb_pm_register(&viafb_gpio_pm_hooks);
263 #endif
264         return ret;
265 }
266
267
268 static int viafb_gpio_remove(struct platform_device *platdev)
269 {
270         unsigned long flags;
271         int ret = 0, i;
272
273 #ifdef CONFIG_PM
274         viafb_pm_unregister(&viafb_gpio_pm_hooks);
275 #endif
276
277         /*
278          * Get unregistered.
279          */
280         if (gpio_config.gpio_chip.ngpio > 0) {
281                 ret = gpiochip_remove(&gpio_config.gpio_chip);
282                 if (ret) { /* Somebody still using it? */
283                         printk(KERN_ERR "Viafb: GPIO remove failed\n");
284                         return ret;
285                 }
286         }
287         /*
288          * Disable the ports.
289          */
290         spin_lock_irqsave(&gpio_config.vdev->reg_lock, flags);
291         for (i = 0; i < gpio_config.gpio_chip.ngpio; i += 2)
292                 viafb_gpio_disable(gpio_config.active_gpios[i]);
293         gpio_config.gpio_chip.ngpio = 0;
294         spin_unlock_irqrestore(&gpio_config.vdev->reg_lock, flags);
295         return ret;
296 }
297
298 static struct platform_driver via_gpio_driver = {
299         .driver = {
300                 .name = "viafb-gpio",
301         },
302         .probe = viafb_gpio_probe,
303         .remove = viafb_gpio_remove,
304 };
305
306 int viafb_gpio_init(void)
307 {
308         return platform_driver_register(&via_gpio_driver);
309 }
310
311 void viafb_gpio_exit(void)
312 {
313         platform_driver_unregister(&via_gpio_driver);
314 }