Remove obsolete #include <linux/config.h>
[linux-2.6] / arch / powerpc / platforms / powermac / pfunc_base.c
1 #include <linux/types.h>
2 #include <linux/init.h>
3 #include <linux/delay.h>
4 #include <linux/kernel.h>
5 #include <linux/interrupt.h>
6 #include <linux/spinlock.h>
7
8 #include <asm/pmac_feature.h>
9 #include <asm/pmac_pfunc.h>
10
11 #undef DEBUG
12 #ifdef DEBUG
13 #define DBG(fmt...)     printk(fmt)
14 #else
15 #define DBG(fmt...)
16 #endif
17
18 static irqreturn_t macio_gpio_irq(int irq, void *data, struct pt_regs *regs)
19 {
20         pmf_do_irq(data);
21
22         return IRQ_HANDLED;
23 }
24
25 static int macio_do_gpio_irq_enable(struct pmf_function *func)
26 {
27         if (func->node->n_intrs < 1)
28                 return -EINVAL;
29
30         return request_irq(func->node->intrs[0].line, macio_gpio_irq, 0,
31                            func->node->name, func);
32 }
33
34 static int macio_do_gpio_irq_disable(struct pmf_function *func)
35 {
36         if (func->node->n_intrs < 1)
37                 return -EINVAL;
38
39         free_irq(func->node->intrs[0].line, func);
40         return 0;
41 }
42
43 static int macio_do_gpio_write(PMF_STD_ARGS, u8 value, u8 mask)
44 {
45         u8 __iomem *addr = (u8 __iomem *)func->driver_data;
46         unsigned long flags;
47         u8 tmp;
48
49         /* Check polarity */
50         if (args && args->count && !args->u[0].v)
51                 value = ~value;
52
53         /* Toggle the GPIO */
54         spin_lock_irqsave(&feature_lock, flags);
55         tmp = readb(addr);
56         tmp = (tmp & ~mask) | (value & mask);
57         DBG("Do write 0x%02x to GPIO %s (%p)\n",
58             tmp, func->node->full_name, addr);
59         writeb(tmp, addr);
60         spin_unlock_irqrestore(&feature_lock, flags);
61
62         return 0;
63 }
64
65 static int macio_do_gpio_read(PMF_STD_ARGS, u8 mask, int rshift, u8 xor)
66 {
67         u8 __iomem *addr = (u8 __iomem *)func->driver_data;
68         u32 value;
69
70         /* Check if we have room for reply */
71         if (args == NULL || args->count == 0 || args->u[0].p == NULL)
72                 return -EINVAL;
73
74         value = readb(addr);
75         *args->u[0].p = ((value & mask) >> rshift) ^ xor;
76
77         return 0;
78 }
79
80 static int macio_do_delay(PMF_STD_ARGS, u32 duration)
81 {
82         /* assume we can sleep ! */
83         msleep((duration + 999) / 1000);
84         return 0;
85 }
86
87 static struct pmf_handlers macio_gpio_handlers = {
88         .irq_enable     = macio_do_gpio_irq_enable,
89         .irq_disable    = macio_do_gpio_irq_disable,
90         .write_gpio     = macio_do_gpio_write,
91         .read_gpio      = macio_do_gpio_read,
92         .delay          = macio_do_delay,
93 };
94
95 static void macio_gpio_init_one(struct macio_chip *macio)
96 {
97         struct device_node *gparent, *gp;
98
99         /*
100          * Find the "gpio" parent node
101          */
102
103         for (gparent = NULL;
104              (gparent = of_get_next_child(macio->of_node, gparent)) != NULL;)
105                 if (strcmp(gparent->name, "gpio") == 0)
106                         break;
107         if (gparent == NULL)
108                 return;
109
110         DBG("Installing GPIO functions for macio %s\n",
111             macio->of_node->full_name);
112
113         /*
114          * Ok, got one, we dont need anything special to track them down, so
115          * we just create them all
116          */
117         for (gp = NULL; (gp = of_get_next_child(gparent, gp)) != NULL;) {
118                 u32 *reg = (u32 *)get_property(gp, "reg", NULL);
119                 unsigned long offset;
120                 if (reg == NULL)
121                         continue;
122                 offset = *reg;
123                 /* Deal with old style device-tree. We can safely hard code the
124                  * offset for now too even if it's a bit gross ...
125                  */
126                 if (offset < 0x50)
127                         offset += 0x50;
128                 offset += (unsigned long)macio->base;
129                 pmf_register_driver(gp, &macio_gpio_handlers, (void *)offset);
130         }
131
132         DBG("Calling initial GPIO functions for macio %s\n",
133             macio->of_node->full_name);
134
135         /* And now we run all the init ones */
136         for (gp = NULL; (gp = of_get_next_child(gparent, gp)) != NULL;)
137                 pmf_do_functions(gp, NULL, 0, PMF_FLAGS_ON_INIT, NULL);
138
139         /* Note: We do not at this point implement the "at sleep" or "at wake"
140          * functions. I yet to find any for GPIOs anyway
141          */
142 }
143
144 static int macio_do_write_reg32(PMF_STD_ARGS, u32 offset, u32 value, u32 mask)
145 {
146         struct macio_chip *macio = func->driver_data;
147         unsigned long flags;
148
149         spin_lock_irqsave(&feature_lock, flags);
150         MACIO_OUT32(offset, (MACIO_IN32(offset) & ~mask) | (value & mask));
151         spin_unlock_irqrestore(&feature_lock, flags);
152         return 0;
153 }
154
155 static int macio_do_read_reg32(PMF_STD_ARGS, u32 offset)
156 {
157         struct macio_chip *macio = func->driver_data;
158
159         /* Check if we have room for reply */
160         if (args == NULL || args->count == 0 || args->u[0].p == NULL)
161                 return -EINVAL;
162
163         *args->u[0].p = MACIO_IN32(offset);
164         return 0;
165 }
166
167 static int macio_do_write_reg8(PMF_STD_ARGS, u32 offset, u8 value, u8 mask)
168 {
169         struct macio_chip *macio = func->driver_data;
170         unsigned long flags;
171
172         spin_lock_irqsave(&feature_lock, flags);
173         MACIO_OUT8(offset, (MACIO_IN8(offset) & ~mask) | (value & mask));
174         spin_unlock_irqrestore(&feature_lock, flags);
175         return 0;
176 }
177
178 static int macio_do_read_reg8(PMF_STD_ARGS, u32 offset)
179 {
180         struct macio_chip *macio = func->driver_data;
181
182         /* Check if we have room for reply */
183         if (args == NULL || args->count == 0 || args->u[0].p == NULL)
184                 return -EINVAL;
185
186         *((u8 *)(args->u[0].p)) = MACIO_IN8(offset);
187         return 0;
188 }
189
190 static int macio_do_read_reg32_msrx(PMF_STD_ARGS, u32 offset, u32 mask,
191                                     u32 shift, u32 xor)
192 {
193         struct macio_chip *macio = func->driver_data;
194
195         /* Check if we have room for reply */
196         if (args == NULL || args->count == 0 || args->u[0].p == NULL)
197                 return -EINVAL;
198
199         *args->u[0].p = ((MACIO_IN32(offset) & mask) >> shift) ^ xor;
200         return 0;
201 }
202
203 static int macio_do_read_reg8_msrx(PMF_STD_ARGS, u32 offset, u32 mask,
204                                    u32 shift, u32 xor)
205 {
206         struct macio_chip *macio = func->driver_data;
207
208         /* Check if we have room for reply */
209         if (args == NULL || args->count == 0 || args->u[0].p == NULL)
210                 return -EINVAL;
211
212         *((u8 *)(args->u[0].p)) = ((MACIO_IN8(offset) & mask) >> shift) ^ xor;
213         return 0;
214 }
215
216 static int macio_do_write_reg32_slm(PMF_STD_ARGS, u32 offset, u32 shift,
217                                     u32 mask)
218 {
219         struct macio_chip *macio = func->driver_data;
220         unsigned long flags;
221         u32 tmp, val;
222
223         /* Check args */
224         if (args == NULL || args->count == 0)
225                 return -EINVAL;
226
227         spin_lock_irqsave(&feature_lock, flags);
228         tmp = MACIO_IN32(offset);
229         val = args->u[0].v << shift;
230         tmp = (tmp & ~mask) | (val & mask);
231         MACIO_OUT32(offset, tmp);
232         spin_unlock_irqrestore(&feature_lock, flags);
233         return 0;
234 }
235
236 static int macio_do_write_reg8_slm(PMF_STD_ARGS, u32 offset, u32 shift,
237                                    u32 mask)
238 {
239         struct macio_chip *macio = func->driver_data;
240         unsigned long flags;
241         u32 tmp, val;
242
243         /* Check args */
244         if (args == NULL || args->count == 0)
245                 return -EINVAL;
246
247         spin_lock_irqsave(&feature_lock, flags);
248         tmp = MACIO_IN8(offset);
249         val = args->u[0].v << shift;
250         tmp = (tmp & ~mask) | (val & mask);
251         MACIO_OUT8(offset, tmp);
252         spin_unlock_irqrestore(&feature_lock, flags);
253         return 0;
254 }
255
256 static struct pmf_handlers macio_mmio_handlers = {
257         .write_reg32            = macio_do_write_reg32,
258         .read_reg32             = macio_do_read_reg32,
259         .write_reg8             = macio_do_write_reg8,
260         .read_reg32             = macio_do_read_reg8,
261         .read_reg32_msrx        = macio_do_read_reg32_msrx,
262         .read_reg8_msrx         = macio_do_read_reg8_msrx,
263         .write_reg32_slm        = macio_do_write_reg32_slm,
264         .write_reg8_slm         = macio_do_write_reg8_slm,
265         .delay                  = macio_do_delay,
266 };
267
268 static void macio_mmio_init_one(struct macio_chip *macio)
269 {
270         DBG("Installing MMIO functions for macio %s\n",
271             macio->of_node->full_name);
272
273         pmf_register_driver(macio->of_node, &macio_mmio_handlers, macio);
274 }
275
276 static struct device_node *unin_hwclock;
277
278 static int unin_do_write_reg32(PMF_STD_ARGS, u32 offset, u32 value, u32 mask)
279 {
280         unsigned long flags;
281
282         spin_lock_irqsave(&feature_lock, flags);
283         /* This is fairly bogus in darwin, but it should work for our needs
284          * implemeted that way:
285          */
286         UN_OUT(offset, (UN_IN(offset) & ~mask) | (value & mask));
287         spin_unlock_irqrestore(&feature_lock, flags);
288         return 0;
289 }
290
291
292 static struct pmf_handlers unin_mmio_handlers = {
293         .write_reg32            = unin_do_write_reg32,
294         .delay                  = macio_do_delay,
295 };
296
297 static void uninorth_install_pfunc(void)
298 {
299         struct device_node *np;
300
301         DBG("Installing functions for UniN %s\n",
302             uninorth_node->full_name);
303
304         /*
305          * Install handlers for the bridge itself
306          */
307         pmf_register_driver(uninorth_node, &unin_mmio_handlers, NULL);
308         pmf_do_functions(uninorth_node, NULL, 0, PMF_FLAGS_ON_INIT, NULL);
309
310
311         /*
312          * Install handlers for the hwclock child if any
313          */
314         for (np = NULL; (np = of_get_next_child(uninorth_node, np)) != NULL;)
315                 if (strcmp(np->name, "hw-clock") == 0) {
316                         unin_hwclock = np;
317                         break;
318                 }
319         if (unin_hwclock) {
320                 DBG("Installing functions for UniN clock %s\n",
321                     unin_hwclock->full_name);
322                 pmf_register_driver(unin_hwclock, &unin_mmio_handlers, NULL);
323                 pmf_do_functions(unin_hwclock, NULL, 0, PMF_FLAGS_ON_INIT,
324                                  NULL);
325         }
326 }
327
328 /* We export this as the SMP code might init us early */
329 int __init pmac_pfunc_base_install(void)
330 {
331         static int pfbase_inited;
332         int i;
333
334         if (pfbase_inited)
335                 return 0;
336         pfbase_inited = 1;
337
338         if (!machine_is(powermac))
339                 return 0;
340
341         DBG("Installing base platform functions...\n");
342
343         /*
344          * Locate mac-io chips and install handlers
345          */
346         for (i = 0 ; i < MAX_MACIO_CHIPS; i++) {
347                 if (macio_chips[i].of_node) {
348                         macio_mmio_init_one(&macio_chips[i]);
349                         macio_gpio_init_one(&macio_chips[i]);
350                 }
351         }
352
353         /*
354          * Install handlers for northbridge and direct mapped hwclock
355          * if any. We do not implement the config space access callback
356          * which is only ever used for functions that we do not call in
357          * the current driver (enabling/disabling cells in U2, mostly used
358          * to restore the PCI settings, we do that differently)
359          */
360         if (uninorth_node && uninorth_base)
361                 uninorth_install_pfunc();
362
363         DBG("All base functions installed\n");
364
365         return 0;
366 }
367
368 arch_initcall(pmac_pfunc_base_install);
369
370 #ifdef CONFIG_PM
371
372 /* Those can be called by pmac_feature. Ultimately, I should use a sysdev
373  * or a device, but for now, that's good enough until I sort out some
374  * ordering issues. Also, we do not bother with GPIOs, as so far I yet have
375  * to see a case where a GPIO function has the on-suspend or on-resume bit
376  */
377 void pmac_pfunc_base_suspend(void)
378 {
379         int i;
380
381         for (i = 0 ; i < MAX_MACIO_CHIPS; i++) {
382                 if (macio_chips[i].of_node)
383                         pmf_do_functions(macio_chips[i].of_node, NULL, 0,
384                                          PMF_FLAGS_ON_SLEEP, NULL);
385         }
386         if (uninorth_node)
387                 pmf_do_functions(uninorth_node, NULL, 0,
388                                  PMF_FLAGS_ON_SLEEP, NULL);
389         if (unin_hwclock)
390                 pmf_do_functions(unin_hwclock, NULL, 0,
391                                  PMF_FLAGS_ON_SLEEP, NULL);
392 }
393
394 void pmac_pfunc_base_resume(void)
395 {
396         int i;
397
398         if (unin_hwclock)
399                 pmf_do_functions(unin_hwclock, NULL, 0,
400                                  PMF_FLAGS_ON_WAKE, NULL);
401         if (uninorth_node)
402                 pmf_do_functions(uninorth_node, NULL, 0,
403                                  PMF_FLAGS_ON_WAKE, NULL);
404         for (i = 0 ; i < MAX_MACIO_CHIPS; i++) {
405                 if (macio_chips[i].of_node)
406                         pmf_do_functions(macio_chips[i].of_node, NULL, 0,
407                                          PMF_FLAGS_ON_WAKE, NULL);
408         }
409 }
410
411 #endif /* CONFIG_PM */