Fix a lockup on some PPC machines running an SMP kernel - we were
[opensuse:kernel.git] / arch / ppc / platforms / pmac_feature.c
1 /*
2  * BK Id: %F% %I% %G% %U% %#%
3  */
4 /*
5  *  arch/ppc/platforms/pmac_feature.c
6  *
7  *  Copyright (C) 1996-2001 Paul Mackerras (paulus@cs.anu.edu.au)
8  *                          Ben. Herrenschmidt (benh@kernel.crashing.org)
9  *
10  *  This program is free software; you can redistribute it and/or
11  *  modify it under the terms of the GNU General Public License
12  *  as published by the Free Software Foundation; either version
13  *  2 of the License, or (at your option) any later version.
14  *  
15  *  TODO: 
16  *  
17  *   - Replace mdelay with some schedule loop if possible
18  *   - Shorten some obfuscated delays on some routines (like modem
19  *     power)
20  *
21  */
22 #include <linux/config.h>
23 #include <linux/types.h>
24 #include <linux/init.h>
25 #include <linux/delay.h>
26 #include <linux/kernel.h>
27 #include <linux/sched.h>
28 #include <linux/spinlock.h>
29 #include <linux/adb.h>
30 #include <linux/pmu.h>
31 #include <asm/sections.h>
32 #include <asm/errno.h>
33 #include <asm/ohare.h>
34 #include <asm/heathrow.h>
35 #include <asm/keylargo.h>
36 #include <asm/uninorth.h>
37 #include <asm/io.h>
38 #include <asm/prom.h>
39 #include <asm/machdep.h>
40 #include <asm/pmac_feature.h>
41 #include <asm/dbdma.h>
42
43 #undef DEBUG_FEATURE
44
45 #ifdef DEBUG_FEATURE
46 #define DBG(fmt,...) printk(KERN_DEBUG fmt)
47 #else
48 #define DBG(fmt,...)
49 #endif
50
51 /* Exported from arch/ppc/kernel/idle.c */
52 extern unsigned long powersave_nap;
53
54 /*
55  * We use a single global lock to protect accesses. Each driver has
56  * to take care of it's own locking
57  */
58 static spinlock_t feature_lock  __pmacdata = SPIN_LOCK_UNLOCKED;
59
60 #define LOCK(flags)     spin_lock_irqsave(&feature_lock, flags);
61 #define UNLOCK(flags)   spin_unlock_irqrestore(&feature_lock, flags);
62
63 /*
64  * Helper functions regarding the various flavors of mac-io
65  */
66  
67 #define MAX_MACIO_CHIPS         2
68
69 enum {
70         macio_unknown = 0,
71         macio_grand_central,
72         macio_ohare,
73         macio_ohareII,
74         macio_heathrow,
75         macio_gatwick,
76         macio_paddington,
77         macio_keylargo,
78         macio_pangea
79 };
80
81 static const char* macio_names[] __pmacdata = 
82 {
83         "Unknown",
84         "Grand Central",
85         "OHare",
86         "OHareII",
87         "Heathrow",
88         "Gatwick",
89         "Paddington",
90         "Keylargo",
91         "Pangea"
92 };
93
94 static struct macio_chip
95 {
96         struct device_node*     of_node;
97         int                     type;
98         int                     rev;
99         volatile u32*           base;
100         unsigned long           flags;
101 } macio_chips[MAX_MACIO_CHIPS]  __pmacdata;
102
103 #define MACIO_FLAG_SCCA_ON      0x00000001
104 #define MACIO_FLAG_SCCB_ON      0x00000002
105 #define MACIO_FLAG_SCC_LOCKED   0x00000004
106 #define MACIO_FLAG_AIRPORT_ON   0x00000010
107 #define MACIO_FLAG_FW_SUPPORTED 0x00000020
108
109 static struct macio_chip* __pmac
110 macio_find(struct device_node* child, int type)
111 {
112         while(child) {
113                 int     i;
114         
115                 for (i=0; i < MAX_MACIO_CHIPS && macio_chips[i].of_node; i++)
116                         if (child == macio_chips[i].of_node &&
117                             (!type || macio_chips[i].type == type))
118                                 return &macio_chips[i];
119                 child = child->parent;
120         }
121         return NULL;
122 }
123
124 #define MACIO_FCR32(macio, r)   ((macio)->base + ((r) >> 2))
125 #define MACIO_FCR8(macio, r)    (((volatile u8*)((macio)->base)) + (r))
126
127 #define MACIO_IN32(r)           (in_le32(MACIO_FCR32(macio,r)))
128 #define MACIO_OUT32(r,v)        (out_le32(MACIO_FCR32(macio,r), (v)))
129 #define MACIO_BIS(r,v)          (MACIO_OUT32((r), MACIO_IN32(r) | (v)))
130 #define MACIO_BIC(r,v)          (MACIO_OUT32((r), MACIO_IN32(r) & ~(v)))
131 #define MACIO_IN8(r)            (in_8(MACIO_FCR8(macio,r)))
132 #define MACIO_OUT8(r,v)         (out_8(MACIO_FCR8(macio,r), (v)))
133
134 /*
135  * Uninorth reg. access. Note that Uni-N regs are big endian
136  */
137  
138 #define UN_REG(r)       (uninorth_base + ((r) >> 2))
139 #define UN_IN(r)        (in_be32(UN_REG(r)))
140 #define UN_OUT(r,v)     (out_be32(UN_REG(r), (v)))
141 #define UN_BIS(r,v)     (UN_OUT((r), UN_IN(r) | (v)))
142 #define UN_BIC(r,v)     (UN_OUT((r), UN_IN(r) & ~(v)))
143
144 static struct device_node* uninorth_node __pmacdata;
145 static u32* uninorth_base __pmacdata;
146 static u32 uninorth_rev __pmacdata;
147
148
149 /*
150  * For each motherboard family, we have a table of functions pointers
151  * that handle the various features.
152  */
153
154 typedef int (*feature_call)(struct device_node* node, int param, int value);
155
156 struct feature_table_entry {
157         unsigned int    selector;       
158         feature_call    function;
159 };
160
161 struct pmac_mb_def
162 {
163         const char*                     model_string;
164         const char*                     model_name;
165         int                             model_id;
166         struct feature_table_entry*     features;
167         unsigned long                   board_flags;
168 };
169 static struct pmac_mb_def pmac_mb __pmacdata;
170
171 /*
172  * Here are the chip specific feature functions
173  */
174
175 static inline int __pmac
176 simple_feature_tweak(struct device_node* node, int type, int reg, u32 mask, int value)
177 {
178         struct macio_chip*      macio;
179         unsigned long           flags;
180         
181         macio = macio_find(node, type);
182         if (!macio)
183                 return -ENODEV;
184         LOCK(flags);
185         if (value)
186                 MACIO_BIS(reg, mask);
187         else
188                 MACIO_BIC(reg, mask);
189         (void)MACIO_IN32(reg);
190         UNLOCK(flags);
191
192         return 0;
193 }
194
195 static int __pmac
196 generic_scc_enable(struct device_node* node, u32 enable_mask, u32 reset_mask,
197         int param, int value)
198 {
199         struct macio_chip*      macio;
200         unsigned long           chan_mask;
201         unsigned long           fcr;
202         unsigned long           flags;
203         
204         macio = macio_find(node, 0);
205         if (!macio)
206                 return -ENODEV;
207         if (!strcmp(node->name, "ch-a"))
208                 chan_mask = MACIO_FLAG_SCCA_ON;
209         else if (!strcmp(node->name, "ch-b"))
210                 chan_mask = MACIO_FLAG_SCCB_ON;
211         else
212                 return -ENODEV;
213
214         if (value) {
215                 LOCK(flags);
216                 fcr = MACIO_IN32(OHARE_FCR);
217                 /* Check if scc cell need enabling */
218                 if (!(fcr & OH_SCC_ENABLE)) {
219                         fcr |= enable_mask;
220                         MACIO_OUT32(OHARE_FCR, fcr);
221                         fcr |= reset_mask;
222                         MACIO_OUT32(OHARE_FCR, fcr);
223                         UNLOCK(flags);
224                         (void)MACIO_IN32(OHARE_FCR);
225                         mdelay(15);
226                         LOCK(flags);
227                         fcr &= ~reset_mask;
228                         MACIO_OUT32(OHARE_FCR, fcr);
229                 }
230                 if (chan_mask & MACIO_FLAG_SCCA_ON)
231                         fcr |= OH_SCCA_IO;
232                 if (chan_mask & MACIO_FLAG_SCCB_ON)
233                         fcr |= OH_SCCB_IO;
234                 MACIO_OUT32(OHARE_FCR, fcr);
235                 macio->flags |= chan_mask;
236                 UNLOCK(flags);
237                 if (param & PMAC_SCC_FLAG_XMON)
238                         macio->flags |= MACIO_FLAG_SCC_LOCKED;
239         } else {
240                 if (macio->flags & MACIO_FLAG_SCC_LOCKED)
241                         return -EPERM;
242                 LOCK(flags);
243                 fcr = MACIO_IN32(OHARE_FCR);
244                 if (chan_mask & MACIO_FLAG_SCCA_ON)
245                         fcr &= ~OH_SCCA_IO;
246                 if (chan_mask & MACIO_FLAG_SCCB_ON)
247                         fcr &= ~OH_SCCB_IO;
248                 MACIO_OUT32(OHARE_FCR, fcr);
249                 if ((fcr & (OH_SCCA_IO | OH_SCCB_IO)) == 0) {
250                         fcr &= ~enable_mask;
251                         MACIO_OUT32(OHARE_FCR, fcr);
252                 }
253                 macio->flags &= ~(chan_mask);
254                 UNLOCK(flags);
255                 mdelay(10);
256         }
257         return 0;
258 }
259
260 static int __pmac
261 ohare_scc_enable(struct device_node* node, int param, int value)
262 {
263         int rc;
264
265 #ifdef CONFIG_ADB_PMU
266         if (value && (param & 0xfff) == PMAC_SCC_IRDA)
267                 pmu_enable_irled(1);
268 #endif /* CONFIG_ADB_PMU */             
269         rc = generic_scc_enable(node, OH_SCC_ENABLE, OH_SCC_RESET, param, value);
270 #ifdef CONFIG_ADB_PMU
271         if ((param & 0xfff) == PMAC_SCC_IRDA && (rc || !value))
272                 pmu_enable_irled(0);
273 #endif /* CONFIG_ADB_PMU */             
274         return rc;
275 }
276
277 static int __pmac
278 ohare_floppy_enable(struct device_node* node, int param, int value)
279 {
280         return simple_feature_tweak(node, macio_ohare,
281                 OHARE_FCR, OH_FLOPPY_ENABLE, value);
282 }
283
284 static int __pmac
285 ohare_mesh_enable(struct device_node* node, int param, int value)
286 {
287         return simple_feature_tweak(node, macio_ohare,
288                 OHARE_FCR, OH_MESH_ENABLE, value);
289 }
290
291 static int __pmac
292 ohare_ide_enable(struct device_node* node, int param, int value)
293 {
294         switch(param) {
295             case 0:
296                 /* For some reason, setting the bit in set_initial_features()
297                  * doesn't stick. I'm still investigating... --BenH.
298                  */
299                 if (value)
300                         simple_feature_tweak(node, macio_ohare,
301                                 OHARE_FCR, OH_IOBUS_ENABLE, 1);
302                 return simple_feature_tweak(node, macio_ohare,
303                         OHARE_FCR, OH_IDE0_ENABLE, value);
304             case 1:
305                 return simple_feature_tweak(node, macio_ohare,
306                         OHARE_FCR, OH_BAY_IDE_ENABLE, value);
307             default:
308                 return -ENODEV;
309         }
310 }
311
312 static int __pmac
313 ohare_ide_reset(struct device_node* node, int param, int value)
314 {
315         switch(param) {
316             case 0:
317                 return simple_feature_tweak(node, macio_ohare,
318                         OHARE_FCR, OH_IDE0_RESET_N, !value);
319             case 1:
320                 return simple_feature_tweak(node, macio_ohare,
321                         OHARE_FCR, OH_IDE1_RESET_N, !value);
322             default:
323                 return -ENODEV;
324         }
325 }
326
327 static int __pmac
328 ohare_sleep_state(struct device_node* node, int param, int value)
329 {
330         struct macio_chip*      macio = &macio_chips[0];
331
332         if ((pmac_mb.board_flags & PMAC_MB_CAN_SLEEP) == 0)
333                 return -EPERM;
334         if (value) {
335                 MACIO_BIC(OHARE_FCR, OH_IOBUS_ENABLE);
336         } else {
337                 MACIO_BIS(OHARE_FCR, OH_IOBUS_ENABLE);
338         }
339         
340         return 0;
341 }
342
343 static int __pmac
344 heathrow_scc_enable(struct device_node* node, int param, int value)
345 {
346         int rc;
347         
348 #ifdef CONFIG_ADB_PMU
349         if (value && param == PMAC_SCC_IRDA)
350                 pmu_enable_irled(1);
351 #endif /* CONFIG_ADB_PMU */             
352         /* Fixme: It's possible that wallstreet (heathrow) is different
353          * than other paddington machines. I still have to figure that
354          * out exactly, for now, the paddington values are used
355          */
356         rc = generic_scc_enable(node, HRW_SCC_ENABLE, PADD_RESET_SCC, param, value);
357 #ifdef CONFIG_ADB_PMU
358         if (param == PMAC_SCC_IRDA && (rc || !value))
359                 pmu_enable_irled(0);
360 #endif /* CONFIG_ADB_PMU */             
361         return rc;
362 }
363
364 static int __pmac
365 heathrow_modem_enable(struct device_node* node, int param, int value)
366 {
367         struct macio_chip*      macio;
368         u8                      gpio;
369         unsigned long           flags;
370         
371         macio = macio_find(node, macio_unknown);
372         if (!macio)
373                 return -ENODEV;
374         gpio = MACIO_IN8(HRW_GPIO_MODEM_RESET) & ~1;
375         if (!value) {
376                 LOCK(flags);
377                 MACIO_OUT8(HRW_GPIO_MODEM_RESET, gpio);
378                 UNLOCK(flags);
379                 (void)MACIO_IN8(HRW_GPIO_MODEM_RESET);
380                 mdelay(250);
381         }
382         if (pmac_mb.model_id != PMAC_TYPE_YOSEMITE &&
383             pmac_mb.model_id != PMAC_TYPE_YIKES) {
384                 LOCK(flags);
385                 /* We use the paddington values as they seem to work properly
386                  * on the wallstreet (heathrow) as well. I can't tell why we
387                  * had to flip them on older feature.c, the fact is that new
388                  * code uses the paddington values which are also the ones used
389                  * in Darwin, and that works on wallstreet !
390                  */
391                 if (value)
392                         MACIO_BIC(HEATHROW_FCR, PADD_MODEM_POWER_N);
393                 else
394                         MACIO_BIS(HEATHROW_FCR, PADD_MODEM_POWER_N);
395                 UNLOCK(flags);
396                 (void)MACIO_IN32(HEATHROW_FCR);
397                 mdelay(250);
398         }
399         if (value) {
400                 LOCK(flags);
401                 MACIO_OUT8(HRW_GPIO_MODEM_RESET, gpio | 1);
402                 (void)MACIO_IN8(HRW_GPIO_MODEM_RESET);
403                 UNLOCK(flags);
404                 mdelay(250);
405                 LOCK(flags);
406                 MACIO_OUT8(HRW_GPIO_MODEM_RESET, gpio);
407                 (void)MACIO_IN8(HRW_GPIO_MODEM_RESET);
408                 UNLOCK(flags);
409                 mdelay(250);
410                 LOCK(flags);
411                 MACIO_OUT8(HRW_GPIO_MODEM_RESET, gpio | 1);
412                 (void)MACIO_IN8(HRW_GPIO_MODEM_RESET);
413                 UNLOCK(flags);
414         }
415         return 0;
416 }
417
418 static int __pmac
419 heathrow_floppy_enable(struct device_node* node, int param, int value)
420 {
421         return simple_feature_tweak(node, macio_unknown,
422                 HEATHROW_FCR,
423                 HRW_SWIM_ENABLE|HRW_BAY_FLOPPY_ENABLE,
424                 value);
425 }
426
427 static int __pmac
428 heathrow_mesh_enable(struct device_node* node, int param, int value)
429 {
430         struct macio_chip*      macio;
431         unsigned long           flags;
432         
433         macio = macio_find(node, macio_unknown);
434         if (!macio)
435                 return -ENODEV;
436         LOCK(flags);
437         /* Set clear mesh cell enable */
438         if (value)
439                 MACIO_BIS(HEATHROW_FCR, HRW_MESH_ENABLE);
440         else
441                 MACIO_BIC(HEATHROW_FCR, HRW_MESH_ENABLE);
442         (void)MACIO_IN32(HEATHROW_FCR);
443         udelay(10);
444         /* Set/Clear termination power (todo: test ! the bit value
445          * used by Darwin doesn't seem to match what we used so
446          * far. If you experience problems, turn #if 1 into #if 0
447          * and tell me about it --BenH.
448          */
449 #if 1
450         if (value)
451                 MACIO_BIC(HEATHROW_MBCR, 0x00000004);
452         else
453                 MACIO_BIS(HEATHROW_MBCR, 0x00000004);
454 #else
455         if (value)
456                 MACIO_BIC(HEATHROW_MBCR, 0x00040000);
457         else
458                 MACIO_BIS(HEATHROW_MBCR, 0x00040000);
459 #endif          
460         (void)MACIO_IN32(HEATHROW_MBCR);
461         udelay(10);
462         UNLOCK(flags);
463
464         return 0;
465 }
466
467 static int __pmac
468 heathrow_ide_enable(struct device_node* node, int param, int value)
469 {
470         switch(param) {
471             case 0:
472                 return simple_feature_tweak(node, macio_unknown,
473                         HEATHROW_FCR, HRW_IDE0_ENABLE, value);
474             case 1:
475                 return simple_feature_tweak(node, macio_unknown,
476                         HEATHROW_FCR, HRW_BAY_IDE_ENABLE, value);
477             default:
478                 return -ENODEV;
479         }
480 }
481
482 static int __pmac
483 heathrow_ide_reset(struct device_node* node, int param, int value)
484 {
485         switch(param) {
486             case 0:
487                 return simple_feature_tweak(node, macio_unknown,
488                         HEATHROW_FCR, HRW_IDE0_RESET_N, !value);
489             case 1:
490                 return simple_feature_tweak(node, macio_unknown,
491                         HEATHROW_FCR, HRW_IDE1_RESET_N, !value);
492             default:
493                 return -ENODEV;
494         }
495 }
496
497 static int __pmac
498 heathrow_bmac_enable(struct device_node* node, int param, int value)
499 {
500         struct macio_chip*      macio;
501         unsigned long           flags;
502         
503         macio = macio_find(node, 0);
504         if (!macio)
505                 return -ENODEV;
506         if (value) {
507                 LOCK(flags);
508                 MACIO_BIS(HEATHROW_FCR, HRW_BMAC_IO_ENABLE);
509                 MACIO_BIS(HEATHROW_FCR, HRW_BMAC_RESET);
510                 UNLOCK(flags);
511                 (void)MACIO_IN32(HEATHROW_FCR);
512                 mdelay(10);
513                 LOCK(flags);
514                 MACIO_BIC(HEATHROW_FCR, HRW_BMAC_RESET);
515                 UNLOCK(flags);
516                 (void)MACIO_IN32(HEATHROW_FCR);
517                 mdelay(10);
518         } else {
519                 LOCK(flags);
520                 MACIO_BIC(HEATHROW_FCR, HRW_BMAC_IO_ENABLE);
521                 UNLOCK(flags);
522         }
523         return 0;
524 }
525
526 static int __pmac
527 heathrow_sound_enable(struct device_node* node, int param, int value)
528 {
529         struct macio_chip*      macio;
530         unsigned long           flags;
531
532         /* B&W G3 and Yikes don't support that properly (the
533          * sound appear to never come back after beeing shut down).
534          */
535         if (pmac_mb.model_id == PMAC_TYPE_YOSEMITE ||
536             pmac_mb.model_id == PMAC_TYPE_YIKES)
537                 return 0;
538         
539         macio = macio_find(node, 0);
540         if (!macio)
541                 return -ENODEV;
542         if (value) {
543                 LOCK(flags);
544                 MACIO_BIS(HEATHROW_FCR, HRW_SOUND_CLK_ENABLE);
545                 MACIO_BIC(HEATHROW_FCR, HRW_SOUND_POWER_N);
546                 UNLOCK(flags);
547                 (void)MACIO_IN32(HEATHROW_FCR);
548         } else {
549                 LOCK(flags);
550                 MACIO_BIS(HEATHROW_FCR, HRW_SOUND_POWER_N);
551                 MACIO_BIC(HEATHROW_FCR, HRW_SOUND_CLK_ENABLE);
552                 UNLOCK(flags);
553         }
554         return 0;
555 }
556
557 static u32 save_fcr[5] __pmacdata;
558 static u32 save_mbcr __pmacdata;
559 static u32 save_gpio_levels[2] __pmacdata;
560 static u8 save_gpio_extint[KEYLARGO_GPIO_EXTINT_CNT] __pmacdata;
561 static u8 save_gpio_normal[KEYLARGO_GPIO_CNT] __pmacdata;
562 static u32 save_unin_clock_ctl __pmacdata;
563 static struct dbdma_regs save_dbdma[13] __pmacdata;
564 static struct dbdma_regs save_alt_dbdma[13] __pmacdata;
565
566 static void __pmac
567 dbdma_save(struct macio_chip* macio, struct dbdma_regs* save)
568 {
569         int i;
570         
571         /* Save state & config of DBDMA channels */
572         for (i=0; i<13; i++) {
573                 volatile struct dbdma_regs* chan = (volatile struct dbdma_regs*)
574                         (macio->base + ((0x8000+i*0x100)>>2));
575                 save[i].cmdptr_hi = in_le32(&chan->cmdptr_hi);
576                 save[i].cmdptr = in_le32(&chan->cmdptr);
577                 save[i].intr_sel = in_le32(&chan->intr_sel);
578                 save[i].br_sel = in_le32(&chan->br_sel);
579                 save[i].wait_sel = in_le32(&chan->wait_sel);
580         }
581 }
582
583 static void __pmac
584 dbdma_restore(struct macio_chip* macio, struct dbdma_regs* save)
585 {
586         int i;
587         
588         /* Save state & config of DBDMA channels */
589         for (i=0; i<13; i++) {
590                 volatile struct dbdma_regs* chan = (volatile struct dbdma_regs*)
591                         (macio->base + ((0x8000+i*0x100)>>2));
592                 out_le32(&chan->control, (ACTIVE|DEAD|WAKE|FLUSH|PAUSE|RUN)<<16);
593                 while (in_le32(&chan->status) & ACTIVE)
594                         mb();
595                 out_le32(&chan->cmdptr_hi, save[i].cmdptr_hi);
596                 out_le32(&chan->cmdptr, save[i].cmdptr);
597                 out_le32(&chan->intr_sel, save[i].intr_sel);
598                 out_le32(&chan->br_sel, save[i].br_sel);
599                 out_le32(&chan->wait_sel, save[i].wait_sel);
600         }
601 }
602
603 static void __pmac
604 heathrow_sleep(struct macio_chip* macio, int secondary)
605 {
606         if (secondary) {
607                 dbdma_save(macio, save_alt_dbdma);
608                 save_fcr[2] = MACIO_IN32(0x38);
609                 save_fcr[3] = MACIO_IN32(0x3c);
610         } else {
611                 dbdma_save(macio, save_dbdma);
612                 save_fcr[0] = MACIO_IN32(0x38);
613                 save_fcr[1] = MACIO_IN32(0x3c);
614                 save_mbcr = MACIO_IN32(0x34);
615                 /* Make sure sound is shut down */
616                 MACIO_BIS(HEATHROW_FCR, HRW_SOUND_POWER_N);
617                 MACIO_BIC(HEATHROW_FCR, HRW_SOUND_CLK_ENABLE);
618                 /* This seems to be necessary as well or the fan
619                  * keeps coming up and battery drains fast */
620                 MACIO_BIC(HEATHROW_FCR, HRW_IOBUS_ENABLE);
621         }
622         /* Make sure modem is shut down */
623         MACIO_OUT8(HRW_GPIO_MODEM_RESET,
624                 MACIO_IN8(HRW_GPIO_MODEM_RESET) & ~1);
625         MACIO_BIS(HEATHROW_FCR, PADD_MODEM_POWER_N);
626         MACIO_BIC(HEATHROW_FCR, OH_SCCA_IO|OH_SCCB_IO|HRW_SCC_ENABLE);
627
628         /* Let things settle */
629         (void)MACIO_IN32(HEATHROW_FCR);
630         mdelay(1);
631 }
632
633 static void __pmac
634 heathrow_wakeup(struct macio_chip* macio, int secondary)
635 {
636         if (secondary) {
637                 MACIO_OUT32(0x38, save_fcr[2]);
638                 (void)MACIO_IN32(0x38);
639                 mdelay(1);
640                 MACIO_OUT32(0x3c, save_fcr[3]);
641                 (void)MACIO_IN32(0x38);
642                 mdelay(10);
643                 dbdma_restore(macio, save_alt_dbdma);
644         } else {
645                 MACIO_OUT32(0x38, save_fcr[0] | HRW_IOBUS_ENABLE);
646                 (void)MACIO_IN32(0x38);
647                 mdelay(1);
648                 MACIO_OUT32(0x3c, save_fcr[1]);
649                 (void)MACIO_IN32(0x38);
650                 mdelay(1);
651                 MACIO_OUT32(0x34, save_mbcr);
652                 (void)MACIO_IN32(0x38);
653                 mdelay(10);
654                 dbdma_restore(macio, save_dbdma);
655         }
656 }
657
658 static int __pmac
659 heathrow_sleep_state(struct device_node* node, int param, int value)
660 {
661         if ((pmac_mb.board_flags & PMAC_MB_CAN_SLEEP) == 0)
662                 return -EPERM;
663         if (value == 1) {
664                 if (macio_chips[1].type == macio_gatwick)
665                         heathrow_sleep(&macio_chips[0], 1);
666                 heathrow_sleep(&macio_chips[0], 0);
667         } else if (value == 0) {
668                 heathrow_wakeup(&macio_chips[0], 0);
669                 if (macio_chips[1].type == macio_gatwick)
670                         heathrow_wakeup(&macio_chips[0], 1);
671         }
672         return 0;
673 }
674
675 static int __pmac
676 core99_scc_enable(struct device_node* node, int param, int value)
677 {
678         struct macio_chip*      macio;
679         unsigned long           flags;
680         unsigned long           chan_mask;
681         u32                     fcr;
682         
683         macio = macio_find(node, 0);
684         if (!macio)
685                 return -ENODEV;
686         if (!strcmp(node->name, "ch-a"))
687                 chan_mask = MACIO_FLAG_SCCA_ON;
688         else if (!strcmp(node->name, "ch-b"))
689                 chan_mask = MACIO_FLAG_SCCB_ON;
690         else
691                 return -ENODEV;
692
693         if (value) {
694                 int need_reset_scc = 0;
695                 int need_reset_irda = 0;
696                 
697                 LOCK(flags);
698                 fcr = MACIO_IN32(KEYLARGO_FCR0);
699                 /* Check if scc cell need enabling */
700                 if (!(fcr & KL0_SCC_CELL_ENABLE)) {
701                         fcr |= KL0_SCC_CELL_ENABLE;
702                         need_reset_scc = 1;
703                 }
704                 if (chan_mask & MACIO_FLAG_SCCA_ON) {
705                         fcr |= KL0_SCCA_ENABLE;
706                         /* Don't enable line drivers for I2S modem */
707                         if ((param & 0xfff) == PMAC_SCC_I2S1)
708                                 fcr &= ~KL0_SCC_A_INTF_ENABLE;
709                         else
710                                 fcr |= KL0_SCC_A_INTF_ENABLE;
711                 }
712                 if (chan_mask & MACIO_FLAG_SCCB_ON) {
713                         fcr |= KL0_SCCB_ENABLE;
714                         /* Perform irda specific inits */
715                         if ((param & 0xfff) == PMAC_SCC_IRDA) {
716                                 fcr &= ~KL0_SCC_B_INTF_ENABLE;
717                                 fcr |= KL0_IRDA_ENABLE;
718                                 fcr |= KL0_IRDA_CLK32_ENABLE | KL0_IRDA_CLK19_ENABLE;
719                                 fcr |= KL0_IRDA_SOURCE1_SEL;
720                                 fcr &= ~(KL0_IRDA_FAST_CONNECT|KL0_IRDA_DEFAULT1|KL0_IRDA_DEFAULT0);
721                                 fcr &= ~(KL0_IRDA_SOURCE2_SEL|KL0_IRDA_HIGH_BAND);
722                                 need_reset_irda = 1;
723                         } else
724                                 fcr |= KL0_SCC_B_INTF_ENABLE;
725                 }
726                 MACIO_OUT32(KEYLARGO_FCR0, fcr);
727                 macio->flags |= chan_mask;
728                 if (need_reset_scc)  {
729                         MACIO_BIS(KEYLARGO_FCR0, KL0_SCC_RESET);
730                         (void)MACIO_IN32(KEYLARGO_FCR0);
731                         UNLOCK(flags);
732                         mdelay(15);
733                         LOCK(flags);
734                         MACIO_BIC(KEYLARGO_FCR0, KL0_SCC_RESET);
735                 }
736                 if (need_reset_irda)  {
737                         MACIO_BIS(KEYLARGO_FCR0, KL0_IRDA_RESET);
738                         (void)MACIO_IN32(KEYLARGO_FCR0);
739                         UNLOCK(flags);
740                         mdelay(15);
741                         LOCK(flags);
742                         MACIO_BIC(KEYLARGO_FCR0, KL0_IRDA_RESET);
743                 }
744                 UNLOCK(flags);
745                 if (param & PMAC_SCC_FLAG_XMON)
746                         macio->flags |= MACIO_FLAG_SCC_LOCKED;
747         } else {
748                 if (macio->flags & MACIO_FLAG_SCC_LOCKED)
749                         return -EPERM;
750                 LOCK(flags);
751                 fcr = MACIO_IN32(KEYLARGO_FCR0);
752                 if (chan_mask & MACIO_FLAG_SCCA_ON)
753                         fcr &= ~KL0_SCCA_ENABLE;
754                 if (chan_mask & MACIO_FLAG_SCCB_ON) {
755                         fcr &= ~KL0_SCCB_ENABLE;
756                         /* Perform irda specific clears */
757                         if ((param & 0xfff) == PMAC_SCC_IRDA) {
758                                 fcr &= ~KL0_IRDA_ENABLE;
759                                 fcr &= ~(KL0_IRDA_CLK32_ENABLE | KL0_IRDA_CLK19_ENABLE);
760                                 fcr &= ~(KL0_IRDA_FAST_CONNECT|KL0_IRDA_DEFAULT1|KL0_IRDA_DEFAULT0);
761                                 fcr &= ~(KL0_IRDA_SOURCE1_SEL|KL0_IRDA_SOURCE2_SEL|KL0_IRDA_HIGH_BAND);
762                         }
763                 }
764                 MACIO_OUT32(KEYLARGO_FCR0, fcr);
765                 if ((fcr & (KL0_SCCA_ENABLE | KL0_SCCB_ENABLE)) == 0) {
766                         fcr &= ~KL0_SCC_CELL_ENABLE;
767                         MACIO_OUT32(KEYLARGO_FCR0, fcr);
768                 }
769                 macio->flags &= ~(chan_mask);
770                 UNLOCK(flags);
771                 mdelay(10);
772         }
773         return 0;
774 }
775
776 static int __pmac
777 core99_modem_enable(struct device_node* node, int param, int value)
778 {
779         struct macio_chip*      macio;
780         u8                      gpio;
781         unsigned long           flags;
782         
783         macio = macio_find(node, 0);
784         if (!macio)
785                 return -ENODEV;
786         gpio = MACIO_IN8(KL_GPIO_MODEM_RESET);
787         gpio |= KEYLARGO_GPIO_OUTPUT_ENABLE;
788         gpio &= ~KEYLARGO_GPIO_OUTOUT_DATA;
789         
790         if (!value) {
791                 LOCK(flags);
792                 MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio);
793                 UNLOCK(flags);
794                 (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
795                 mdelay(250);
796         }
797         LOCK(flags);
798         if (value) {
799                 MACIO_BIC(KEYLARGO_FCR2, KL2_ALT_DATA_OUT);
800                 UNLOCK(flags);
801                 (void)MACIO_IN32(KEYLARGO_FCR2);
802                 mdelay(250);
803         } else {
804                 MACIO_BIS(KEYLARGO_FCR2, KL2_ALT_DATA_OUT);
805                 UNLOCK(flags);
806         }
807         if (value) {
808                 LOCK(flags);
809                 MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio | KEYLARGO_GPIO_OUTOUT_DATA);
810                 (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
811                 UNLOCK(flags); mdelay(250); LOCK(flags);
812                 MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio);
813                 (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
814                 UNLOCK(flags); mdelay(250); LOCK(flags);
815                 MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio | KEYLARGO_GPIO_OUTOUT_DATA);
816                 (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
817                 UNLOCK(flags); mdelay(250); LOCK(flags);
818         }
819         return 0;
820 }
821
822 static int __pmac
823 core99_ide_enable(struct device_node* node, int param, int value)
824 {
825         switch(param) {
826             case 0:
827                 return simple_feature_tweak(node, macio_unknown,
828                         KEYLARGO_FCR1, KL1_EIDE0_ENABLE, value);
829             case 1:
830                 return simple_feature_tweak(node, macio_unknown,
831                         KEYLARGO_FCR1, KL1_EIDE1_ENABLE, value);
832             case 2:
833                 return simple_feature_tweak(node, macio_unknown,
834                         KEYLARGO_FCR1, KL1_UIDE_ENABLE, value);
835             default:
836                 return -ENODEV;
837         }
838 }
839
840 static int __pmac
841 core99_ide_reset(struct device_node* node, int param, int value)
842 {
843         switch(param) {
844             case 0:
845                 return simple_feature_tweak(node, macio_unknown,
846                         KEYLARGO_FCR1, KL1_EIDE0_RESET_N, !value);
847             case 1:
848                 return simple_feature_tweak(node, macio_unknown,
849                         KEYLARGO_FCR1, KL1_EIDE1_RESET_N, !value);
850             case 2:
851                 return simple_feature_tweak(node, macio_unknown,
852                         KEYLARGO_FCR1, KL1_UIDE_RESET_N, !value);
853             default:
854                 return -ENODEV;
855         }
856 }
857
858 static int __pmac
859 core99_gmac_enable(struct device_node* node, int param, int value)
860 {
861         unsigned long flags;
862
863         LOCK(flags);
864         if (value)
865                 UN_BIS(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_GMAC);
866         else
867                 UN_BIC(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_GMAC);
868         (void)UN_IN(UNI_N_CLOCK_CNTL);
869         UNLOCK(flags);
870         udelay(20);
871
872         return 0;
873 }
874
875 static int __pmac
876 core99_gmac_phy_reset(struct device_node* node, int param, int value)
877 {
878         unsigned long flags;
879         struct macio_chip* macio;
880         
881         macio = &macio_chips[0];
882         if (macio->type != macio_keylargo && macio->type != macio_pangea)
883                 return -ENODEV;
884
885         LOCK(flags);
886         MACIO_OUT8(KL_GPIO_ETH_PHY_RESET, KEYLARGO_GPIO_OUTPUT_ENABLE);
887         (void)MACIO_IN8(KL_GPIO_ETH_PHY_RESET);
888         UNLOCK(flags);
889         mdelay(10);
890         LOCK(flags);
891         MACIO_OUT8(KL_GPIO_ETH_PHY_RESET, KEYLARGO_GPIO_OUTPUT_ENABLE
892                 | KEYLARGO_GPIO_OUTOUT_DATA);
893         UNLOCK(flags);
894         mdelay(10);
895
896         return 0;
897 }
898
899 static int __pmac
900 core99_sound_chip_enable(struct device_node* node, int param, int value)
901 {
902         struct macio_chip*      macio;
903         unsigned long           flags;
904         
905         macio = macio_find(node, 0);
906         if (!macio)
907                 return -ENODEV;
908
909         /* Do a better probe code, screamer G4 desktops &
910          * iMacs can do that too, add a recalibrate  in
911          * the driver as well
912          */
913         if (pmac_mb.model_id == PMAC_TYPE_PISMO ||
914             pmac_mb.model_id == PMAC_TYPE_TITANIUM) {
915                 LOCK(flags);
916                 if (value)
917                         MACIO_OUT8(KL_GPIO_SOUND_POWER,
918                                 KEYLARGO_GPIO_OUTPUT_ENABLE |
919                                 KEYLARGO_GPIO_OUTOUT_DATA);
920                 else
921                         MACIO_OUT8(KL_GPIO_SOUND_POWER,
922                                 KEYLARGO_GPIO_OUTPUT_ENABLE);
923                 (void)MACIO_IN8(KL_GPIO_SOUND_POWER);
924                 UNLOCK(flags);
925         }
926         return 0;
927 }
928
929 static int __pmac
930 core99_airport_enable(struct device_node* node, int param, int value)
931 {
932         struct macio_chip*      macio;
933         unsigned long           flags;
934         int                     state;
935         
936         macio = macio_find(node, 0);
937         if (!macio)
938                 return -ENODEV;
939         
940         /* Hint: we allow passing of macio itself for the sake of the
941          * sleep code
942          */
943         if (node != macio->of_node &&
944             (!node->parent || node->parent != macio->of_node))
945                 return -ENODEV;
946         state = (macio->flags & MACIO_FLAG_AIRPORT_ON) != 0;
947         if (value == state)
948                 return 0;
949         if (value) {
950                 /* This code is a reproduction of OF enable-cardslot
951                  * and init-wireless methods, slightly hacked until
952                  * I got it working.
953                  */
954                 LOCK(flags);
955                 MACIO_OUT8(KEYLARGO_GPIO_0+0xf, 5);
956                 (void)MACIO_IN8(KEYLARGO_GPIO_0+0xf);
957                 UNLOCK(flags);
958                 mdelay(10);
959                 LOCK(flags);
960                 MACIO_OUT8(KEYLARGO_GPIO_0+0xf, 4);
961                 (void)MACIO_IN8(KEYLARGO_GPIO_0+0xf);
962                 UNLOCK(flags);
963
964                 mdelay(10);
965
966                 LOCK(flags);
967                 MACIO_BIC(KEYLARGO_FCR2, KL2_CARDSEL_16);
968                 (void)MACIO_IN32(KEYLARGO_FCR2);
969                 udelay(10);
970                 MACIO_OUT8(KEYLARGO_GPIO_EXTINT_0+0xb, 0);
971                 (void)MACIO_IN8(KEYLARGO_GPIO_EXTINT_0+0xb);
972                 udelay(10);
973                 MACIO_OUT8(KEYLARGO_GPIO_EXTINT_0+0xa, 0x28);
974                 (void)MACIO_IN8(KEYLARGO_GPIO_EXTINT_0+0xa);
975                 udelay(10);
976                 MACIO_OUT8(KEYLARGO_GPIO_EXTINT_0+0xd, 0x28);
977                 (void)MACIO_IN8(KEYLARGO_GPIO_EXTINT_0+0xd);
978                 udelay(10);
979                 MACIO_OUT8(KEYLARGO_GPIO_0+0xd, 0x28);
980                 (void)MACIO_IN8(KEYLARGO_GPIO_0+0xd);
981                 udelay(10);
982                 MACIO_OUT8(KEYLARGO_GPIO_0+0xe, 0x28);
983                 (void)MACIO_IN8(KEYLARGO_GPIO_0+0xe);
984                 UNLOCK(flags);
985                 udelay(10);
986                 MACIO_OUT32(0x1c000, 0);
987                 mdelay(1);
988                 MACIO_OUT8(0x1a3e0, 0x41);
989                 (void)MACIO_IN8(0x1a3e0);
990                 udelay(10);
991                 LOCK(flags);
992                 MACIO_BIS(KEYLARGO_FCR2, KL2_CARDSEL_16);
993                 (void)MACIO_IN32(KEYLARGO_FCR2);
994                 UNLOCK(flags);
995                 mdelay(100);
996
997                 macio->flags |= MACIO_FLAG_AIRPORT_ON;
998         } else {
999                 LOCK(flags);
1000                 MACIO_BIC(KEYLARGO_FCR2, KL2_CARDSEL_16);
1001                 (void)MACIO_IN32(KEYLARGO_FCR2);
1002                 MACIO_OUT8(KL_GPIO_AIRPORT_0, 0);
1003                 MACIO_OUT8(KL_GPIO_AIRPORT_1, 0);
1004                 MACIO_OUT8(KL_GPIO_AIRPORT_2, 0);
1005                 MACIO_OUT8(KL_GPIO_AIRPORT_3, 0);
1006                 MACIO_OUT8(KL_GPIO_AIRPORT_4, 0);
1007                 (void)MACIO_IN8(KL_GPIO_AIRPORT_4);
1008                 UNLOCK(flags);
1009
1010                 macio->flags &= ~MACIO_FLAG_AIRPORT_ON;
1011         }
1012         return 0;
1013 }
1014
1015 #ifdef CONFIG_SMP
1016 static int __pmac
1017 core99_reset_cpu(struct device_node* node, int param, int value)
1018 {
1019         const int reset_lines[] = {     KL_GPIO_RESET_CPU0,
1020                                         KL_GPIO_RESET_CPU1,
1021                                         KL_GPIO_RESET_CPU2,
1022                                         KL_GPIO_RESET_CPU3 };
1023         int reset_io;
1024         unsigned long flags;
1025         struct macio_chip* macio;
1026         
1027         macio = &macio_chips[0];
1028         if (macio->type != macio_keylargo && macio->type != macio_pangea)
1029                 return -ENODEV;
1030         if (param > 3 || param < 0)
1031                 return -ENODEV;
1032
1033         reset_io = reset_lines[param];
1034         
1035         LOCK(flags);
1036         MACIO_OUT8(reset_io, KEYLARGO_GPIO_OUTPUT_ENABLE);
1037         (void)MACIO_IN8(reset_io);
1038         udelay(1);
1039         MACIO_OUT8(reset_io, KEYLARGO_GPIO_OUTPUT_ENABLE | KEYLARGO_GPIO_OUTOUT_DATA);
1040         (void)MACIO_IN8(reset_io);
1041         UNLOCK(flags);
1042
1043         return 0;
1044 }
1045 #endif /* CONFIG_SMP */
1046
1047 static int __pmac
1048 core99_usb_enable(struct device_node* node, int param, int value)
1049 {
1050         struct macio_chip* macio;
1051         unsigned long flags;
1052         char* prop;
1053         int number;
1054         u32 reg;
1055         
1056         macio = &macio_chips[0];
1057         if (macio->type != macio_keylargo && macio->type != macio_pangea)
1058                 return -ENODEV;
1059         
1060         prop = (char *)get_property(node, "AAPL,clock-id", NULL);
1061         if (!prop)
1062                 return -ENODEV;
1063         if (strncmp(prop, "usb0u048", strlen("usb0u048")) == 0)
1064                 number = 0;
1065         else if (strncmp(prop, "usb1u148", strlen("usb1u148")) == 0)
1066                 number = 2;
1067         else
1068                 return -ENODEV;
1069
1070         /* Sorry for the brute-force locking, but this is only used during
1071          * sleep and the timing seem to be critical
1072          */
1073         LOCK(flags);
1074         if (value) {
1075                 /* Turn ON */
1076                 if (number == 0) {
1077                         MACIO_BIC(KEYLARGO_FCR0, (KL0_USB0_PAD_SUSPEND0 | KL0_USB0_PAD_SUSPEND1));
1078                         (void)MACIO_IN32(KEYLARGO_FCR0);
1079                         UNLOCK(flags);
1080                         mdelay(1);
1081                         LOCK(flags);
1082                         MACIO_BIS(KEYLARGO_FCR0, KL0_USB0_CELL_ENABLE);
1083                 } else {
1084                         MACIO_BIC(KEYLARGO_FCR0, (KL0_USB1_PAD_SUSPEND0 | KL0_USB1_PAD_SUSPEND1));
1085                         UNLOCK(flags);
1086                         (void)MACIO_IN32(KEYLARGO_FCR0);
1087                         mdelay(1);
1088                         LOCK(flags);
1089                         MACIO_BIS(KEYLARGO_FCR0, KL0_USB1_CELL_ENABLE);
1090                 }
1091                 reg = MACIO_IN32(KEYLARGO_FCR4);
1092                 reg &=  ~(KL4_PORT_WAKEUP_ENABLE(number) | KL4_PORT_RESUME_WAKE_EN(number) |
1093                         KL4_PORT_CONNECT_WAKE_EN(number) | KL4_PORT_DISCONNECT_WAKE_EN(number));
1094                 reg &=  ~(KL4_PORT_WAKEUP_ENABLE(number+1) | KL4_PORT_RESUME_WAKE_EN(number+1) |
1095                         KL4_PORT_CONNECT_WAKE_EN(number+1) | KL4_PORT_DISCONNECT_WAKE_EN(number+1));
1096                 MACIO_OUT32(KEYLARGO_FCR4, reg);
1097                 (void)MACIO_IN32(KEYLARGO_FCR4);
1098                 udelay(10);
1099         } else {
1100                 /* Turn OFF */
1101                 reg = MACIO_IN32(KEYLARGO_FCR4);
1102                 reg |=  KL4_PORT_WAKEUP_ENABLE(number) | KL4_PORT_RESUME_WAKE_EN(number) |
1103                         KL4_PORT_CONNECT_WAKE_EN(number) | KL4_PORT_DISCONNECT_WAKE_EN(number);
1104                 reg |=  KL4_PORT_WAKEUP_ENABLE(number+1) | KL4_PORT_RESUME_WAKE_EN(number+1) |
1105                         KL4_PORT_CONNECT_WAKE_EN(number+1) | KL4_PORT_DISCONNECT_WAKE_EN(number+1);
1106                 MACIO_OUT32(KEYLARGO_FCR4, reg);
1107                 (void)MACIO_IN32(KEYLARGO_FCR4);
1108                 udelay(1);
1109                 if (number == 0) {
1110                         MACIO_BIC(KEYLARGO_FCR0, KL0_USB0_CELL_ENABLE);
1111                         (void)MACIO_IN32(KEYLARGO_FCR0);
1112                         udelay(1);
1113                         MACIO_BIS(KEYLARGO_FCR0, (KL0_USB0_PAD_SUSPEND0 | KL0_USB0_PAD_SUSPEND1));
1114                         (void)MACIO_IN32(KEYLARGO_FCR0);
1115                 } else {
1116                         MACIO_BIC(KEYLARGO_FCR0, KL0_USB1_CELL_ENABLE);
1117                         (void)MACIO_IN32(KEYLARGO_FCR0);
1118                         udelay(1);
1119                         MACIO_BIS(KEYLARGO_FCR0, (KL0_USB1_PAD_SUSPEND0 | KL0_USB1_PAD_SUSPEND1));
1120                         (void)MACIO_IN32(KEYLARGO_FCR0);
1121                 }
1122                 udelay(1);
1123         }
1124         UNLOCK(flags);
1125
1126         return 0;
1127 }
1128
1129 static int __pmac
1130 core99_firewire_enable(struct device_node* node, int param, int value)
1131 {
1132         unsigned long flags;
1133         struct macio_chip* macio;
1134
1135         macio = &macio_chips[0];
1136         if (macio->type != macio_keylargo && macio->type != macio_pangea)
1137                 return -ENODEV;
1138         if (!(macio->flags & MACIO_FLAG_FW_SUPPORTED))
1139                 return -ENODEV;
1140         
1141         LOCK(flags);
1142         if (value) {
1143                 UN_BIS(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_FW);
1144                 (void)UN_IN(UNI_N_CLOCK_CNTL);
1145         } else {
1146                 UN_BIC(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_FW);
1147                 (void)UN_IN(UNI_N_CLOCK_CNTL);
1148         }
1149         UNLOCK(flags);
1150         mdelay(1);
1151
1152         return 0;
1153 }
1154
1155 static int __pmac
1156 core99_firewire_cable_power(struct device_node* node, int param, int value)
1157 {
1158         unsigned long flags;
1159         struct macio_chip* macio;
1160
1161         /* Trick: we allow NULL node */
1162         if ((pmac_mb.board_flags & PMAC_MB_HAS_FW_POWER) == 0)
1163                 return -ENODEV;
1164         macio = &macio_chips[0];
1165         if (macio->type != macio_keylargo && macio->type != macio_pangea)
1166                 return -ENODEV;
1167         if (!(macio->flags & MACIO_FLAG_FW_SUPPORTED))
1168                 return -ENODEV;
1169         
1170         LOCK(flags);
1171         if (value) {
1172                 MACIO_OUT8(KL_GPIO_FW_CABLE_POWER , 0);
1173                 MACIO_IN8(KL_GPIO_FW_CABLE_POWER);
1174                 udelay(10);
1175         } else {
1176                 MACIO_OUT8(KL_GPIO_FW_CABLE_POWER , 4);
1177                 MACIO_IN8(KL_GPIO_FW_CABLE_POWER); udelay(10);
1178         }
1179         UNLOCK(flags);
1180         mdelay(1);
1181
1182         return 0;
1183 }
1184
1185 static int __pmac
1186 core99_read_gpio(struct device_node* node, int param, int value)
1187 {
1188         struct macio_chip* macio = &macio_chips[0];
1189         
1190         return MACIO_IN8(param);
1191 }
1192
1193
1194 static int __pmac
1195 core99_write_gpio(struct device_node* node, int param, int value)
1196 {
1197         struct macio_chip* macio = &macio_chips[0];
1198
1199         MACIO_OUT8(param, (u8)(value & 0xff));
1200         return 0;
1201 }
1202
1203 static void __pmac
1204 keylargo_shutdown(struct macio_chip* macio, int restart)
1205 {
1206         u32 temp;
1207
1208         mdelay(1);
1209         MACIO_BIS(KEYLARGO_FCR0, KL0_USB_REF_SUSPEND);
1210         (void)MACIO_IN32(KEYLARGO_FCR0);
1211         mdelay(100);
1212
1213         MACIO_BIC(KEYLARGO_FCR0,KL0_SCCA_ENABLE | KL0_SCCB_ENABLE |
1214                                 KL0_SCC_CELL_ENABLE |
1215                                 KL0_IRDA_ENABLE | KL0_IRDA_CLK32_ENABLE |
1216                                 KL0_IRDA_CLK19_ENABLE);
1217
1218         (void)MACIO_IN32(KEYLARGO_FCR0); udelay(10);
1219         MACIO_BIC(KEYLARGO_MBCR, KL_MBCR_MB0_DEV_MASK);
1220         (void)MACIO_IN32(KEYLARGO_MBCR); udelay(10);
1221
1222         MACIO_BIC(KEYLARGO_FCR1,
1223                 KL1_AUDIO_SEL_22MCLK | KL1_AUDIO_CLK_ENABLE_BIT |
1224                 KL1_AUDIO_CLK_OUT_ENABLE | KL1_AUDIO_CELL_ENABLE |
1225                 KL1_I2S0_CELL_ENABLE | KL1_I2S0_CLK_ENABLE_BIT |
1226                 KL1_I2S0_ENABLE | KL1_I2S1_CELL_ENABLE |
1227                 KL1_I2S1_CLK_ENABLE_BIT | KL1_I2S1_ENABLE |
1228                 KL1_EIDE0_ENABLE | KL1_EIDE0_RESET_N |
1229                 KL1_EIDE1_ENABLE | KL1_EIDE1_RESET_N |
1230                 KL1_UIDE_ENABLE);
1231         (void)MACIO_IN32(KEYLARGO_FCR1); udelay(10);
1232
1233         MACIO_BIS(KEYLARGO_FCR2, KL2_ALT_DATA_OUT);
1234         udelay(10);
1235         MACIO_BIC(KEYLARGO_FCR2, KL2_IOBUS_ENABLE);
1236         udelay(10);
1237         temp = MACIO_IN32(KEYLARGO_FCR3);
1238         if (macio->rev >= 2)
1239                 temp |= (KL3_SHUTDOWN_PLL2X | KL3_SHUTDOWN_PLL_TOTAL);
1240                 
1241         temp |= KL3_SHUTDOWN_PLLKW6 | KL3_SHUTDOWN_PLLKW4 |
1242                 KL3_SHUTDOWN_PLLKW35 | KL3_SHUTDOWN_PLLKW12;
1243         temp &= ~(KL3_CLK66_ENABLE | KL3_CLK49_ENABLE | KL3_CLK45_ENABLE
1244                 | KL3_CLK31_ENABLE | KL3_TIMER_CLK18_ENABLE | KL3_I2S1_CLK18_ENABLE
1245                 | KL3_I2S0_CLK18_ENABLE | KL3_VIA_CLK16_ENABLE);
1246         MACIO_OUT32(KEYLARGO_FCR3, temp);
1247         (void)MACIO_IN32(KEYLARGO_FCR3); udelay(10);
1248 }
1249
1250 static void __pmac
1251 pangea_shutdown(struct macio_chip* macio, int restart)
1252 {
1253         u32 temp;
1254
1255         MACIO_BIC(KEYLARGO_FCR0,KL0_SCCA_ENABLE | KL0_SCCB_ENABLE |
1256                                 KL0_SCC_CELL_ENABLE |
1257                                 KL0_USB0_CELL_ENABLE | KL0_USB1_CELL_ENABLE);
1258
1259         (void)MACIO_IN32(KEYLARGO_FCR0); udelay(10);
1260         MACIO_BIC(KEYLARGO_MBCR, KL_MBCR_MB0_DEV_MASK);
1261         (void)MACIO_IN32(KEYLARGO_MBCR); udelay(10);
1262
1263         MACIO_BIC(KEYLARGO_FCR1,
1264                 KL1_AUDIO_SEL_22MCLK | KL1_AUDIO_CLK_ENABLE_BIT |
1265                 KL1_AUDIO_CLK_OUT_ENABLE | KL1_AUDIO_CELL_ENABLE |
1266                 KL1_I2S0_CELL_ENABLE | KL1_I2S0_CLK_ENABLE_BIT |
1267                 KL1_I2S0_ENABLE | KL1_I2S1_CELL_ENABLE |
1268                 KL1_I2S1_CLK_ENABLE_BIT | KL1_I2S1_ENABLE |
1269                 KL1_UIDE_ENABLE);
1270         (void)MACIO_IN32(KEYLARGO_FCR1); udelay(10);
1271
1272         MACIO_BIS(KEYLARGO_FCR2, KL2_ALT_DATA_OUT);
1273         udelay(10);
1274         temp = MACIO_IN32(KEYLARGO_FCR3);
1275         temp |= KL3_SHUTDOWN_PLLKW6 | KL3_SHUTDOWN_PLLKW4 |
1276                 KL3_SHUTDOWN_PLLKW35;
1277         temp &= ~(KL3_CLK49_ENABLE | KL3_CLK45_ENABLE
1278                 | KL3_CLK31_ENABLE | KL3_TIMER_CLK18_ENABLE | KL3_I2S1_CLK18_ENABLE
1279                 | KL3_I2S0_CLK18_ENABLE | KL3_VIA_CLK16_ENABLE);
1280         MACIO_OUT32(KEYLARGO_FCR3, temp);
1281         (void)MACIO_IN32(KEYLARGO_FCR3); udelay(10);
1282 }
1283
1284 static int __pmac
1285 core99_sleep(void)
1286 {
1287         struct macio_chip* macio;
1288         int i;
1289
1290         macio = &macio_chips[0];
1291         if (macio->type != macio_keylargo && macio->type != macio_pangea)
1292                 return -ENODEV;
1293         
1294         /* We power off the wireless slot in case it was not done
1295          * by the driver. We don't power it on automatically however
1296          */
1297         if (macio->flags & MACIO_FLAG_AIRPORT_ON)
1298                 core99_airport_enable(macio->of_node, 0, 0);
1299
1300         /* We power off the FW cable. Should be done by the driver... */
1301         if (macio->flags & MACIO_FLAG_FW_SUPPORTED) {
1302                 core99_firewire_enable(NULL, 0, 0);
1303                 core99_firewire_cable_power(NULL, 0, 0);
1304         }
1305
1306         /* We make sure int. modem is off (in case driver lost it) */
1307         core99_modem_enable(macio->of_node, 0, 0);
1308         /* We make sure the sound is off as well */
1309         core99_sound_chip_enable(macio->of_node, 0, 0);
1310          
1311         /*
1312          * Save various bits of KeyLargo
1313          */
1314
1315         /* Save the state of the various GPIOs */
1316         save_gpio_levels[0] = MACIO_IN32(KEYLARGO_GPIO_LEVELS0);
1317         save_gpio_levels[1] = MACIO_IN32(KEYLARGO_GPIO_LEVELS1);
1318         for (i=0; i<KEYLARGO_GPIO_EXTINT_CNT; i++)
1319                 save_gpio_extint[i] = MACIO_IN8(KEYLARGO_GPIO_EXTINT_0+i);
1320         for (i=0; i<KEYLARGO_GPIO_CNT; i++)
1321                 save_gpio_normal[i] = MACIO_IN8(KEYLARGO_GPIO_0+i);
1322
1323         /* Save the FCRs */
1324         save_mbcr = MACIO_IN32(KEYLARGO_MBCR);
1325         save_fcr[0] = MACIO_IN32(KEYLARGO_FCR0);
1326         save_fcr[1] = MACIO_IN32(KEYLARGO_FCR1);
1327         save_fcr[2] = MACIO_IN32(KEYLARGO_FCR2);
1328         save_fcr[3] = MACIO_IN32(KEYLARGO_FCR3);
1329         save_fcr[4] = MACIO_IN32(KEYLARGO_FCR4);
1330
1331         /* Save state & config of DBDMA channels */
1332         dbdma_save(macio, save_dbdma);
1333         
1334         /*
1335          * Turn off as much as we can
1336          */
1337         if (macio->type == macio_pangea)
1338                 pangea_shutdown(macio, 0);
1339         else if (macio->type == macio_keylargo)
1340                 keylargo_shutdown(macio, 0);
1341         
1342         /* 
1343          * Put the host bridge to sleep
1344          */
1345
1346         save_unin_clock_ctl = UN_IN(UNI_N_CLOCK_CNTL);
1347         UN_OUT(UNI_N_CLOCK_CNTL, save_unin_clock_ctl &
1348                 ~(UNI_N_CLOCK_CNTL_GMAC|UNI_N_CLOCK_CNTL_FW/*|UNI_N_CLOCK_CNTL_PCI*/));
1349         udelay(100);
1350         UN_OUT(UNI_N_HWINIT_STATE, UNI_N_HWINIT_STATE_SLEEPING);
1351         UN_OUT(UNI_N_POWER_MGT, UNI_N_POWER_MGT_SLEEP);
1352
1353         /*
1354          * FIXME: A bit of black magic with OpenPIC (don't ask me why)
1355          */
1356         if (pmac_mb.model_id == PMAC_TYPE_SAWTOOTH) {
1357                 MACIO_BIS(0x506e0, 0x00400000);
1358                 MACIO_BIS(0x506e0, 0x80000000);
1359         }
1360         return 0;
1361 }
1362
1363 static int __pmac
1364 core99_wake_up(void)
1365 {
1366         struct macio_chip* macio;
1367         int i;
1368
1369         macio = &macio_chips[0];
1370         if (macio->type != macio_keylargo && macio->type != macio_pangea)
1371                 return -ENODEV;
1372
1373         /*
1374          * Wakeup the host bridge
1375          */
1376         UN_OUT(UNI_N_POWER_MGT, UNI_N_POWER_MGT_NORMAL);
1377         udelay(10);
1378         UN_OUT(UNI_N_HWINIT_STATE, UNI_N_HWINIT_STATE_RUNNING);
1379         udelay(10);
1380         
1381         /*
1382          * Restore KeyLargo
1383          */
1384          
1385         MACIO_OUT32(KEYLARGO_MBCR, save_mbcr);
1386         (void)MACIO_IN32(KEYLARGO_MBCR); udelay(10);
1387         MACIO_OUT32(KEYLARGO_FCR0, save_fcr[0]);
1388         (void)MACIO_IN32(KEYLARGO_FCR0); udelay(10);
1389         MACIO_OUT32(KEYLARGO_FCR1, save_fcr[1]);
1390         (void)MACIO_IN32(KEYLARGO_FCR1); udelay(10);
1391         MACIO_OUT32(KEYLARGO_FCR2, save_fcr[2]);
1392         (void)MACIO_IN32(KEYLARGO_FCR2); udelay(10);
1393         MACIO_OUT32(KEYLARGO_FCR3, save_fcr[3]);
1394         (void)MACIO_IN32(KEYLARGO_FCR3); udelay(10);
1395         MACIO_OUT32(KEYLARGO_FCR4, save_fcr[4]);
1396         (void)MACIO_IN32(KEYLARGO_FCR4); udelay(10);
1397
1398         dbdma_restore(macio, save_dbdma);
1399
1400         MACIO_OUT32(KEYLARGO_GPIO_LEVELS0, save_gpio_levels[0]);
1401         MACIO_OUT32(KEYLARGO_GPIO_LEVELS1, save_gpio_levels[1]);
1402         for (i=0; i<KEYLARGO_GPIO_EXTINT_CNT; i++)
1403                 MACIO_OUT8(KEYLARGO_GPIO_EXTINT_0+i, save_gpio_extint[i]);
1404         for (i=0; i<KEYLARGO_GPIO_CNT; i++)
1405                 MACIO_OUT8(KEYLARGO_GPIO_0+i, save_gpio_normal[i]);
1406
1407         /* FIXME more black magic with OpenPIC ... */
1408         if (pmac_mb.model_id == PMAC_TYPE_SAWTOOTH) {
1409                 MACIO_BIC(0x506e0, 0x00400000);
1410                 MACIO_BIC(0x506e0, 0x80000000);
1411         }
1412
1413         UN_OUT(UNI_N_CLOCK_CNTL, save_unin_clock_ctl);
1414         udelay(100);
1415
1416         return 0;
1417 }
1418
1419 static int __pmac
1420 core99_sleep_state(struct device_node* node, int param, int value)
1421 {
1422         if ((pmac_mb.board_flags & PMAC_MB_CAN_SLEEP) == 0)
1423                 return -EPERM;
1424         if (value == 1)
1425                 return core99_sleep();
1426         else if (value == 0)
1427                 return core99_wake_up();
1428         return 0;
1429 }
1430
1431 static int __pmac
1432 pangea_modem_enable(struct device_node* node, int param, int value)
1433 {
1434         struct macio_chip*      macio;
1435         u8                      gpio;
1436         unsigned long           flags;
1437         
1438         macio = macio_find(node, 0);
1439         if (!macio)
1440                 return -ENODEV;
1441         gpio = MACIO_IN8(KL_GPIO_MODEM_RESET);
1442         gpio |= KEYLARGO_GPIO_OUTPUT_ENABLE;
1443         gpio &= ~KEYLARGO_GPIO_OUTOUT_DATA;
1444         
1445         if (!value) {
1446                 LOCK(flags);
1447                 MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio);
1448                 UNLOCK(flags);
1449                 (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
1450                 mdelay(250);
1451         }
1452         LOCK(flags);
1453         if (value) {
1454                 MACIO_OUT8(KL_GPIO_MODEM_POWER,
1455                         KEYLARGO_GPIO_OUTPUT_ENABLE);
1456                 UNLOCK(flags);
1457                 (void)MACIO_IN32(KEYLARGO_FCR2);
1458                 mdelay(250);
1459         } else {
1460                 MACIO_OUT8(KL_GPIO_MODEM_POWER,
1461                         KEYLARGO_GPIO_OUTPUT_ENABLE | KEYLARGO_GPIO_OUTOUT_DATA);
1462                 UNLOCK(flags);
1463         }
1464         if (value) {
1465                 LOCK(flags);
1466                 MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio | KEYLARGO_GPIO_OUTOUT_DATA);
1467                 (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
1468                 UNLOCK(flags); mdelay(250); LOCK(flags);
1469                 MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio);
1470                 (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
1471                 UNLOCK(flags); mdelay(250); LOCK(flags);
1472                 MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio | KEYLARGO_GPIO_OUTOUT_DATA);
1473                 (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
1474                 UNLOCK(flags); mdelay(250); LOCK(flags);
1475         }
1476         return 0;
1477 }
1478
1479
1480 static int __pmac
1481 generic_get_mb_info(struct device_node* node, int param, int value)
1482 {
1483         switch(param) {
1484                 case PMAC_MB_INFO_MODEL:
1485                         return pmac_mb.model_id;
1486                 case PMAC_MB_INFO_FLAGS:
1487                         return pmac_mb.board_flags;
1488                 case PMAC_MB_INFO_NAME: 
1489                         /* hack hack hack... but should work */
1490                         return (int)pmac_mb.model_name;
1491         }
1492         return 0;
1493 }
1494
1495
1496 /* 
1497  * Table definitions
1498  */
1499  
1500 /* Used on any machine
1501  */
1502 static struct feature_table_entry any_features[]  __pmacdata = {
1503         { PMAC_FTR_GET_MB_INFO,         generic_get_mb_info },
1504         { 0, NULL }
1505 };
1506
1507 /* OHare based motherboards. Currently, we only use these on the
1508  * 2400,3400 and 3500 series powerbooks. Some older desktops seem
1509  * to have issues with turning on/off those asic cells
1510  */
1511 static struct feature_table_entry ohare_features[]  __pmacdata = {
1512         { PMAC_FTR_SCC_ENABLE,          ohare_scc_enable },
1513         { PMAC_FTR_SWIM3_ENABLE,        ohare_floppy_enable },
1514         { PMAC_FTR_MESH_ENABLE,         ohare_mesh_enable },
1515         { PMAC_FTR_IDE_ENABLE,          ohare_ide_enable},
1516         { PMAC_FTR_IDE_RESET,           ohare_ide_reset},
1517         { PMAC_FTR_SLEEP_STATE,         ohare_sleep_state },
1518         { 0, NULL }
1519 };
1520
1521 /* Heathrow desktop machines (Beige G3).
1522  * Separated as some features couldn't be properly tested
1523  * and the serial port control bits appear to confuse it.
1524  */
1525 static struct feature_table_entry heathrow_desktop_features[]  __pmacdata = {
1526         { PMAC_FTR_SWIM3_ENABLE,        heathrow_floppy_enable },
1527         { PMAC_FTR_MESH_ENABLE,         heathrow_mesh_enable },
1528         { PMAC_FTR_IDE_ENABLE,          heathrow_ide_enable },
1529         { PMAC_FTR_IDE_RESET,           heathrow_ide_reset },
1530         { PMAC_FTR_BMAC_ENABLE,         heathrow_bmac_enable },
1531         { 0, NULL }
1532 };
1533
1534 /* Heathrow based laptop, that is the Wallstreet and mainstreet
1535  * powerbooks.
1536  */
1537 static struct feature_table_entry heathrow_laptop_features[]  __pmacdata = {
1538         { PMAC_FTR_SCC_ENABLE,          heathrow_scc_enable },
1539         { PMAC_FTR_MODEM_ENABLE,        heathrow_modem_enable },
1540         { PMAC_FTR_SWIM3_ENABLE,        heathrow_floppy_enable },
1541         { PMAC_FTR_MESH_ENABLE,         heathrow_mesh_enable },
1542         { PMAC_FTR_IDE_ENABLE,          heathrow_ide_enable },
1543         { PMAC_FTR_IDE_RESET,           heathrow_ide_reset },
1544         { PMAC_FTR_BMAC_ENABLE,         heathrow_bmac_enable },
1545         { PMAC_FTR_SOUND_CHIP_ENABLE,   heathrow_sound_enable },
1546         { PMAC_FTR_SLEEP_STATE,         heathrow_sleep_state },
1547         { 0, NULL }
1548 };
1549
1550 /* Paddington based machines
1551  * The lombard (101) powerbook, first iMac models, B&W G3 and Yikes G4.
1552  */
1553 static struct feature_table_entry paddington_features[]  __pmacdata = {
1554         { PMAC_FTR_SCC_ENABLE,          heathrow_scc_enable },
1555         { PMAC_FTR_MODEM_ENABLE,        heathrow_modem_enable },
1556         { PMAC_FTR_SWIM3_ENABLE,        heathrow_floppy_enable },
1557         { PMAC_FTR_MESH_ENABLE,         heathrow_mesh_enable },
1558         { PMAC_FTR_IDE_ENABLE,          heathrow_ide_enable },
1559         { PMAC_FTR_IDE_RESET,           heathrow_ide_reset },
1560         { PMAC_FTR_BMAC_ENABLE,         heathrow_bmac_enable },
1561         { PMAC_FTR_SOUND_CHIP_ENABLE,   heathrow_sound_enable },
1562         { PMAC_FTR_SLEEP_STATE,         heathrow_sleep_state },
1563         { 0, NULL }
1564 };
1565
1566 /* Core99 & MacRISC 2 machines (all machines released since the
1567  * iBook (included), that is all AGP machines, except pangea
1568  * chipset. The pangea chipset is the "combo" UniNorth/KeyLargo
1569  * used on iBook2 & iMac "flow power".
1570  */
1571 static struct feature_table_entry core99_features[]  __pmacdata = {
1572         { PMAC_FTR_SCC_ENABLE,          core99_scc_enable },
1573         { PMAC_FTR_MODEM_ENABLE,        core99_modem_enable },
1574         { PMAC_FTR_IDE_ENABLE,          core99_ide_enable },
1575         { PMAC_FTR_IDE_RESET,           core99_ide_reset },
1576         { PMAC_FTR_GMAC_ENABLE,         core99_gmac_enable },
1577         { PMAC_FTR_GMAC_PHY_RESET,      core99_gmac_phy_reset },
1578         { PMAC_FTR_SOUND_CHIP_ENABLE,   core99_sound_chip_enable },
1579         { PMAC_FTR_AIRPORT_ENABLE,      core99_airport_enable },
1580         { PMAC_FTR_USB_ENABLE,          core99_usb_enable },
1581         { PMAC_FTR_1394_ENABLE,         core99_firewire_enable },
1582         { PMAC_FTR_1394_CABLE_POWER,    core99_firewire_cable_power },
1583         { PMAC_FTR_SLEEP_STATE,         core99_sleep_state },
1584 #ifdef CONFIG_SMP
1585         { PMAC_FTR_RESET_CPU,           core99_reset_cpu },
1586 #endif /* CONFIG_SMP */
1587         { PMAC_FTR_READ_GPIO,           core99_read_gpio },
1588         { PMAC_FTR_WRITE_GPIO,          core99_write_gpio },
1589         { 0, NULL }
1590 };
1591
1592 /* Pangea features
1593  */
1594 static struct feature_table_entry pangea_features[]  __pmacdata = {
1595         { PMAC_FTR_SCC_ENABLE,          core99_scc_enable },
1596         { PMAC_FTR_MODEM_ENABLE,        pangea_modem_enable },
1597         { PMAC_FTR_IDE_ENABLE,          core99_ide_enable },
1598         { PMAC_FTR_IDE_RESET,           core99_ide_reset },
1599         { PMAC_FTR_GMAC_ENABLE,         core99_gmac_enable },
1600         { PMAC_FTR_GMAC_PHY_RESET,      core99_gmac_phy_reset },
1601         { PMAC_FTR_SOUND_CHIP_ENABLE,   core99_sound_chip_enable },
1602         { PMAC_FTR_AIRPORT_ENABLE,      core99_airport_enable },
1603         { PMAC_FTR_USB_ENABLE,          core99_usb_enable },
1604         { PMAC_FTR_1394_ENABLE,         core99_firewire_enable },
1605         { PMAC_FTR_1394_CABLE_POWER,    core99_firewire_cable_power },
1606         { PMAC_FTR_SLEEP_STATE,         core99_sleep_state },
1607         { PMAC_FTR_READ_GPIO,           core99_read_gpio },
1608         { PMAC_FTR_WRITE_GPIO,          core99_write_gpio },
1609         { 0, NULL }
1610 };
1611         
1612 static struct pmac_mb_def pmac_mb_defs[] __pmacdata = {
1613         /* Warning: ordering is important as some models may claim
1614          * beeing compatible with several types
1615          */
1616         {       "AAPL,8500",                    "PowerMac 8500/8600",
1617                 PMAC_TYPE_PSURGE,               NULL,
1618                 0
1619         },
1620         {       "AAPL,9500",                    "PowerMac 9500/9600",
1621                 PMAC_TYPE_PSURGE,               NULL,
1622                 0
1623         },
1624         {       "AAPL,7500",                    "PowerMac 7500",
1625                 PMAC_TYPE_PSURGE,               NULL,
1626                 0
1627         },
1628         {       "AAPL,e407",                    "Alchemy",
1629                 PMAC_TYPE_ALCHEMY,              NULL,
1630                 0
1631         },
1632         {       "AAPL,e411",                    "Gazelle",
1633                 PMAC_TYPE_GAZELLE,              NULL,
1634                 0
1635         },
1636         {       "AAPL,3400/2400",               "PowerBook 3400",
1637                 PMAC_TYPE_HOOPER,               ohare_features,
1638                 PMAC_MB_CAN_SLEEP
1639         },
1640         {       "AAPL,3500",                    "PowerBook 3500",
1641                 PMAC_TYPE_KANGA,                ohare_features,
1642                 PMAC_MB_CAN_SLEEP
1643         },
1644         {       "AAPL,Gossamer",                "PowerMac G3 (Gossamer)",
1645                 PMAC_TYPE_GOSSAMER,             heathrow_desktop_features,
1646                 0
1647         },
1648         {       "AAPL,PowerMac G3",             "PowerMac G3 (Silk)",
1649                 PMAC_TYPE_SILK,                 heathrow_desktop_features,
1650                 0
1651         },
1652         {       "AAPL,PowerBook1998",           "PowerBook Wallstreet",
1653                 PMAC_TYPE_WALLSTREET,           heathrow_laptop_features,
1654                 PMAC_MB_CAN_SLEEP
1655         },
1656         {       "AAPL,PowerBook1,1",            "PowerBook 101 (Lombard)",
1657                 PMAC_TYPE_101_PBOOK,            paddington_features,
1658                 PMAC_MB_CAN_SLEEP
1659         },
1660         {       "iMac,1",                       "iMac (first generation)",
1661                 PMAC_TYPE_ORIG_IMAC,            paddington_features,
1662                 0
1663         },
1664         {       "PowerMac4,1",                  "iMac \"Flower Power\"",
1665                 PMAC_TYPE_PANGEA_IMAC,          pangea_features,
1666                 PMAC_MB_CAN_SLEEP
1667         },
1668         {       "PowerBook4,1",                 "iBook 2",
1669                 PMAC_TYPE_IBOOK2,               pangea_features,
1670                 PMAC_MB_CAN_SLEEP | PMAC_MB_HAS_FW_POWER
1671         },
1672         {       "PowerMac4,2",                  "Flat panel iMac",
1673                 PMAC_TYPE_FLAT_PANEL_IMAC,      pangea_features,
1674                 PMAC_MB_CAN_SLEEP
1675         },
1676         {       "PowerMac1,1",                  "Blue&White G3",
1677                 PMAC_TYPE_YOSEMITE,             paddington_features,
1678                 0
1679         },
1680         {       "PowerMac1,2",                  "PowerMac G4 PCI Graphics",
1681                 PMAC_TYPE_YIKES,                paddington_features,
1682                 0
1683         },
1684         {       "PowerBook2,1",                 "iBook (first generation)",
1685                 PMAC_TYPE_ORIG_IBOOK,           core99_features,
1686                 PMAC_MB_CAN_SLEEP
1687         },
1688         {       "PowerMac3,1",                  "PowerMac G4 AGP Graphics",
1689                 PMAC_TYPE_SAWTOOTH,             core99_features,
1690                 0
1691         },
1692         {       "PowerMac3,2",                  "PowerMac G4 AGP Graphics",
1693                 PMAC_TYPE_SAWTOOTH,             core99_features,
1694                 0
1695         },
1696         {       "PowerMac3,3",                  "PowerMac G4 AGP Graphics",
1697                 PMAC_TYPE_SAWTOOTH,             core99_features,
1698                 0
1699         },
1700         {       "PowerMac2,1",                  "iMac FireWire",
1701                 PMAC_TYPE_FW_IMAC,              core99_features,
1702                 PMAC_MB_CAN_SLEEP
1703         },
1704         {       "PowerMac2,2",                  "iMac FireWire",
1705                 PMAC_TYPE_FW_IMAC,              core99_features,
1706                 PMAC_MB_CAN_SLEEP
1707         },
1708         {       "PowerBook2,2",                 "iBook FireWire",
1709                 PMAC_TYPE_FW_IBOOK,             core99_features,
1710                 PMAC_MB_CAN_SLEEP | PMAC_MB_HAS_FW_POWER
1711         },
1712         {       "PowerMac5,1",                  "PowerMac G4 Cube",
1713                 PMAC_TYPE_CUBE,                 core99_features,
1714         },
1715         {       "PowerMac3,4",                  "PowerMac G4 Silver",
1716                 PMAC_TYPE_QUICKSILVER,          core99_features,
1717                 0
1718         },
1719         {       "PowerMac3,5",                  "PowerMac G4 Silver",
1720                 PMAC_TYPE_QUICKSILVER,          core99_features,
1721                 0
1722         },
1723         {       "PowerBook3,1",                 "PowerBook Pismo",
1724                 PMAC_TYPE_PISMO,                core99_features,
1725                 PMAC_MB_CAN_SLEEP | PMAC_MB_HAS_FW_POWER
1726         },
1727         {       "PowerBook3,2",                 "PowerBook Titanium",
1728                 PMAC_TYPE_TITANIUM,             core99_features,
1729                 PMAC_MB_CAN_SLEEP | PMAC_MB_HAS_FW_POWER
1730         },
1731         {       "PowerBook3,3",                 "PowerBook Titanium II",
1732                 PMAC_TYPE_TITANIUM2,            core99_features,
1733                 PMAC_MB_CAN_SLEEP | PMAC_MB_HAS_FW_POWER
1734         },
1735 };
1736
1737 /*
1738  * The toplevel feature_call callback
1739  */
1740 int __pmac
1741 pmac_do_feature_call(unsigned int selector, ...)
1742 {
1743         struct device_node* node;
1744         int param, value, i;
1745         feature_call func = NULL;
1746         va_list args;
1747         
1748         if (!pmac_mb.features)
1749                 return -ENODEV;
1750         for (i=0; pmac_mb.features[i].function; i++)
1751                 if (pmac_mb.features[i].selector == selector) {
1752                         func = pmac_mb.features[i].function;
1753                         break;
1754                 }
1755         if (!func)
1756                 for (i=0; any_features[i].function; i++)
1757                         if (any_features[i].selector == selector) {
1758                                 func = any_features[i].function;
1759                                 break;
1760                         }
1761         if (!func)
1762                 return -ENODEV;
1763
1764         va_start(args, selector);
1765         node = (struct device_node*)va_arg(args, void*);
1766         param = va_arg(args, int);
1767         value = va_arg(args, int);
1768         va_end(args);
1769
1770         return func(node, param, value);
1771 }
1772
1773 static int __init
1774 probe_motherboard(void)
1775 {
1776         int i;
1777         struct macio_chip* macio = &macio_chips[0];
1778
1779         /* Lookup known motherboard type in device-tree */
1780         for(i=0; i<(sizeof(pmac_mb_defs)/sizeof(struct pmac_mb_def)); i++) {
1781             if (machine_is_compatible(pmac_mb_defs[i].model_string)) {
1782                 pmac_mb = pmac_mb_defs[i];
1783                 goto found;
1784             }
1785         }
1786
1787         /* Fallback to selection depending on mac-io chip type */
1788         switch(macio->type) {
1789             case macio_grand_central:
1790                 pmac_mb.model_id = PMAC_TYPE_PSURGE;
1791                 pmac_mb.model_name = "Unknown PowerSurge";
1792                 break;
1793             case macio_ohare:
1794                 pmac_mb.model_id = PMAC_TYPE_UNKNOWN_OHARE;
1795                 pmac_mb.model_name = "Unknown OHare-based";
1796                 break;
1797             case macio_heathrow:
1798                 pmac_mb.model_id = PMAC_TYPE_UNKNOWN_HEATHROW;
1799                 pmac_mb.model_name = "Unknown Heathrow-based";
1800                 pmac_mb.features = heathrow_desktop_features;
1801                 break;
1802             case macio_paddington:
1803                 pmac_mb.model_id = PMAC_TYPE_UNKNOWN_PADDINGTON;
1804                 pmac_mb.model_name = "Unknown Paddington-based";
1805                 pmac_mb.features = paddington_features;
1806                 break;
1807             case macio_keylargo:
1808                 pmac_mb.model_id = PMAC_TYPE_UNKNOWN_CORE99;
1809                 pmac_mb.model_name = "Unknown Keylargo-based";
1810                 pmac_mb.features = core99_features;
1811                 break;
1812             case macio_pangea:
1813                 pmac_mb.model_id = PMAC_TYPE_UNKNOWN_PANGEA;
1814                 pmac_mb.model_name = "Unknown Pangea-based";
1815                 pmac_mb.features = pangea_features;
1816                 break;
1817             default:
1818                 return -ENODEV;
1819         }
1820 found:
1821         /* Fixup Hooper vs. Comet */
1822         if (pmac_mb.model_id == PMAC_TYPE_HOOPER) {
1823                 u32* mach_id_ptr = (u32*)ioremap(0xf3000034, 4);
1824                 if (!mach_id_ptr)
1825                         return -ENODEV;
1826                 /* Here, I used to disable the media-bay on comet. It
1827                  * appears this is wrong, the floppy connector is actually
1828                  * a kind of media-bay and works with the current driver.
1829                  */
1830                 if ((*mach_id_ptr) & 0x20000000UL)
1831                         pmac_mb.model_id = PMAC_TYPE_COMET;
1832                 iounmap(mach_id_ptr);
1833         }
1834
1835         /* Set default value of powersave_nap on machines that support it.
1836          * It appears that uninorth rev 3 has a problem with it, we don't
1837          * enable it on those. In theory, the flush-on-lock property is
1838          * supposed to be set when not supported, but I'm not very confident
1839          * that all Apple OF revs did it properly, I do it the paranoid way.
1840          */
1841         while (uninorth_base && uninorth_rev > 3) {
1842                 struct device_node* np = find_path_device("/cpus");
1843                 u32 pvr = mfspr(PVR);
1844                 if (!np || !np->child) {
1845                         printk(KERN_WARNING "Can't find CPU(s) in device tree !\n");
1846                         break;
1847                 }
1848                 np = np->child;
1849                 /* Nap mode not supported on SMP */
1850                 if (np->sibling)
1851                         break;
1852                 /* Nap mode not supported if flush-on-lock property is present */
1853                 if (get_property(np, "flush-on-lock", NULL))
1854                         break;
1855                 /* Some 7450 may have problem with NAP mode too ... */
1856                 if (((pvr >> 16) == 0x8000) && ((pvr & 0xffff) < 0x0201))
1857                         break;
1858                 powersave_nap = 1;
1859                 printk(KERN_INFO "Processor NAP mode on idle enabled.\n");
1860                 break;
1861         }
1862
1863         printk(KERN_INFO "PowerMac motherboard: %s\n", pmac_mb.model_name);
1864         return 0;
1865 }
1866
1867 /* Initialize the Core99 UniNorth host bridge and memory controller
1868  */
1869 static void __init
1870 probe_uninorth(void)
1871 {
1872         unsigned long actrl;
1873         
1874         /* Locate core99 Uni-N */
1875         uninorth_node = find_devices("uni-n");
1876         if (uninorth_node && uninorth_node->n_addrs > 0) {
1877                 uninorth_base = ioremap(uninorth_node->addrs[0].address, 0x1000);
1878                 uninorth_rev = in_be32(UN_REG(UNI_N_VERSION));
1879         } else
1880                 uninorth_node = NULL;
1881                 
1882         if (!uninorth_node)
1883                 return;
1884         
1885         printk(KERN_INFO "Found Uninorth memory controller & host bridge, revision: %d\n",
1886                         uninorth_rev);
1887
1888         /* Set the arbitrer QAck delay according to what Apple does
1889          */
1890         if (uninorth_rev < 0x10) {
1891                 actrl = UN_IN(UNI_N_ARB_CTRL) & ~UNI_N_ARB_CTRL_QACK_DELAY_MASK;
1892                 actrl |= ((uninorth_rev < 3) ? UNI_N_ARB_CTRL_QACK_DELAY105 :
1893                         UNI_N_ARB_CTRL_QACK_DELAY) << UNI_N_ARB_CTRL_QACK_DELAY_SHIFT;
1894                 UN_OUT(UNI_N_ARB_CTRL, actrl);
1895         }
1896 }       
1897
1898 static void __init
1899 probe_one_macio(const char* name, const char* compat, int type)
1900 {
1901         struct device_node*     node;
1902         int                     i;
1903         volatile u32*           base;
1904         u32*                    revp;
1905         
1906         node = find_devices(name);
1907         if (!node || !node->n_addrs)
1908                 return;
1909         if (compat)
1910                 do {
1911                         if (device_is_compatible(node, compat))
1912                                 break;
1913                         node = node->next;
1914                 } while (node);
1915         if (!node)
1916                 return;
1917         for(i=0; i<MAX_MACIO_CHIPS; i++) {
1918                 if (!macio_chips[i].of_node)
1919                         break;
1920                 if (macio_chips[i].of_node == node)
1921                         return;
1922         }
1923         if (i >= MAX_MACIO_CHIPS) {
1924                 printk(KERN_ERR "pmac_feature: Please increase MAX_MACIO_CHIPS !\n");
1925                 printk(KERN_ERR "pmac_feature: %s skipped\n", node->full_name);
1926                 return;
1927         }
1928         base = (volatile u32*)ioremap(node->addrs[0].address, node->addrs[0].size);
1929         if (!base) {
1930                 printk(KERN_ERR "pmac_feature: Can't map mac-io chip !\n");
1931                 return;
1932         }
1933         if (type == macio_keylargo) {
1934                 u32* did = (u32 *)get_property(node, "device-id", NULL);
1935                 if (*did == 0x00000025)
1936                         type = macio_pangea;
1937         }
1938         macio_chips[i].of_node  = node;
1939         macio_chips[i].type     = type;
1940         macio_chips[i].base     = base;
1941         macio_chips[i].flags    = MACIO_FLAG_SCCB_ON | MACIO_FLAG_SCCB_ON;
1942         revp = (u32 *)get_property(node, "revision-id", NULL);
1943         if (revp)
1944                 macio_chips[i].rev = *revp;
1945         printk(KERN_INFO "Found a %s mac-io controller, rev: %d, mapped at 0x%p\n",
1946                 macio_names[type], macio_chips[i].rev, macio_chips[i].base);
1947 }
1948
1949 static int __init
1950 probe_macios(void)
1951 {
1952         /* Warning, ordering is important */
1953         probe_one_macio("gc", NULL, macio_grand_central);
1954         probe_one_macio("ohare", NULL, macio_ohare);
1955         probe_one_macio("pci106b,7", NULL, macio_ohareII);
1956         probe_one_macio("mac-io", "keylargo", macio_keylargo);
1957         probe_one_macio("mac-io", "paddington", macio_paddington);
1958         probe_one_macio("mac-io", "gatwick", macio_gatwick);
1959         probe_one_macio("mac-io", "heathrow", macio_heathrow);
1960
1961         /* Make sure the "main" macio chip appear first */
1962         if (macio_chips[0].type == macio_gatwick
1963             && macio_chips[1].type == macio_heathrow) {
1964                 struct macio_chip temp = macio_chips[0];
1965                 macio_chips[0] = macio_chips[1];
1966                 macio_chips[1] = temp;
1967         }
1968         if (macio_chips[0].type == macio_ohareII
1969             && macio_chips[1].type == macio_ohare) {
1970                 struct macio_chip temp = macio_chips[0];
1971                 macio_chips[0] = macio_chips[1];
1972                 macio_chips[1] = temp;
1973         }
1974
1975         return (macio_chips[0].of_node == NULL) ? -ENODEV : 0;
1976 }
1977
1978 static void __init
1979 initial_serial_shutdown(struct device_node* np)
1980 {
1981         int len;
1982         struct slot_names_prop {
1983                 int     count;
1984                 char    name[1];
1985         } *slots;
1986         char *conn;
1987         int port_type = PMAC_SCC_ASYNC;
1988         int modem = 0;
1989         
1990         slots = (struct slot_names_prop *)get_property(np, "slot-names", &len);
1991         conn = get_property(np, "AAPL,connector", &len);
1992         if (conn && (strcmp(conn, "infrared") == 0))
1993                 port_type = PMAC_SCC_IRDA;
1994         else if (device_is_compatible(np, "cobalt"))
1995                 modem = 1;
1996         else if (slots && slots->count > 0) {
1997                 if (strcmp(slots->name, "IrDA") == 0)
1998                         port_type = PMAC_SCC_IRDA;
1999                 else if (strcmp(slots->name, "Modem") == 0)
2000                         modem = 1;
2001         }
2002         if (modem)
2003                 pmac_call_feature(PMAC_FTR_MODEM_ENABLE, np, 0, 0);
2004         pmac_call_feature(PMAC_FTR_SCC_ENABLE, np, port_type, 0);
2005 }
2006
2007 static void __init
2008 set_initial_features(void)
2009 {
2010         struct device_node* np;
2011         
2012         /* That hack appears to be necessary for some StarMax motherboards
2013          * but I'm not too sure it was audited for side-effects on other
2014          * ohare based machines...
2015          * Since I still have difficulties figuring the right way to
2016          * differenciate them all and since that hack was there for a long
2017          * time, I'll keep it around
2018          */
2019         if (macio_chips[0].type == macio_ohare && !find_devices("via-pmu")) {
2020                 struct macio_chip* macio = &macio_chips[0];
2021                 MACIO_OUT32(OHARE_FCR, STARMAX_FEATURES);
2022         } else if (macio_chips[0].type == macio_ohare) {
2023                 struct macio_chip* macio = &macio_chips[0];
2024                 MACIO_BIS(OHARE_FCR, OH_IOBUS_ENABLE);
2025         } else if (macio_chips[1].type == macio_ohare) {
2026                 struct macio_chip* macio = &macio_chips[1];
2027                 MACIO_BIS(OHARE_FCR, OH_IOBUS_ENABLE);
2028         }
2029
2030         if (macio_chips[0].type == macio_keylargo ||
2031             macio_chips[0].type == macio_pangea) {
2032                 /* Enable GMAC for now for PCI probing. It will be disabled
2033                  * later on after PCI probe
2034                  */
2035                 np = find_devices("ethernet");
2036                 while(np) {
2037                         if (np->parent
2038                             && device_is_compatible(np->parent, "uni-north")
2039                             && device_is_compatible(np, "gmac"))
2040                                 core99_gmac_enable(np, 0, 1);
2041                         np = np->next;
2042                 }
2043
2044                 /* Enable FW before PCI probe. Will be disabled later on
2045                  * Note: We should have a batter way to check that we are
2046                  * dealing with uninorth internal cell and not a PCI cell
2047                  * on the external PCI. The code below works though.
2048                  */
2049                 np = find_devices("firewire");
2050                 while(np) {
2051                         if (np->parent
2052                             && device_is_compatible(np->parent, "uni-north")
2053                             && (device_is_compatible(np, "pci106b,18") || 
2054                                 device_is_compatible(np, "pci106b,30") ||
2055                                 device_is_compatible(np, "pci11c1,5811"))) {
2056                                 macio_chips[0].flags |= MACIO_FLAG_FW_SUPPORTED;
2057                                 core99_firewire_enable(np, 0, 1);
2058                         }
2059                         np = np->next;
2060                 }
2061                 
2062                 /* Switch airport off */
2063                 np = find_devices("radio");
2064                 while(np) {
2065                         if (np && np->parent == macio_chips[0].of_node) {
2066                                 macio_chips[0].flags |= MACIO_FLAG_AIRPORT_ON;
2067                                 core99_airport_enable(np, 0, 0);
2068                         }
2069                         np = np->next;
2070                 }
2071         }
2072
2073         /* On all machines, switch sound off */
2074         if (macio_chips[0].of_node)
2075                 pmac_do_feature_call(PMAC_FTR_SOUND_CHIP_ENABLE,
2076                         macio_chips[0].of_node, 0, 0);
2077
2078         /* On all machines, switch modem & serial ports off */
2079         np = find_devices("ch-a");
2080         while(np) {
2081                 initial_serial_shutdown(np);
2082                 np = np->next;
2083         }
2084         np = find_devices("ch-b");
2085         while(np) {
2086                 initial_serial_shutdown(np);
2087                 np = np->next;
2088         }
2089         
2090         /* Let hardware settle down */
2091         mdelay(10);
2092 }
2093
2094 void __init
2095 pmac_feature_init(void)
2096 {
2097         /* Detect the UniNorth memory controller */
2098         probe_uninorth();
2099
2100         /* Probe mac-io controllers */
2101         if (probe_macios()) {
2102                 printk(KERN_WARNING "No mac-io chip found\n");
2103                 return;
2104         }
2105
2106         /* Probe machine type */
2107         if (probe_motherboard())
2108                 printk(KERN_WARNING "Unknown PowerMac !\n");
2109
2110         /* Set some initial features (turn off some chips that will
2111          * be later turned on)
2112          */
2113         set_initial_features();
2114 }
2115
2116 void __init
2117 pmac_feature_late_init(void)
2118 {
2119         struct device_node* np;
2120         
2121         /* Request some resources late */
2122         if (uninorth_node)
2123                 request_OF_resource(uninorth_node, 0, NULL);
2124         np = find_devices("hammerhead");
2125         if (np)
2126                 request_OF_resource(np, 0, NULL);
2127         np = find_devices("interrupt-controller");
2128         if (np)
2129                 request_OF_resource(np, 0, NULL);
2130 }