drivers/sbus/sbus.c

   1 /* $Id: sbus.c,v 1.84 2000/03/15 01:51:16 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_OPENPROMIO
 169 extern int openprom_init(void);
 170 #endif
 171 #ifdef CONFIG_SUN_AUXIO
 172 extern void auxio_probe(void);
 173 #endif
 174 #ifdef CONFIG_OBP_FLASH
 175 extern int flash_init(void);
 176 #endif
 177 #ifdef CONFIG_SUN_AURORA
 178 extern int aurora_init(void);
 179 #endif
 180 #ifdef CONFIG_TADPOLE_TS102_UCTRL
 181 extern int ts102_uctrl_init(void);
 182 #endif
 183
 184 static void __init sbus_do_child_siblings(int start_node,
 185                                           struct sbus_dev *child,
 186                                           struct sbus_dev *parent,
 187                                           struct sbus_bus *sbus)
 188 {
 189         struct sbus_dev *this_dev = child;
 190         int this_node = start_node;
 191
 192         /* Child already filled in, just need to traverse siblings. */
 193         child->child = NULL;
 194         child->parent = parent;
 195         while((this_node = prom_getsibling(this_node)) != 0) {
 196                 this_dev->next = kmalloc(sizeof(struct sbus_dev), GFP_ATOMIC);
 197                 this_dev = this_dev->next;
 198                 this_dev->next = 0;
 199                 this_dev->parent = parent;
 200
 201                 this_dev->bus = sbus;
 202                 fill_sbus_device(this_node, this_dev);
 203
 204                 if(prom_getchild(this_node)) {
 205                         this_dev->child = kmalloc(sizeof(struct sbus_dev),
 206                                                   GFP_ATOMIC);
 207                         this_dev->child->bus = sbus;
 208                         this_dev->child->next = 0;
 209                         fill_sbus_device(prom_getchild(this_node), this_dev->child);
 210                         sbus_do_child_siblings(prom_getchild(this_node),
 211                                                this_dev->child, this_dev, sbus);
 212                 } else {
 213                         this_dev->child = NULL;
 214                 }
 215         }
 216 }
 217
 218 /*
 219  * XXX This functions appears to be a distorted version of
 220  * prom_sbus_ranges_init(), with all sun4d stuff cut away.
 221  * Ask DaveM what is going on here, how is sun4d supposed to work... XXX
 222  */
 223 static void __init sbus_bus_ranges_init(int parent_node, struct sbus_bus *sbus)
 224 {
 225         int len;
 226
 227         len = prom_getproperty(sbus->prom_node, "ranges",
 228                                (char *) sbus->sbus_ranges,
 229                                sizeof(sbus->sbus_ranges));
 230         if (len == -1 || len == 0) {
 231                 sbus->num_sbus_ranges = 0;
 232                 return;
 233         }
 234         sbus->num_sbus_ranges = len / sizeof(struct linux_prom_ranges);
 235 }
 236
 237 static void __init __apply_ranges_to_regs(struct linux_prom_ranges *ranges,
 238                                           int num_ranges,
 239                                           struct linux_prom_registers *regs,
 240                                           int num_regs)
 241 {
 242         if (num_ranges) {
 243                 int regnum;
 244
 245                 for (regnum = 0; regnum < num_regs; regnum++) {
 246                         int rngnum;
 247
 248                         for (rngnum = 0; rngnum < num_ranges; rngnum++) {
 249                                 if (regs[regnum].which_io == ranges[rngnum].ot_child_space)
 250                                         break;
 251                         }
 252                         if (rngnum == num_ranges) {
 253                                 prom_printf("sbus_apply_ranges: Cannot find matching "
 254                                             "range nregs[%d] nranges[%d].\n",
 255                                             num_regs, num_ranges);
 256                                 prom_halt();
 257                         }
 258                         regs[regnum].which_io = ranges[rngnum].ot_parent_space;
 259                         regs[regnum].phys_addr += ranges[rngnum].ot_parent_base;
 260                 }
 261         }
 262 }
 263
 264 static void __init __fixup_regs_sdev(struct sbus_dev *sdev)
 265 {
 266         if (sdev->num_registers != 0) {
 267                 struct sbus_dev *parent = sdev->parent;
 268                 int i;
 269
 270                 while (parent != NULL) {
 271                         __apply_ranges_to_regs(parent->device_ranges,
 272                                                parent->num_device_ranges,
 273                                                sdev->reg_addrs,
 274                                                sdev->num_registers);
 275
 276                         parent = parent->parent;
 277                 }
 278
 279                 __apply_ranges_to_regs(sdev->bus->sbus_ranges,
 280                                        sdev->bus->num_sbus_ranges,
 281                                        sdev->reg_addrs,
 282                                        sdev->num_registers);
 283
 284                 for (i = 0; i < sdev->num_registers; i++) {
 285                         struct resource *res = &sdev->resource[i];
 286
 287                         res->start = sdev->reg_addrs[i].phys_addr;
 288                         res->end = (res->start +
 289                                     (unsigned long)sdev->reg_addrs[i].reg_size - 1UL);
 290                         res->flags = IORESOURCE_IO |
 291                                 (sdev->reg_addrs[i].which_io & 0xff);
 292                 }
 293         }
 294 }
 295
 296 static void __init sbus_fixup_all_regs(struct sbus_dev *first_sdev)
 297 {
 298         struct sbus_dev *sdev;
 299
 300         for (sdev = first_sdev; sdev; sdev = sdev->next) {
 301                 if (sdev->child)
 302                         sbus_fixup_all_regs(sdev->child);
 303                 __fixup_regs_sdev(sdev);
 304         }
 305 }
 306
 307 void __init sbus_init(void)
 308 {
 309         int nd, this_sbus, sbus_devs, topnd, iommund;
 310         unsigned int sbus_clock;
 311         struct sbus_bus *sbus;
 312         struct sbus_dev *this_dev;
 313         int num_sbus = 0;  /* How many did we find? */
 314
 315 #ifdef CONFIG_SUN4
 316         return sun4_dvma_init();
 317 #endif
 318
 319         topnd = prom_getchild(prom_root_node);
 320
 321         /* Finding the first sbus is a special case... */
 322         iommund = 0;
 323         if(sparc_cpu_model == sun4u) {
 324                 nd = prom_searchsiblings(topnd, "sbus");
 325                 if(nd == 0) {
 326 #ifdef CONFIG_PCI
 327                         if (!pcibios_present()) {
 328                                 prom_printf("Neither SBUS nor PCI found.\n");
 329                                 prom_halt();
 330                         } else {
 331 #ifdef __sparc_v9__
 332                                 extern void firetruck_init(void);
 333                                 firetruck_init();
 334 #endif
 335                         }
 336                         return;
 337 #else
 338                         prom_printf("YEEE, UltraSparc sbus not found\n");
 339                         prom_halt();
 340 #endif
 341                 }
 342         } else if(sparc_cpu_model == sun4d) {
 343                 if((iommund = prom_searchsiblings(topnd, "io-unit")) == 0 ||
 344                    (nd = prom_getchild(iommund)) == 0 ||
 345                    (nd = prom_searchsiblings(nd, "sbi")) == 0) {
 346                         panic("sbi not found");
 347                 }
 348         } else if((nd = prom_searchsiblings(topnd, "sbus")) == 0) {
 349                 if((iommund = prom_searchsiblings(topnd, "iommu")) == 0 ||
 350                    (nd = prom_getchild(iommund)) == 0 ||
 351                    (nd = prom_searchsiblings(nd, "sbus")) == 0) {
 352 #ifdef CONFIG_PCI
 353                         if (!pcibios_present()) {
 354                                 prom_printf("Neither SBUS nor PCI found.\n");
 355                                 prom_halt();
 356                         }
 357                         return;
 358 #else
 359                         /* No reason to run further - the data access trap will occur. */
 360                         panic("sbus not found");
 361 #endif
 362                 }
 363         }
 364
 365         /* Ok, we've found the first one, allocate first SBus struct
 366          * and place in chain.
 367          */
 368         sbus = sbus_root = kmalloc(sizeof(struct sbus_bus), GFP_ATOMIC);
 369         sbus->next = NULL;
 370         sbus->prom_node = nd;
 371         this_sbus = nd;
 372
 373         if(iommund && sparc_cpu_model != sun4u && sparc_cpu_model != sun4d)
 374                 iommu_init(iommund, sbus);
 375
 376         /* Loop until we find no more SBUS's */
 377         while(this_sbus) {
 378 #ifdef __sparc_v9__
 379                 /* IOMMU hides inside SBUS/SYSIO prom node on Ultra. */
 380                 if(sparc_cpu_model == sun4u) {
 381                         extern void sbus_iommu_init(int prom_node, struct sbus_bus *sbus);
 382
 383                         sbus_iommu_init(this_sbus, sbus);
 384                 }
 385 #endif
 386 #ifndef __sparc_v9__
 387                 if (sparc_cpu_model == sun4d)
 388                         iounit_init(this_sbus, iommund, sbus);
 389 #endif
 390                 printk("sbus%d: ", num_sbus);
 391                 sbus_clock = prom_getint(this_sbus, "clock-frequency");
 392                 if(sbus_clock == -1)
 393                         sbus_clock = (25*1000*1000);
 394                 printk("Clock %d.%d MHz\n", (int) ((sbus_clock/1000)/1000),
 395                        (int) (((sbus_clock/1000)%1000 != 0) ?
 396                               (((sbus_clock/1000)%1000) + 1000) : 0));
 397
 398                 prom_getstring(this_sbus, "name",
 399                                sbus->prom_name, sizeof(sbus->prom_name));
 400                 sbus->clock_freq = sbus_clock;
 401 #ifndef __sparc_v9__
 402                 if (sparc_cpu_model == sun4d) {
 403                         sbus->devid = prom_getint(iommund, "device-id");
 404                         sbus->board = prom_getint(iommund, "board#");
 405                 }
 406 #endif
 407
 408                 sbus_bus_ranges_init(iommund, sbus);
 409
 410                 sbus_devs = prom_getchild(this_sbus);
 411
 412                 sbus->devices = kmalloc(sizeof(struct sbus_dev), GFP_ATOMIC);
 413
 414                 this_dev = sbus->devices;
 415                 this_dev->next = NULL;
 416
 417                 this_dev->bus = sbus;
 418                 this_dev->parent = NULL;
 419                 fill_sbus_device(sbus_devs, this_dev);
 420
 421                 /* Should we traverse for children? */
 422                 if(prom_getchild(sbus_devs)) {
 423                         /* Allocate device node */
 424                         this_dev->child = kmalloc(sizeof(struct sbus_dev),
 425                                                   GFP_ATOMIC);
 426                         /* Fill it */
 427                         this_dev->child->bus = sbus;
 428                         this_dev->child->next = 0;
 429                         fill_sbus_device(prom_getchild(sbus_devs),
 430                                          this_dev->child);
 431                         sbus_do_child_siblings(prom_getchild(sbus_devs),
 432                                                this_dev->child,
 433                                                this_dev,
 434                                                sbus);
 435                 } else {
 436                         this_dev->child = NULL;
 437                 }
 438
 439                 while((sbus_devs = prom_getsibling(sbus_devs)) != 0) {
 440                         /* Allocate device node */
 441                         this_dev->next = kmalloc(sizeof(struct sbus_dev),
 442                                                  GFP_ATOMIC);
 443                         this_dev = this_dev->next;
 444                         this_dev->next = NULL;
 445
 446                         /* Fill it */
 447                         this_dev->bus = sbus;
 448                         this_dev->parent = NULL;
 449                         fill_sbus_device(sbus_devs, this_dev);
 450
 451                         /* Is there a child node hanging off of us? */
 452                         if(prom_getchild(sbus_devs)) {
 453                                 /* Get new device struct */
 454                                 this_dev->child = kmalloc(sizeof(struct sbus_dev),
 455                                                           GFP_ATOMIC);
 456                                 /* Fill it */
 457                                 this_dev->child->bus = sbus;
 458                                 this_dev->child->next = 0;
 459                                 fill_sbus_device(prom_getchild(sbus_devs),
 460                                                  this_dev->child);
 461                                 sbus_do_child_siblings(prom_getchild(sbus_devs),
 462                                                        this_dev->child,
 463                                                        this_dev,
 464                                                        sbus);
 465                         } else {
 466                                 this_dev->child = NULL;
 467                         }
 468                 }
 469
 470                 /* Walk all devices and apply parent ranges. */
 471                 sbus_fixup_all_regs(sbus->devices);
 472
 473                 dvma_init(sbus);
 474
 475                 num_sbus++;
 476                 if(sparc_cpu_model == sun4u) {
 477                         this_sbus = prom_getsibling(this_sbus);
 478                         if(!this_sbus)
 479                                 break;
 480                         this_sbus = prom_searchsiblings(this_sbus, "sbus");
 481                 } else if(sparc_cpu_model == sun4d) {
 482                         iommund = prom_getsibling(iommund);
 483                         if(!iommund)
 484                                 break;
 485                         iommund = prom_searchsiblings(iommund, "io-unit");
 486                         if(!iommund)
 487                                 break;
 488                         this_sbus = prom_searchsiblings(prom_getchild(iommund), "sbi");
 489                 } else {
 490                         this_sbus = prom_getsibling(this_sbus);
 491                         if(!this_sbus)
 492                                 break;
 493                         this_sbus = prom_searchsiblings(this_sbus, "sbus");
 494                 }
 495                 if(this_sbus) {
 496                         sbus->next = kmalloc(sizeof(struct sbus_bus), GFP_ATOMIC);
 497                         sbus = sbus->next;
 498                         sbus->next = NULL;
 499                         sbus->prom_node = this_sbus;
 500                 } else {
 501                         break;
 502                 }
 503         } /* while(this_sbus) */
 504
 505         if (sparc_cpu_model == sun4d) {
 506                 extern void sun4d_init_sbi_irq(void);
 507                 sun4d_init_sbi_irq();
 508         }
 509
 510 #ifdef __sparc_v9__
 511         if (sparc_cpu_model == sun4u) {
 512                 extern void firetruck_init(void);
 513
 514                 firetruck_init();
 515         }
 516 #endif
 517 #ifdef CONFIG_SUN_OPENPROMIO
 518         openprom_init();
 519 #endif
 520 #ifdef CONFIG_SUN_BPP
 521         bpp_init();
 522 #endif
 523 #ifdef CONFIG_SUN_AUXIO
 524         if (sparc_cpu_model == sun4u)
 525                 auxio_probe ();
 526 #endif
 527 #ifdef CONFIG_OBP_FLASH
 528         flash_init();
 529 #endif
 530 #ifdef CONFIG_SUN_AURORA
 531         aurora_init();
 532 #endif
 533 #ifdef CONFIG_TADPOLE_TS102_UCTRL
 534         ts102_uctrl_init();
 535 #endif
 536 #ifdef __sparc_v9__
 537         if (sparc_cpu_model == sun4u) {
 538                 extern void clock_probe(void);
 539
 540                 clock_probe();
 541         }
 542 #endif
 543 }