drivers/sbus/sbus.c

   1 /* $Id: sbus.c,v 1.100 2002/01/24 15:36:24 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/slab.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 #ifdef CONFIG_SPARC32
  24 static int interrupts[PROMINTR_MAX] __initdata = { 0 };
  25 #endif
  26
  27 #ifdef CONFIG_PCI
  28 extern int pcic_present(void);
  29 #endif
  30
  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.
  34  */
  35
  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.
  39  */
  40
  41 /* #define DEBUG_FILL */
  42
  43 static void __init fill_sbus_device(int prom_node, struct sbus_dev *sdev)
  44 {
  45         unsigned long address, base;
  46         int len;
  47
  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));
  55         if (len == -1) {
  56                 sdev->num_registers = 0;
  57                 goto no_regs;
  58         }
  59
  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",
  63                             sdev->prom_name, len,
  64                             (int) sizeof(struct linux_prom_registers));
  65                 prom_halt();
  66         }
  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);
  71                 prom_halt();
  72         }
  73         sdev->num_registers = len / sizeof(struct linux_prom_registers);
  74         sdev->ranges_applied = 0;
  75
  76         base = (unsigned long) sdev->reg_addrs[0].phys_addr;
  77
  78         /* Compute the slot number. */
  79         if (base >= SUN_SBUS_BVADDR && sparc_cpu_model == sun4m) {
  80                 sdev->slot = sbus_dev_slot(base);
  81         } else {
  82                 sdev->slot = sdev->reg_addrs[0].which_io;
  83         }
  84
  85 no_regs:
  86         len = prom_getproperty(prom_node, "ranges",
  87                                (char *)sdev->device_ranges,
  88                                sizeof(sdev->device_ranges));
  89         if (len == -1) {
  90                 sdev->num_device_ranges = 0;
  91                 goto no_ranges;
  92         }
  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",
  96                             sdev->prom_name, len,
  97                             (int) sizeof(struct linux_prom_ranges));
  98                 prom_halt();
  99         }
 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);
 104                 prom_halt();
 105         }
 106         sdev->num_device_ranges =
 107                 len / sizeof(struct linux_prom_ranges);
 108
 109 no_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
 113          */
 114 #ifdef CONFIG_SPARC64
 115         len = prom_getproperty(prom_node, "interrupts",
 116                                (char *) irqs, sizeof(irqs));
 117         if (len == -1 || len == 0) {
 118                 sdev->irqs[0] = 0;
 119                 sdev->num_irqs = 0;
 120         } else {
 121                 unsigned int pri = irqs[0].pri;
 122
 123                 sdev->num_irqs = 1;
 124                 if (pri < 0x20)
 125                         pri += sdev->slot * 8;
 126
 127                 sdev->irqs[0] = sbus_build_irq(sdev->bus, pri);
 128         }
 129 #endif /* CONFIG_SPARC64 */
 130
 131 #ifdef CONFIG_SPARC32
 132         len = prom_getproperty(prom_node, "intr",
 133                                (char *)irqs, sizeof(irqs));
 134         if (len != -1) {
 135                 sdev->num_irqs = len / 8;
 136                 if (sdev->num_irqs == 0) {
 137                         sdev->irqs[0] = 0;
 138                 } else if (sparc_cpu_model == sun4d) {
 139                         extern unsigned int sun4d_build_irq(struct sbus_dev *sdev, int irq);
 140
 141                         for (len = 0; len < sdev->num_irqs; len++)
 142                                 sdev->irqs[len] = sun4d_build_irq(sdev, irqs[len].pri);
 143                 } else {
 144                         for (len = 0; len < sdev->num_irqs; len++)
 145                                 sdev->irqs[len] = irqs[len].pri;
 146                 }
 147         } else {
 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).
 152                  */
 153                 len = prom_getproperty(prom_node, "interrupts",
 154                                         (char *)interrupts, sizeof(interrupts));
 155                 if (len == -1) {
 156                         sdev->irqs[0] = 0;
 157                         sdev->num_irqs = 0;
 158                 } else {
 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]);
 162                         }
 163                 }
 164         }
 165 #endif /* CONFIG_SPARC32 */
 166 }
 167
 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
 171  * devices.
 172  */
 173
 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);
 179 #endif
 180
 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)
 185 {
 186         struct sbus_dev *this_dev = child;
 187         int this_node = start_node;
 188
 189         /* Child already filled in, just need to traverse siblings. */
 190         child->child = NULL;
 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;
 197
 198                 this_dev->bus = sbus;
 199                 fill_sbus_device(this_node, this_dev);
 200
 201                 if(prom_getchild(this_node)) {
 202                         this_dev->child = kmalloc(sizeof(struct sbus_dev),
 203                                                   GFP_ATOMIC);
 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);
 209                 } else {
 210                         this_dev->child = NULL;
 211                 }
 212         }
 213 }
 214
 215 /*
 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
 219  */
 220 /* added back sun4d patch from Thomas Bogendoerfer - should be OK (crn) */
 221
 222 static void __init sbus_bus_ranges_init(int parent_node, struct sbus_bus *sbus)
 223 {
 224         int len;
 225
 226         len = prom_getproperty(sbus->prom_node, "ranges",
 227                                (char *) sbus->sbus_ranges,
 228                                sizeof(sbus->sbus_ranges));
 229         if (len == -1 || len == 0) {
 230                 sbus->num_sbus_ranges = 0;
 231                 return;
 232         }
 233         sbus->num_sbus_ranges = len / sizeof(struct linux_prom_ranges);
 234 #ifdef CONFIG_SPARC32
 235         if (sparc_cpu_model == sun4d) {
 236                 struct linux_prom_ranges iounit_ranges[PROMREG_MAX];
 237                 int num_iounit_ranges;
 238
 239                 len = prom_getproperty(parent_node, "ranges",
 240                                        (char *) iounit_ranges,
 241                                        sizeof (iounit_ranges));
 242                 if (len != -1) {
 243                         num_iounit_ranges = (len/sizeof(struct linux_prom_ranges));
 244                         prom_adjust_ranges (sbus->sbus_ranges, sbus->num_sbus_ranges, iounit_ranges, num_iounit_ranges);
 245                 }
 246         }
 247 #endif
 248 }
 249
 250 static void __init __apply_ranges_to_regs(struct linux_prom_ranges *ranges,
 251                                           int num_ranges,
 252                                           struct linux_prom_registers *regs,
 253                                           int num_regs)
 254 {
 255         if (num_ranges) {
 256                 int regnum;
 257
 258                 for (regnum = 0; regnum < num_regs; regnum++) {
 259                         int rngnum;
 260
 261                         for (rngnum = 0; rngnum < num_ranges; rngnum++) {
 262                                 if (regs[regnum].which_io == ranges[rngnum].ot_child_space)
 263                                         break;
 264                         }
 265                         if (rngnum == num_ranges) {
 266                                 /* We used to flag this as an error.  Actually
 267                                  * some devices do not report the regs as we expect.
 268                                  * For example, see SUNW,pln device.  In that case
 269                                  * the reg property is in a format internal to that
 270                                  * node, ie. it is not in the SBUS register space
 271                                  * per se. -DaveM
 272                                  */
 273                                 return;
 274                         }
 275                         regs[regnum].which_io = ranges[rngnum].ot_parent_space;
 276                         regs[regnum].phys_addr -= ranges[rngnum].ot_child_base;
 277                         regs[regnum].phys_addr += ranges[rngnum].ot_parent_base;
 278                 }
 279         }
 280 }
 281
 282 static void __init __fixup_regs_sdev(struct sbus_dev *sdev)
 283 {
 284         if (sdev->num_registers != 0) {
 285                 struct sbus_dev *parent = sdev->parent;
 286                 int i;
 287
 288                 while (parent != NULL) {
 289                         __apply_ranges_to_regs(parent->device_ranges,
 290                                                parent->num_device_ranges,
 291                                                sdev->reg_addrs,
 292                                                sdev->num_registers);
 293
 294                         parent = parent->parent;
 295                 }
 296
 297                 __apply_ranges_to_regs(sdev->bus->sbus_ranges,
 298                                        sdev->bus->num_sbus_ranges,
 299                                        sdev->reg_addrs,
 300                                        sdev->num_registers);
 301
 302                 for (i = 0; i < sdev->num_registers; i++) {
 303                         struct resource *res = &sdev->resource[i];
 304
 305                         res->start = sdev->reg_addrs[i].phys_addr;
 306                         res->end = (res->start +
 307                                     (unsigned long)sdev->reg_addrs[i].reg_size - 1UL);
 308                         res->flags = IORESOURCE_IO |
 309                                 (sdev->reg_addrs[i].which_io & 0xff);
 310                 }
 311         }
 312 }
 313
 314 static void __init sbus_fixup_all_regs(struct sbus_dev *first_sdev)
 315 {
 316         struct sbus_dev *sdev;
 317
 318         for (sdev = first_sdev; sdev; sdev = sdev->next) {
 319                 if (sdev->child)
 320                         sbus_fixup_all_regs(sdev->child);
 321                 __fixup_regs_sdev(sdev);
 322         }
 323 }
 324
 325 extern void register_proc_sparc_ioport(void);
 326 extern void firetruck_init(void);
 327
 328 #ifdef CONFIG_SUN4
 329 extern void sun4_dvma_init(void);
 330 #endif
 331
 332 static int __init sbus_init(void)
 333 {
 334         int nd, this_sbus, sbus_devs, topnd, iommund;
 335         unsigned int sbus_clock;
 336         struct sbus_bus *sbus;
 337         struct sbus_dev *this_dev;
 338         int num_sbus = 0;  /* How many did we find? */
 339
 340 #ifdef CONFIG_SPARC32
 341         register_proc_sparc_ioport();
 342 #endif
 343
 344 #ifdef CONFIG_SUN4
 345         sun4_dvma_init();
 346         return 0;
 347 #endif
 348
 349         topnd = prom_getchild(prom_root_node);
 350
 351         /* Finding the first sbus is a special case... */
 352         iommund = 0;
 353         if(sparc_cpu_model == sun4u) {
 354                 nd = prom_searchsiblings(topnd, "sbus");
 355                 if(nd == 0) {
 356 #ifdef CONFIG_PCI
 357                         if (!pcic_present()) {
 358                                 prom_printf("Neither SBUS nor PCI found.\n");
 359                                 prom_halt();
 360                         } else {
 361 #ifdef CONFIG_SPARC64
 362                                 firetruck_init();
 363 #endif
 364                         }
 365                         return 0;
 366 #else
 367                         prom_printf("YEEE, UltraSparc sbus not found\n");
 368                         prom_halt();
 369 #endif
 370                 }
 371         } else if(sparc_cpu_model == sun4d) {
 372                 if((iommund = prom_searchsiblings(topnd, "io-unit")) == 0 ||
 373                    (nd = prom_getchild(iommund)) == 0 ||
 374                    (nd = prom_searchsiblings(nd, "sbi")) == 0) {
 375                         panic("sbi not found");
 376                 }
 377         } else if((nd = prom_searchsiblings(topnd, "sbus")) == 0) {
 378                 if((iommund = prom_searchsiblings(topnd, "iommu")) == 0 ||
 379                    (nd = prom_getchild(iommund)) == 0 ||
 380                    (nd = prom_searchsiblings(nd, "sbus")) == 0) {
 381 #ifdef CONFIG_PCI
 382                         if (!pcic_present()) {
 383                                 prom_printf("Neither SBUS nor PCI found.\n");
 384                                 prom_halt();
 385                         }
 386                         return 0;
 387 #else
 388                         /* No reason to run further - the data access trap will occur. */
 389                         panic("sbus not found");
 390 #endif
 391                 }
 392         }
 393
 394         /* Ok, we've found the first one, allocate first SBus struct
 395          * and place in chain.
 396          */
 397         sbus = sbus_root = kmalloc(sizeof(struct sbus_bus), GFP_ATOMIC);
 398         sbus->next = NULL;
 399         sbus->prom_node = nd;
 400         this_sbus = nd;
 401
 402         if(iommund && sparc_cpu_model != sun4u && sparc_cpu_model != sun4d)
 403                 iommu_init(iommund, sbus);
 404
 405         /* Loop until we find no more SBUS's */
 406         while(this_sbus) {
 407 #ifdef CONFIG_SPARC64
 408                 /* IOMMU hides inside SBUS/SYSIO prom node on Ultra. */
 409                 if(sparc_cpu_model == sun4u) {
 410                         extern void sbus_iommu_init(int prom_node, struct sbus_bus *sbus);
 411
 412                         sbus_iommu_init(this_sbus, sbus);
 413                 }
 414 #endif /* CONFIG_SPARC64 */
 415
 416 #ifdef CONFIG_SPARC32
 417                 if (sparc_cpu_model == sun4d)
 418                         iounit_init(this_sbus, iommund, sbus);
 419 #endif /* CONFIG_SPARC32 */
 420                 printk("sbus%d: ", num_sbus);
 421                 sbus_clock = prom_getint(this_sbus, "clock-frequency");
 422                 if(sbus_clock == -1)
 423                         sbus_clock = (25*1000*1000);
 424                 printk("Clock %d.%d MHz\n", (int) ((sbus_clock/1000)/1000),
 425                        (int) (((sbus_clock/1000)%1000 != 0) ?
 426                               (((sbus_clock/1000)%1000) + 1000) : 0));
 427
 428                 prom_getstring(this_sbus, "name",
 429                                sbus->prom_name, sizeof(sbus->prom_name));
 430                 sbus->clock_freq = sbus_clock;
 431 #ifdef CONFIG_SPARC32
 432                 if (sparc_cpu_model == sun4d) {
 433                         sbus->devid = prom_getint(iommund, "device-id");
 434                         sbus->board = prom_getint(iommund, "board#");
 435                 }
 436 #endif
 437
 438                 sbus_bus_ranges_init(iommund, sbus);
 439
 440                 sbus_devs = prom_getchild(this_sbus);
 441                 if (!sbus_devs) {
 442                         sbus->devices = NULL;
 443                         goto next_bus;
 444                 }
 445
 446                 sbus->devices = kmalloc(sizeof(struct sbus_dev), GFP_ATOMIC);
 447
 448                 this_dev = sbus->devices;
 449                 this_dev->next = NULL;
 450
 451                 this_dev->bus = sbus;
 452                 this_dev->parent = NULL;
 453                 fill_sbus_device(sbus_devs, this_dev);
 454
 455                 /* Should we traverse for children? */
 456                 if(prom_getchild(sbus_devs)) {
 457                         /* Allocate device node */
 458                         this_dev->child = kmalloc(sizeof(struct sbus_dev),
 459                                                   GFP_ATOMIC);
 460                         /* Fill it */
 461                         this_dev->child->bus = sbus;
 462                         this_dev->child->next = NULL;
 463                         fill_sbus_device(prom_getchild(sbus_devs),
 464                                          this_dev->child);
 465                         sbus_do_child_siblings(prom_getchild(sbus_devs),
 466                                                this_dev->child,
 467                                                this_dev,
 468                                                sbus);
 469                 } else {
 470                         this_dev->child = NULL;
 471                 }
 472
 473                 while((sbus_devs = prom_getsibling(sbus_devs)) != 0) {
 474                         /* Allocate device node */
 475                         this_dev->next = kmalloc(sizeof(struct sbus_dev),
 476                                                  GFP_ATOMIC);
 477                         this_dev = this_dev->next;
 478                         this_dev->next = NULL;
 479
 480                         /* Fill it */
 481                         this_dev->bus = sbus;
 482                         this_dev->parent = NULL;
 483                         fill_sbus_device(sbus_devs, this_dev);
 484
 485                         /* Is there a child node hanging off of us? */
 486                         if(prom_getchild(sbus_devs)) {
 487                                 /* Get new device struct */
 488                                 this_dev->child = kmalloc(sizeof(struct sbus_dev),
 489                                                           GFP_ATOMIC);
 490                                 /* Fill it */
 491                                 this_dev->child->bus = sbus;
 492                                 this_dev->child->next = NULL;
 493                                 fill_sbus_device(prom_getchild(sbus_devs),
 494                                                  this_dev->child);
 495                                 sbus_do_child_siblings(prom_getchild(sbus_devs),
 496                                                        this_dev->child,
 497                                                        this_dev,
 498                                                        sbus);
 499                         } else {
 500                                 this_dev->child = NULL;
 501                         }
 502                 }
 503
 504                 /* Walk all devices and apply parent ranges. */
 505                 sbus_fixup_all_regs(sbus->devices);
 506
 507                 dvma_init(sbus);
 508         next_bus:
 509                 num_sbus++;
 510                 if(sparc_cpu_model == sun4u) {
 511                         this_sbus = prom_getsibling(this_sbus);
 512                         if(!this_sbus)
 513                                 break;
 514                         this_sbus = prom_searchsiblings(this_sbus, "sbus");
 515                 } else if(sparc_cpu_model == sun4d) {
 516                         iommund = prom_getsibling(iommund);
 517                         if(!iommund)
 518                                 break;
 519                         iommund = prom_searchsiblings(iommund, "io-unit");
 520                         if(!iommund)
 521                                 break;
 522                         this_sbus = prom_searchsiblings(prom_getchild(iommund), "sbi");
 523                 } else {
 524                         this_sbus = prom_getsibling(this_sbus);
 525                         if(!this_sbus)
 526                                 break;
 527                         this_sbus = prom_searchsiblings(this_sbus, "sbus");
 528                 }
 529                 if(this_sbus) {
 530                         sbus->next = kmalloc(sizeof(struct sbus_bus), GFP_ATOMIC);
 531                         sbus = sbus->next;
 532                         sbus->next = NULL;
 533                         sbus->prom_node = this_sbus;
 534                 } else {
 535                         break;
 536                 }
 537         } /* while(this_sbus) */
 538
 539         if (sparc_cpu_model == sun4d) {
 540                 extern void sun4d_init_sbi_irq(void);
 541                 sun4d_init_sbi_irq();
 542         }
 543
 544 #ifdef CONFIG_SPARC64
 545         if (sparc_cpu_model == sun4u) {
 546                 firetruck_init();
 547         }
 548 #endif
 549 #ifdef CONFIG_SUN_AUXIO
 550         if (sparc_cpu_model == sun4u)
 551                 auxio_probe ();
 552 #endif
 553 #ifdef CONFIG_SPARC64
 554         if (sparc_cpu_model == sun4u) {
 555                 extern void clock_probe(void);
 556
 557                 clock_probe();
 558         }
 559 #endif
 560
 561         return 0;
 562 }
 563
 564 subsys_initcall(sbus_init);