1 /* $Id: sbus.c,v 1.100 2002/01/24 15:36:24 davem Exp $
2 * sbus.c: SBus support routines.
4 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
7 #include <linux/kernel.h>
8 #include <linux/slab.h>
9 #include <linux/config.h>
10 #include <linux/init.h>
11 #include <linux/pci.h>
13 #include <asm/system.h>
16 #include <asm/oplib.h>
20 struct sbus_bus
*sbus_root
= NULL
;
22 static struct linux_prom_irqs irqs
[PROMINTR_MAX
] __initdata
= { { 0 } };
24 static int interrupts
[PROMINTR_MAX
] __initdata
= { 0 };
28 extern int pcic_present(void);
31 /* Perhaps when I figure out more about the iommu we'll put a
32 * device registration routine here that probe_sbus() calls to
33 * setup the iommu for each Sbus.
36 /* We call this for each SBus device, and fill the structure based
37 * upon the prom device tree. We return the start of memory after
38 * the things we have allocated.
41 /* #define DEBUG_FILL */
43 static void __init
fill_sbus_device(int prom_node
, struct sbus_dev
*sdev
)
45 unsigned long address
, base
;
48 sdev
->prom_node
= prom_node
;
49 prom_getstring(prom_node
, "name",
50 sdev
->prom_name
, sizeof(sdev
->prom_name
));
51 address
= prom_getint(prom_node
, "address");
52 len
= prom_getproperty(prom_node
, "reg",
53 (char *) sdev
->reg_addrs
,
54 sizeof(sdev
->reg_addrs
));
56 sdev
->num_registers
= 0;
60 if (len
% sizeof(struct linux_prom_registers
)) {
61 prom_printf("fill_sbus_device: proplen for regs of %s "
62 " was %d, need multiple of %d\n",
64 (int) sizeof(struct linux_prom_registers
));
67 if (len
> (sizeof(struct linux_prom_registers
) * PROMREG_MAX
)) {
68 prom_printf("fill_sbus_device: Too many register properties "
69 "for device %s, len=%d\n",
70 sdev
->prom_name
, len
);
73 sdev
->num_registers
= len
/ sizeof(struct linux_prom_registers
);
74 sdev
->ranges_applied
= 0;
76 base
= (unsigned long) sdev
->reg_addrs
[0].phys_addr
;
78 /* Compute the slot number. */
79 if (base
>= SUN_SBUS_BVADDR
&& sparc_cpu_model
== sun4m
) {
80 sdev
->slot
= sbus_dev_slot(base
);
82 sdev
->slot
= sdev
->reg_addrs
[0].which_io
;
86 len
= prom_getproperty(prom_node
, "ranges",
87 (char *)sdev
->device_ranges
,
88 sizeof(sdev
->device_ranges
));
90 sdev
->num_device_ranges
= 0;
93 if (len
% sizeof(struct linux_prom_ranges
)) {
94 prom_printf("fill_sbus_device: proplen for ranges of %s "
95 " was %d, need multiple of %d\n",
97 (int) sizeof(struct linux_prom_ranges
));
100 if (len
> (sizeof(struct linux_prom_ranges
) * PROMREG_MAX
)) {
101 prom_printf("fill_sbus_device: Too many range properties "
102 "for device %s, len=%d\n",
103 sdev
->prom_name
, len
);
106 sdev
->num_device_ranges
=
107 len
/ sizeof(struct linux_prom_ranges
);
110 /* XXX Unfortunately, IRQ issues are very arch specific.
111 * XXX Pull this crud out into an arch specific area
112 * XXX at some point. -DaveM
114 #ifdef CONFIG_SPARC64
115 len
= prom_getproperty(prom_node
, "interrupts",
116 (char *) irqs
, sizeof(irqs
));
117 if (len
== -1 || len
== 0) {
121 unsigned int pri
= irqs
[0].pri
;
125 pri
+= sdev
->slot
* 8;
127 sdev
->irqs
[0] = sbus_build_irq(sdev
->bus
, pri
);
129 #endif /* CONFIG_SPARC64 */
131 #ifdef CONFIG_SPARC32
132 len
= prom_getproperty(prom_node
, "intr",
133 (char *)irqs
, sizeof(irqs
));
135 sdev
->num_irqs
= len
/ 8;
136 if (sdev
->num_irqs
== 0) {
138 } else if (sparc_cpu_model
== sun4d
) {
139 extern unsigned int sun4d_build_irq(struct sbus_dev
*sdev
, int irq
);
141 for (len
= 0; len
< sdev
->num_irqs
; len
++)
142 sdev
->irqs
[len
] = sun4d_build_irq(sdev
, irqs
[len
].pri
);
144 for (len
= 0; len
< sdev
->num_irqs
; len
++)
145 sdev
->irqs
[len
] = irqs
[len
].pri
;
148 /* No "intr" node found-- check for "interrupts" node.
149 * This node contains SBus interrupt levels, not IPLs
150 * as in "intr", and no vector values. We convert
151 * SBus interrupt levels to PILs (platform specific).
153 len
= prom_getproperty(prom_node
, "interrupts",
154 (char *)interrupts
, sizeof(interrupts
));
159 sdev
->num_irqs
= len
/ sizeof(int);
160 for (len
= 0; len
< sdev
->num_irqs
; len
++) {
161 sdev
->irqs
[len
] = sbint_to_irq(sdev
, interrupts
[len
]);
165 #endif /* CONFIG_SPARC32 */
168 /* This routine gets called from whoever needs the sbus first, to scan
169 * the SBus device tree. Currently it just prints out the devices
170 * found on the bus and builds trees of SBUS structs and attached
174 extern void iommu_init(int iommu_node
, struct sbus_bus
*sbus
);
175 extern void iounit_init(int sbi_node
, int iounit_node
, struct sbus_bus
*sbus
);
176 void sun4_init(void);
177 #ifdef CONFIG_SUN_AUXIO
178 extern void auxio_probe(void);
181 static void __init
sbus_do_child_siblings(int start_node
,
182 struct sbus_dev
*child
,
183 struct sbus_dev
*parent
,
184 struct sbus_bus
*sbus
)
186 struct sbus_dev
*this_dev
= child
;
187 int this_node
= start_node
;
189 /* Child already filled in, just need to traverse siblings. */
191 child
->parent
= parent
;
192 while((this_node
= prom_getsibling(this_node
)) != 0) {
193 this_dev
->next
= kmalloc(sizeof(struct sbus_dev
), GFP_ATOMIC
);
194 this_dev
= this_dev
->next
;
195 this_dev
->next
= NULL
;
196 this_dev
->parent
= parent
;
198 this_dev
->bus
= sbus
;
199 fill_sbus_device(this_node
, this_dev
);
201 if(prom_getchild(this_node
)) {
202 this_dev
->child
= kmalloc(sizeof(struct sbus_dev
),
204 this_dev
->child
->bus
= sbus
;
205 this_dev
->child
->next
= NULL
;
206 fill_sbus_device(prom_getchild(this_node
), this_dev
->child
);
207 sbus_do_child_siblings(prom_getchild(this_node
),
208 this_dev
->child
, this_dev
, sbus
);
210 this_dev
->child
= NULL
;
216 * XXX This functions appears to be a distorted version of
217 * prom_sbus_ranges_init(), with all sun4d stuff cut away.
218 * Ask DaveM what is going on here, how is sun4d supposed to work... XXX
220 static void __init
sbus_bus_ranges_init(int parent_node
, struct sbus_bus
*sbus
)
224 len
= prom_getproperty(sbus
->prom_node
, "ranges",
225 (char *) sbus
->sbus_ranges
,
226 sizeof(sbus
->sbus_ranges
));
227 if (len
== -1 || len
== 0) {
228 sbus
->num_sbus_ranges
= 0;
231 sbus
->num_sbus_ranges
= len
/ sizeof(struct linux_prom_ranges
);
234 static void __init
__apply_ranges_to_regs(struct linux_prom_ranges
*ranges
,
236 struct linux_prom_registers
*regs
,
242 for (regnum
= 0; regnum
< num_regs
; regnum
++) {
245 for (rngnum
= 0; rngnum
< num_ranges
; rngnum
++) {
246 if (regs
[regnum
].which_io
== ranges
[rngnum
].ot_child_space
)
249 if (rngnum
== num_ranges
) {
250 /* We used to flag this as an error. Actually
251 * some devices do not report the regs as we expect.
252 * For example, see SUNW,pln device. In that case
253 * the reg property is in a format internal to that
254 * node, ie. it is not in the SBUS register space
259 regs
[regnum
].which_io
= ranges
[rngnum
].ot_parent_space
;
260 regs
[regnum
].phys_addr
-= ranges
[rngnum
].ot_child_base
;
261 regs
[regnum
].phys_addr
+= ranges
[rngnum
].ot_parent_base
;
266 static void __init
__fixup_regs_sdev(struct sbus_dev
*sdev
)
268 if (sdev
->num_registers
!= 0) {
269 struct sbus_dev
*parent
= sdev
->parent
;
272 while (parent
!= NULL
) {
273 __apply_ranges_to_regs(parent
->device_ranges
,
274 parent
->num_device_ranges
,
276 sdev
->num_registers
);
278 parent
= parent
->parent
;
281 __apply_ranges_to_regs(sdev
->bus
->sbus_ranges
,
282 sdev
->bus
->num_sbus_ranges
,
284 sdev
->num_registers
);
286 for (i
= 0; i
< sdev
->num_registers
; i
++) {
287 struct resource
*res
= &sdev
->resource
[i
];
289 res
->start
= sdev
->reg_addrs
[i
].phys_addr
;
290 res
->end
= (res
->start
+
291 (unsigned long)sdev
->reg_addrs
[i
].reg_size
- 1UL);
292 res
->flags
= IORESOURCE_IO
|
293 (sdev
->reg_addrs
[i
].which_io
& 0xff);
298 static void __init
sbus_fixup_all_regs(struct sbus_dev
*first_sdev
)
300 struct sbus_dev
*sdev
;
302 for (sdev
= first_sdev
; sdev
; sdev
= sdev
->next
) {
304 sbus_fixup_all_regs(sdev
->child
);
305 __fixup_regs_sdev(sdev
);
309 extern void register_proc_sparc_ioport(void);
310 extern void firetruck_init(void);
313 extern void sun4_dvma_init(void);
316 static int __init
sbus_init(void)
318 int nd
, this_sbus
, sbus_devs
, topnd
, iommund
;
319 unsigned int sbus_clock
;
320 struct sbus_bus
*sbus
;
321 struct sbus_dev
*this_dev
;
322 int num_sbus
= 0; /* How many did we find? */
324 #ifdef CONFIG_SPARC32
325 register_proc_sparc_ioport();
333 topnd
= prom_getchild(prom_root_node
);
335 /* Finding the first sbus is a special case... */
337 if(sparc_cpu_model
== sun4u
) {
338 nd
= prom_searchsiblings(topnd
, "sbus");
341 if (!pcic_present()) {
342 prom_printf("Neither SBUS nor PCI found.\n");
345 #ifdef CONFIG_SPARC64
351 prom_printf("YEEE, UltraSparc sbus not found\n");
355 } else if(sparc_cpu_model
== sun4d
) {
356 if((iommund
= prom_searchsiblings(topnd
, "io-unit")) == 0 ||
357 (nd
= prom_getchild(iommund
)) == 0 ||
358 (nd
= prom_searchsiblings(nd
, "sbi")) == 0) {
359 panic("sbi not found");
361 } else if((nd
= prom_searchsiblings(topnd
, "sbus")) == 0) {
362 if((iommund
= prom_searchsiblings(topnd
, "iommu")) == 0 ||
363 (nd
= prom_getchild(iommund
)) == 0 ||
364 (nd
= prom_searchsiblings(nd
, "sbus")) == 0) {
366 if (!pcic_present()) {
367 prom_printf("Neither SBUS nor PCI found.\n");
372 /* No reason to run further - the data access trap will occur. */
373 panic("sbus not found");
378 /* Ok, we've found the first one, allocate first SBus struct
379 * and place in chain.
381 sbus
= sbus_root
= kmalloc(sizeof(struct sbus_bus
), GFP_ATOMIC
);
383 sbus
->prom_node
= nd
;
386 if(iommund
&& sparc_cpu_model
!= sun4u
&& sparc_cpu_model
!= sun4d
)
387 iommu_init(iommund
, sbus
);
389 /* Loop until we find no more SBUS's */
391 #ifdef CONFIG_SPARC64
392 /* IOMMU hides inside SBUS/SYSIO prom node on Ultra. */
393 if(sparc_cpu_model
== sun4u
) {
394 extern void sbus_iommu_init(int prom_node
, struct sbus_bus
*sbus
);
396 sbus_iommu_init(this_sbus
, sbus
);
398 #endif /* CONFIG_SPARC64 */
400 #ifdef CONFIG_SPARC32
401 if (sparc_cpu_model
== sun4d
)
402 iounit_init(this_sbus
, iommund
, sbus
);
403 #endif /* CONFIG_SPARC32 */
404 printk("sbus%d: ", num_sbus
);
405 sbus_clock
= prom_getint(this_sbus
, "clock-frequency");
407 sbus_clock
= (25*1000*1000);
408 printk("Clock %d.%d MHz\n", (int) ((sbus_clock
/1000)/1000),
409 (int) (((sbus_clock
/1000)%1000 != 0) ?
410 (((sbus_clock
/1000)%1000) + 1000) : 0));
412 prom_getstring(this_sbus
, "name",
413 sbus
->prom_name
, sizeof(sbus
->prom_name
));
414 sbus
->clock_freq
= sbus_clock
;
415 #ifdef CONFIG_SPARC32
416 if (sparc_cpu_model
== sun4d
) {
417 sbus
->devid
= prom_getint(iommund
, "device-id");
418 sbus
->board
= prom_getint(iommund
, "board#");
422 sbus_bus_ranges_init(iommund
, sbus
);
424 sbus_devs
= prom_getchild(this_sbus
);
426 sbus
->devices
= NULL
;
430 sbus
->devices
= kmalloc(sizeof(struct sbus_dev
), GFP_ATOMIC
);
432 this_dev
= sbus
->devices
;
433 this_dev
->next
= NULL
;
435 this_dev
->bus
= sbus
;
436 this_dev
->parent
= NULL
;
437 fill_sbus_device(sbus_devs
, this_dev
);
439 /* Should we traverse for children? */
440 if(prom_getchild(sbus_devs
)) {
441 /* Allocate device node */
442 this_dev
->child
= kmalloc(sizeof(struct sbus_dev
),
445 this_dev
->child
->bus
= sbus
;
446 this_dev
->child
->next
= NULL
;
447 fill_sbus_device(prom_getchild(sbus_devs
),
449 sbus_do_child_siblings(prom_getchild(sbus_devs
),
454 this_dev
->child
= NULL
;
457 while((sbus_devs
= prom_getsibling(sbus_devs
)) != 0) {
458 /* Allocate device node */
459 this_dev
->next
= kmalloc(sizeof(struct sbus_dev
),
461 this_dev
= this_dev
->next
;
462 this_dev
->next
= NULL
;
465 this_dev
->bus
= sbus
;
466 this_dev
->parent
= NULL
;
467 fill_sbus_device(sbus_devs
, this_dev
);
469 /* Is there a child node hanging off of us? */
470 if(prom_getchild(sbus_devs
)) {
471 /* Get new device struct */
472 this_dev
->child
= kmalloc(sizeof(struct sbus_dev
),
475 this_dev
->child
->bus
= sbus
;
476 this_dev
->child
->next
= NULL
;
477 fill_sbus_device(prom_getchild(sbus_devs
),
479 sbus_do_child_siblings(prom_getchild(sbus_devs
),
484 this_dev
->child
= NULL
;
488 /* Walk all devices and apply parent ranges. */
489 sbus_fixup_all_regs(sbus
->devices
);
494 if(sparc_cpu_model
== sun4u
) {
495 this_sbus
= prom_getsibling(this_sbus
);
498 this_sbus
= prom_searchsiblings(this_sbus
, "sbus");
499 } else if(sparc_cpu_model
== sun4d
) {
500 iommund
= prom_getsibling(iommund
);
503 iommund
= prom_searchsiblings(iommund
, "io-unit");
506 this_sbus
= prom_searchsiblings(prom_getchild(iommund
), "sbi");
508 this_sbus
= prom_getsibling(this_sbus
);
511 this_sbus
= prom_searchsiblings(this_sbus
, "sbus");
514 sbus
->next
= kmalloc(sizeof(struct sbus_bus
), GFP_ATOMIC
);
517 sbus
->prom_node
= this_sbus
;
521 } /* while(this_sbus) */
523 if (sparc_cpu_model
== sun4d
) {
524 extern void sun4d_init_sbi_irq(void);
525 sun4d_init_sbi_irq();
528 #ifdef CONFIG_SPARC64
529 if (sparc_cpu_model
== sun4u
) {
533 #ifdef CONFIG_SUN_AUXIO
534 if (sparc_cpu_model
== sun4u
)
537 #ifdef CONFIG_SPARC64
538 if (sparc_cpu_model
== sun4u
) {
539 extern void clock_probe(void);
548 subsys_initcall(sbus_init
);