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
;
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
= 0;
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);
312 static int __init
sbus_init(void)
314 int nd
, this_sbus
, sbus_devs
, topnd
, iommund
;
315 unsigned int sbus_clock
;
316 struct sbus_bus
*sbus
;
317 struct sbus_dev
*this_dev
;
318 int num_sbus
= 0; /* How many did we find? */
320 #ifdef CONFIG_SPARC32
321 register_proc_sparc_ioport();
329 topnd
= prom_getchild(prom_root_node
);
331 /* Finding the first sbus is a special case... */
333 if(sparc_cpu_model
== sun4u
) {
334 nd
= prom_searchsiblings(topnd
, "sbus");
337 if (!pcic_present()) {
338 prom_printf("Neither SBUS nor PCI found.\n");
341 #ifdef CONFIG_SPARC64
347 prom_printf("YEEE, UltraSparc sbus not found\n");
351 } else if(sparc_cpu_model
== sun4d
) {
352 if((iommund
= prom_searchsiblings(topnd
, "io-unit")) == 0 ||
353 (nd
= prom_getchild(iommund
)) == 0 ||
354 (nd
= prom_searchsiblings(nd
, "sbi")) == 0) {
355 panic("sbi not found");
357 } else if((nd
= prom_searchsiblings(topnd
, "sbus")) == 0) {
358 if((iommund
= prom_searchsiblings(topnd
, "iommu")) == 0 ||
359 (nd
= prom_getchild(iommund
)) == 0 ||
360 (nd
= prom_searchsiblings(nd
, "sbus")) == 0) {
362 if (!pcic_present()) {
363 prom_printf("Neither SBUS nor PCI found.\n");
368 /* No reason to run further - the data access trap will occur. */
369 panic("sbus not found");
374 /* Ok, we've found the first one, allocate first SBus struct
375 * and place in chain.
377 sbus
= sbus_root
= kmalloc(sizeof(struct sbus_bus
), GFP_ATOMIC
);
379 sbus
->prom_node
= nd
;
382 if(iommund
&& sparc_cpu_model
!= sun4u
&& sparc_cpu_model
!= sun4d
)
383 iommu_init(iommund
, sbus
);
385 /* Loop until we find no more SBUS's */
387 #ifdef CONFIG_SPARC64
388 /* IOMMU hides inside SBUS/SYSIO prom node on Ultra. */
389 if(sparc_cpu_model
== sun4u
) {
390 extern void sbus_iommu_init(int prom_node
, struct sbus_bus
*sbus
);
392 sbus_iommu_init(this_sbus
, sbus
);
394 #endif /* CONFIG_SPARC64 */
396 #ifdef CONFIG_SPARC32
397 if (sparc_cpu_model
== sun4d
)
398 iounit_init(this_sbus
, iommund
, sbus
);
399 #endif /* CONFIG_SPARC32 */
400 printk("sbus%d: ", num_sbus
);
401 sbus_clock
= prom_getint(this_sbus
, "clock-frequency");
403 sbus_clock
= (25*1000*1000);
404 printk("Clock %d.%d MHz\n", (int) ((sbus_clock
/1000)/1000),
405 (int) (((sbus_clock
/1000)%1000 != 0) ?
406 (((sbus_clock
/1000)%1000) + 1000) : 0));
408 prom_getstring(this_sbus
, "name",
409 sbus
->prom_name
, sizeof(sbus
->prom_name
));
410 sbus
->clock_freq
= sbus_clock
;
411 #ifdef CONFIG_SPARC32
412 if (sparc_cpu_model
== sun4d
) {
413 sbus
->devid
= prom_getint(iommund
, "device-id");
414 sbus
->board
= prom_getint(iommund
, "board#");
418 sbus_bus_ranges_init(iommund
, sbus
);
420 sbus_devs
= prom_getchild(this_sbus
);
422 sbus
->devices
= NULL
;
426 sbus
->devices
= kmalloc(sizeof(struct sbus_dev
), GFP_ATOMIC
);
428 this_dev
= sbus
->devices
;
429 this_dev
->next
= NULL
;
431 this_dev
->bus
= sbus
;
432 this_dev
->parent
= NULL
;
433 fill_sbus_device(sbus_devs
, this_dev
);
435 /* Should we traverse for children? */
436 if(prom_getchild(sbus_devs
)) {
437 /* Allocate device node */
438 this_dev
->child
= kmalloc(sizeof(struct sbus_dev
),
441 this_dev
->child
->bus
= sbus
;
442 this_dev
->child
->next
= 0;
443 fill_sbus_device(prom_getchild(sbus_devs
),
445 sbus_do_child_siblings(prom_getchild(sbus_devs
),
450 this_dev
->child
= NULL
;
453 while((sbus_devs
= prom_getsibling(sbus_devs
)) != 0) {
454 /* Allocate device node */
455 this_dev
->next
= kmalloc(sizeof(struct sbus_dev
),
457 this_dev
= this_dev
->next
;
458 this_dev
->next
= NULL
;
461 this_dev
->bus
= sbus
;
462 this_dev
->parent
= NULL
;
463 fill_sbus_device(sbus_devs
, this_dev
);
465 /* Is there a child node hanging off of us? */
466 if(prom_getchild(sbus_devs
)) {
467 /* Get new device struct */
468 this_dev
->child
= kmalloc(sizeof(struct sbus_dev
),
471 this_dev
->child
->bus
= sbus
;
472 this_dev
->child
->next
= 0;
473 fill_sbus_device(prom_getchild(sbus_devs
),
475 sbus_do_child_siblings(prom_getchild(sbus_devs
),
480 this_dev
->child
= NULL
;
484 /* Walk all devices and apply parent ranges. */
485 sbus_fixup_all_regs(sbus
->devices
);
490 if(sparc_cpu_model
== sun4u
) {
491 this_sbus
= prom_getsibling(this_sbus
);
494 this_sbus
= prom_searchsiblings(this_sbus
, "sbus");
495 } else if(sparc_cpu_model
== sun4d
) {
496 iommund
= prom_getsibling(iommund
);
499 iommund
= prom_searchsiblings(iommund
, "io-unit");
502 this_sbus
= prom_searchsiblings(prom_getchild(iommund
), "sbi");
504 this_sbus
= prom_getsibling(this_sbus
);
507 this_sbus
= prom_searchsiblings(this_sbus
, "sbus");
510 sbus
->next
= kmalloc(sizeof(struct sbus_bus
), GFP_ATOMIC
);
513 sbus
->prom_node
= this_sbus
;
517 } /* while(this_sbus) */
519 if (sparc_cpu_model
== sun4d
) {
520 extern void sun4d_init_sbi_irq(void);
521 sun4d_init_sbi_irq();
524 #ifdef CONFIG_SPARC64
525 if (sparc_cpu_model
== sun4u
) {
529 #ifdef CONFIG_SUN_AUXIO
530 if (sparc_cpu_model
== sun4u
)
533 #ifdef CONFIG_SPARC64
534 if (sparc_cpu_model
== sun4u
) {
535 extern void clock_probe(void);
544 subsys_initcall(sbus_init
);