1 /* $Id: sbus.c,v 1.91 2000/11/08 05:04:06 davem Exp $
2 * sbus.c: SBus support routines.
3 *
4 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
5 */
6
7 #include <linux/kernel.h>
8 #include <linux/malloc.h>
9 #include <linux/config.h>
10 #include <linux/init.h>
11 #include <linux/pci.h>
12
13 #include <asm/system.h>
14 #include <asm/sbus.h>
15 #include <asm/dma.h>
16 #include <asm/oplib.h>
17 #include <asm/bpp.h>
18 #include <asm/irq.h>
19
20 struct sbus_bus *sbus_root = NULL;
21
22 static struct linux_prom_irqs irqs[PROMINTR_MAX] __initdata = { { 0 } };
23
24 /* Perhaps when I figure out more about the iommu we'll put a
25 * device registration routine here that probe_sbus() calls to
26 * setup the iommu for each Sbus.
27 */
28
29 /* We call this for each SBus device, and fill the structure based
30 * upon the prom device tree. We return the start of memory after
31 * the things we have allocated.
32 */
33
34 /* #define DEBUG_FILL */
35
36 static void __init fill_sbus_device(int prom_node, struct sbus_dev *sdev)
37 {
38 unsigned long address, base;
39 int len;
40
41 sdev->prom_node = prom_node;
42 prom_getstring(prom_node, "name",
43 sdev->prom_name, sizeof(sdev->prom_name));
44 address = prom_getint(prom_node, "address");
45 len = prom_getproperty(prom_node, "reg",
46 (char *) sdev->reg_addrs,
47 sizeof(sdev->reg_addrs));
48 if (len == -1) {
49 sdev->num_registers = 0;
50 goto no_regs;
51 }
52
53 if (len % sizeof(struct linux_prom_registers)) {
54 prom_printf("fill_sbus_device: proplen for regs of %s "
55 " was %d, need multiple of %d\n",
56 sdev->prom_name, len,
57 (int) sizeof(struct linux_prom_registers));
58 prom_halt();
59 }
60 if (len > (sizeof(struct linux_prom_registers) * PROMREG_MAX)) {
61 prom_printf("fill_sbus_device: Too many register properties "
62 "for device %s, len=%d\n",
63 sdev->prom_name, len);
64 prom_halt();
65 }
66 sdev->num_registers = len / sizeof(struct linux_prom_registers);
67 sdev->ranges_applied = 0;
68
69 base = (unsigned long) sdev->reg_addrs[0].phys_addr;
70 if (base >= SUN_SBUS_BVADDR ||
71 (sparc_cpu_model != sun4c && sparc_cpu_model != sun4)) {
72 /* OK, we can compute the slot number in a
73 * straightforward manner.
74 */
75 if (sparc_cpu_model == sun4u ||
76 sparc_cpu_model == sun4d)
77 sdev->slot = sdev->reg_addrs[0].which_io;
78 else
79 sdev->slot = sbus_dev_slot(base);
80 } else {
81 int rnum;
82
83 /* Fixups are needed to compute the slot number. */
84 sdev->slot = sdev->reg_addrs[0].which_io;
85 sdev->reg_addrs[0].phys_addr =
86 sbus_devaddr(sdev->slot, base);
87 for (rnum = 1; rnum < sdev->num_registers; rnum++) {
88 base = (unsigned long)
89 sdev->reg_addrs[rnum].phys_addr;
90 sdev->reg_addrs[rnum].phys_addr =
91 sbus_devaddr(sdev->slot, base);
92 }
93 }
94
95 no_regs:
96 len = prom_getproperty(prom_node, "ranges",
97 (char *)sdev->device_ranges,
98 sizeof(sdev->device_ranges));
99 if (len == -1) {
100 sdev->num_device_ranges = 0;
101 goto no_ranges;
102 }
103 if (len % sizeof(struct linux_prom_ranges)) {
104 prom_printf("fill_sbus_device: proplen for ranges of %s "
105 " was %d, need multiple of %d\n",
106 sdev->prom_name, len,
107 (int) sizeof(struct linux_prom_ranges));
108 prom_halt();
109 }
110 if (len > (sizeof(struct linux_prom_ranges) * PROMREG_MAX)) {
111 prom_printf("fill_sbus_device: Too many range properties "
112 "for device %s, len=%d\n",
113 sdev->prom_name, len);
114 prom_halt();
115 }
116 sdev->num_device_ranges =
117 len / sizeof(struct linux_prom_ranges);
118
119 no_ranges:
120 /* XXX Unfortunately, IRQ issues are very arch specific.
121 * XXX Pull this crud out into an arch specific area
122 * XXX at some point. -DaveM
123 */
124 #ifdef __sparc_v9__
125 len = prom_getproperty(prom_node, "interrupts",
126 (char *) irqs, sizeof(irqs));
127 if (len == -1 || len == 0) {
128 sdev->irqs[0] = 0;
129 sdev->num_irqs = 0;
130 } else {
131 unsigned int pri = irqs[0].pri;
132
133 sdev->num_irqs = 1;
134 if (pri < 0x20)
135 pri += sdev->slot * 8;
136
137 sdev->irqs[0] = sbus_build_irq(sdev->bus, pri);
138 }
139 #else
140 len = prom_getproperty(prom_node, "intr",
141 (char *)irqs, sizeof(irqs));
142 if (len == -1)
143 len = 0;
144 sdev->num_irqs = len / 8;
145 if (sdev->num_irqs == 0) {
146 sdev->irqs[0] = 0;
147 } else if (sparc_cpu_model == sun4d) {
148 extern unsigned int sun4d_build_irq(struct sbus_dev *sdev, int irq);
149
150 for (len = 0; len < sdev->num_irqs; len++)
151 sdev->irqs[len] = sun4d_build_irq(sdev, irqs[len].pri);
152 } else {
153 for (len = 0; len < sdev->num_irqs; len++)
154 sdev->irqs[len] = irqs[len].pri;
155 }
156 #endif /* !__sparc_v9__ */
157 }
158
159 /* This routine gets called from whoever needs the sbus first, to scan
160 * the SBus device tree. Currently it just prints out the devices
161 * found on the bus and builds trees of SBUS structs and attached
162 * devices.
163 */
164
165 extern void iommu_init(int iommu_node, struct sbus_bus *sbus);
166 extern void iounit_init(int sbi_node, int iounit_node, struct sbus_bus *sbus);
167 void sun4_init(void);
168 #ifdef CONFIG_SUN_AUXIO
169 extern void auxio_probe(void);
170 #endif
171
172 static void __init sbus_do_child_siblings(int start_node,
173 struct sbus_dev *child,
174 struct sbus_dev *parent,
175 struct sbus_bus *sbus)
176 {
177 struct sbus_dev *this_dev = child;
178 int this_node = start_node;
179
180 /* Child already filled in, just need to traverse siblings. */
181 child->child = NULL;
182 child->parent = parent;
183 while((this_node = prom_getsibling(this_node)) != 0) {
184 this_dev->next = kmalloc(sizeof(struct sbus_dev), GFP_ATOMIC);
185 this_dev = this_dev->next;
186 this_dev->next = 0;
187 this_dev->parent = parent;
188
189 this_dev->bus = sbus;
190 fill_sbus_device(this_node, this_dev);
191
192 if(prom_getchild(this_node)) {
193 this_dev->child = kmalloc(sizeof(struct sbus_dev),
194 GFP_ATOMIC);
195 this_dev->child->bus = sbus;
196 this_dev->child->next = 0;
197 fill_sbus_device(prom_getchild(this_node), this_dev->child);
198 sbus_do_child_siblings(prom_getchild(this_node),
199 this_dev->child, this_dev, sbus);
200 } else {
201 this_dev->child = NULL;
202 }
203 }
204 }
205
206 /*
207 * XXX This functions appears to be a distorted version of
208 * prom_sbus_ranges_init(), with all sun4d stuff cut away.
209 * Ask DaveM what is going on here, how is sun4d supposed to work... XXX
210 */
211 static void __init sbus_bus_ranges_init(int parent_node, struct sbus_bus *sbus)
212 {
213 int len;
214
215 len = prom_getproperty(sbus->prom_node, "ranges",
216 (char *) sbus->sbus_ranges,
217 sizeof(sbus->sbus_ranges));
218 if (len == -1 || len == 0) {
219 sbus->num_sbus_ranges = 0;
220 return;
221 }
222 sbus->num_sbus_ranges = len / sizeof(struct linux_prom_ranges);
223 }
224
225 static void __init __apply_ranges_to_regs(struct linux_prom_ranges *ranges,
226 int num_ranges,
227 struct linux_prom_registers *regs,
228 int num_regs)
229 {
230 if (num_ranges) {
231 int regnum;
232
233 for (regnum = 0; regnum < num_regs; regnum++) {
234 int rngnum;
235
236 for (rngnum = 0; rngnum < num_ranges; rngnum++) {
237 if (regs[regnum].which_io == ranges[rngnum].ot_child_space)
238 break;
239 }
240 if (rngnum == num_ranges) {
241 prom_printf("sbus_apply_ranges: Cannot find matching "
242 "range nregs[%d] nranges[%d].\n",
243 num_regs, num_ranges);
244 prom_halt();
245 }
246 regs[regnum].which_io = ranges[rngnum].ot_parent_space;
247 regs[regnum].phys_addr += ranges[rngnum].ot_parent_base;
248 }
249 }
250 }
251
252 static void __init __fixup_regs_sdev(struct sbus_dev *sdev)
253 {
254 if (sdev->num_registers != 0) {
255 struct sbus_dev *parent = sdev->parent;
256 int i;
257
258 while (parent != NULL) {
259 __apply_ranges_to_regs(parent->device_ranges,
260 parent->num_device_ranges,
261 sdev->reg_addrs,
262 sdev->num_registers);
263
264 parent = parent->parent;
265 }
266
267 __apply_ranges_to_regs(sdev->bus->sbus_ranges,
268 sdev->bus->num_sbus_ranges,
269 sdev->reg_addrs,
270 sdev->num_registers);
271
272 for (i = 0; i < sdev->num_registers; i++) {
273 struct resource *res = &sdev->resource[i];
274
275 res->start = sdev->reg_addrs[i].phys_addr;
276 res->end = (res->start +
277 (unsigned long)sdev->reg_addrs[i].reg_size - 1UL);
278 res->flags = IORESOURCE_IO |
279 (sdev->reg_addrs[i].which_io & 0xff);
280 }
281 }
282 }
283
284 static void __init sbus_fixup_all_regs(struct sbus_dev *first_sdev)
285 {
286 struct sbus_dev *sdev;
287
288 for (sdev = first_sdev; sdev; sdev = sdev->next) {
289 if (sdev->child)
290 sbus_fixup_all_regs(sdev->child);
291 __fixup_regs_sdev(sdev);
292 }
293 }
294
295 extern void register_proc_sparc_ioport(void);
296
297 void __init sbus_init(void)
298 {
299 int nd, this_sbus, sbus_devs, topnd, iommund;
300 unsigned int sbus_clock;
301 struct sbus_bus *sbus;
302 struct sbus_dev *this_dev;
303 int num_sbus = 0; /* How many did we find? */
304
305 #ifndef __sparc_v9__
306 register_proc_sparc_ioport();
307 #endif
308
309 #ifdef CONFIG_SUN4
310 return sun4_dvma_init();
311 #endif
312
313 topnd = prom_getchild(prom_root_node);
314
315 /* Finding the first sbus is a special case... */
316 iommund = 0;
317 if(sparc_cpu_model == sun4u) {
318 nd = prom_searchsiblings(topnd, "sbus");
319 if(nd == 0) {
320 #ifdef CONFIG_PCI
321 if (!pcibios_present()) {
322 prom_printf("Neither SBUS nor PCI found.\n");
323 prom_halt();
324 } else {
325 #ifdef __sparc_v9__
326 extern void firetruck_init(void);
327 firetruck_init();
328 #endif
329 }
330 return;
331 #else
332 prom_printf("YEEE, UltraSparc sbus not found\n");
333 prom_halt();
334 #endif
335 }
336 } else if(sparc_cpu_model == sun4d) {
337 if((iommund = prom_searchsiblings(topnd, "io-unit")) == 0 ||
338 (nd = prom_getchild(iommund)) == 0 ||
339 (nd = prom_searchsiblings(nd, "sbi")) == 0) {
340 panic("sbi not found");
341 }
342 } else if((nd = prom_searchsiblings(topnd, "sbus")) == 0) {
343 if((iommund = prom_searchsiblings(topnd, "iommu")) == 0 ||
344 (nd = prom_getchild(iommund)) == 0 ||
345 (nd = prom_searchsiblings(nd, "sbus")) == 0) {
346 #ifdef CONFIG_PCI
347 if (!pcibios_present()) {
348 prom_printf("Neither SBUS nor PCI found.\n");
349 prom_halt();
350 }
351 return;
352 #else
353 /* No reason to run further - the data access trap will occur. */
354 panic("sbus not found");
355 #endif
356 }
357 }
358
359 /* Ok, we've found the first one, allocate first SBus struct
360 * and place in chain.
361 */
362 sbus = sbus_root = kmalloc(sizeof(struct sbus_bus), GFP_ATOMIC);
363 sbus->next = NULL;
364 sbus->prom_node = nd;
365 this_sbus = nd;
366
367 if(iommund && sparc_cpu_model != sun4u && sparc_cpu_model != sun4d)
368 iommu_init(iommund, sbus);
369
370 /* Loop until we find no more SBUS's */
371 while(this_sbus) {
372 #ifdef __sparc_v9__
373 /* IOMMU hides inside SBUS/SYSIO prom node on Ultra. */
374 if(sparc_cpu_model == sun4u) {
375 extern void sbus_iommu_init(int prom_node, struct sbus_bus *sbus);
376
377 sbus_iommu_init(this_sbus, sbus);
378 }
379 #endif
380 #ifndef __sparc_v9__
381 if (sparc_cpu_model == sun4d)
382 iounit_init(this_sbus, iommund, sbus);
383 #endif
384 printk("sbus%d: ", num_sbus);
385 sbus_clock = prom_getint(this_sbus, "clock-frequency");
386 if(sbus_clock == -1)
387 sbus_clock = (25*1000*1000);
388 printk("Clock %d.%d MHz\n", (int) ((sbus_clock/1000)/1000),
389 (int) (((sbus_clock/1000)%1000 != 0) ?
390 (((sbus_clock/1000)%1000) + 1000) : 0));
391
392 prom_getstring(this_sbus, "name",
393 sbus->prom_name, sizeof(sbus->prom_name));
394 sbus->clock_freq = sbus_clock;
395 #ifndef __sparc_v9__
396 if (sparc_cpu_model == sun4d) {
397 sbus->devid = prom_getint(iommund, "device-id");
398 sbus->board = prom_getint(iommund, "board#");
399 }
400 #endif
401
402 sbus_bus_ranges_init(iommund, sbus);
403
404 sbus_devs = prom_getchild(this_sbus);
405
406 sbus->devices = kmalloc(sizeof(struct sbus_dev), GFP_ATOMIC);
407
408 this_dev = sbus->devices;
409 this_dev->next = NULL;
410
411 this_dev->bus = sbus;
412 this_dev->parent = NULL;
413 fill_sbus_device(sbus_devs, this_dev);
414
415 /* Should we traverse for children? */
416 if(prom_getchild(sbus_devs)) {
417 /* Allocate device node */
418 this_dev->child = kmalloc(sizeof(struct sbus_dev),
419 GFP_ATOMIC);
420 /* Fill it */
421 this_dev->child->bus = sbus;
422 this_dev->child->next = 0;
423 fill_sbus_device(prom_getchild(sbus_devs),
424 this_dev->child);
425 sbus_do_child_siblings(prom_getchild(sbus_devs),
426 this_dev->child,
427 this_dev,
428 sbus);
429 } else {
430 this_dev->child = NULL;
431 }
432
433 while((sbus_devs = prom_getsibling(sbus_devs)) != 0) {
434 /* Allocate device node */
435 this_dev->next = kmalloc(sizeof(struct sbus_dev),
436 GFP_ATOMIC);
437 this_dev = this_dev->next;
438 this_dev->next = NULL;
439
440 /* Fill it */
441 this_dev->bus = sbus;
442 this_dev->parent = NULL;
443 fill_sbus_device(sbus_devs, this_dev);
444
445 /* Is there a child node hanging off of us? */
446 if(prom_getchild(sbus_devs)) {
447 /* Get new device struct */
448 this_dev->child = kmalloc(sizeof(struct sbus_dev),
449 GFP_ATOMIC);
450 /* Fill it */
451 this_dev->child->bus = sbus;
452 this_dev->child->next = 0;
453 fill_sbus_device(prom_getchild(sbus_devs),
454 this_dev->child);
455 sbus_do_child_siblings(prom_getchild(sbus_devs),
456 this_dev->child,
457 this_dev,
458 sbus);
459 } else {
460 this_dev->child = NULL;
461 }
462 }
463
464 /* Walk all devices and apply parent ranges. */
465 sbus_fixup_all_regs(sbus->devices);
466
467 dvma_init(sbus);
468
469 num_sbus++;
470 if(sparc_cpu_model == sun4u) {
471 this_sbus = prom_getsibling(this_sbus);
472 if(!this_sbus)
473 break;
474 this_sbus = prom_searchsiblings(this_sbus, "sbus");
475 } else if(sparc_cpu_model == sun4d) {
476 iommund = prom_getsibling(iommund);
477 if(!iommund)
478 break;
479 iommund = prom_searchsiblings(iommund, "io-unit");
480 if(!iommund)
481 break;
482 this_sbus = prom_searchsiblings(prom_getchild(iommund), "sbi");
483 } else {
484 this_sbus = prom_getsibling(this_sbus);
485 if(!this_sbus)
486 break;
487 this_sbus = prom_searchsiblings(this_sbus, "sbus");
488 }
489 if(this_sbus) {
490 sbus->next = kmalloc(sizeof(struct sbus_bus), GFP_ATOMIC);
491 sbus = sbus->next;
492 sbus->next = NULL;
493 sbus->prom_node = this_sbus;
494 } else {
495 break;
496 }
497 } /* while(this_sbus) */
498
499 if (sparc_cpu_model == sun4d) {
500 extern void sun4d_init_sbi_irq(void);
501 sun4d_init_sbi_irq();
502 }
503
504 #ifdef __sparc_v9__
505 if (sparc_cpu_model == sun4u) {
506 extern void firetruck_init(void);
507
508 firetruck_init();
509 }
510 #endif
511 #ifdef CONFIG_SUN_AUXIO
512 if (sparc_cpu_model == sun4u)
513 auxio_probe ();
514 #endif
515 #ifdef __sparc_v9__
516 if (sparc_cpu_model == sun4u) {
517 extern void clock_probe(void);
518
519 clock_probe();
520 }
521 #endif
522 }
523
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.